add .clang-format
Change-Id: I6627b5569c2e0f730be7331403218b823a2c622f
Signed-off-by: Patrick Venture <venture@google.com>
diff --git a/pid/builder.cpp b/pid/builder.cpp
index 45838e7..8ffa77c 100644
--- a/pid/builder.cpp
+++ b/pid/builder.cpp
@@ -16,15 +16,15 @@
#include "pid/builder.hpp"
+#include "conf.hpp"
+#include "pid/fancontroller.hpp"
+#include "pid/thermalcontroller.hpp"
+
#include <iostream>
#include <memory>
#include <sdbusplus/bus.hpp>
#include <unordered_map>
-#include "conf.hpp"
-#include "pid/fancontroller.hpp"
-#include "pid/thermalcontroller.hpp"
-
static constexpr bool deferSignals = true;
static constexpr auto objectPath = "/xyz/openbmc_project/settings/fanctrl/zone";
@@ -33,11 +33,10 @@
return std::string(objectPath) + std::to_string(zone);
}
-std::unordered_map<int64_t, std::unique_ptr<PIDZone>> BuildZones(
- std::map<int64_t, PIDConf>& zonePids,
- std::map<int64_t, struct zone>& zoneConfigs,
- SensorManager& mgr,
- sdbusplus::bus::bus& modeControlBus)
+std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
+ BuildZones(std::map<int64_t, PIDConf>& zonePids,
+ std::map<int64_t, struct zone>& zoneConfigs, SensorManager& mgr,
+ sdbusplus::bus::bus& modeControlBus)
{
std::unordered_map<int64_t, std::unique_ptr<PIDZone>> zones;
@@ -62,13 +61,9 @@
PIDConf& PIDConfig = zi.second;
auto zone = std::make_unique<PIDZone>(
- zoneId,
- zoneConf->second.minthermalrpm,
- zoneConf->second.failsafepercent,
- mgr,
- modeControlBus,
- GetControlPath(zi.first).c_str(),
- deferSignals);
+ zoneId, zoneConf->second.minthermalrpm,
+ zoneConf->second.failsafepercent, mgr, modeControlBus,
+ GetControlPath(zi.first).c_str(), deferSignals);
std::cerr << "Zone Id: " << zone->getZoneId() << "\n";
@@ -93,11 +88,8 @@
zone->addFanInput(i);
}
- auto pid = FanController::CreateFanPid(
- zone.get(),
- name,
- inputs,
- info->info);
+ auto pid = FanController::CreateFanPid(zone.get(), name, inputs,
+ info->info);
zone->addFanPID(std::move(pid));
}
else if (info->type == "temp" || info->type == "margin")
@@ -109,11 +101,7 @@
}
auto pid = ThermalController::CreateThermalPid(
- zone.get(),
- name,
- inputs,
- info->setpoint,
- info->info);
+ zone.get(), name, inputs, info->setpoint, info->info);
zone->addThermalPID(std::move(pid));
}
diff --git a/pid/builder.hpp b/pid/builder.hpp
index 5c03bd1..9201b9a 100644
--- a/pid/builder.hpp
+++ b/pid/builder.hpp
@@ -1,14 +1,13 @@
#pragma once
+#include "pid/zone.hpp"
+#include "sensors/manager.hpp"
+
#include <memory>
#include <sdbusplus/bus.hpp>
#include <unordered_map>
-#include "pid/zone.hpp"
-#include "sensors/manager.hpp"
-
-std::unordered_map<int64_t, std::unique_ptr<PIDZone>> BuildZones(
- std::map<int64_t, PIDConf>& zonePids,
- std::map<int64_t, struct zone>& zoneConfigs,
- SensorManager& mgr,
- sdbusplus::bus::bus& modeControlBus);
+std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
+ BuildZones(std::map<int64_t, PIDConf>& zonePids,
+ std::map<int64_t, struct zone>& zoneConfigs, SensorManager& mgr,
+ sdbusplus::bus::bus& modeControlBus);
diff --git a/pid/builderconfig.cpp b/pid/builderconfig.cpp
index 33301e2..0106057 100644
--- a/pid/builderconfig.cpp
+++ b/pid/builderconfig.cpp
@@ -16,6 +16,9 @@
#include "pid/builderconfig.hpp"
+#include "conf.hpp"
+#include "pid/builder.hpp"
+
#include <fstream>
#include <iostream>
#include <libconfig.h++>
@@ -24,13 +27,9 @@
#include <string>
#include <unordered_map>
-#include "conf.hpp"
-#include "pid/builder.hpp"
-
-std::unordered_map<int64_t, std::unique_ptr<PIDZone>> BuildZonesFromConfig(
- const std::string& path,
- SensorManager& mgr,
- sdbusplus::bus::bus& modeControlBus)
+std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
+ BuildZonesFromConfig(const std::string& path, SensorManager& mgr,
+ sdbusplus::bus::bus& modeControlBus)
{
using namespace libconfig;
// zone -> pids
@@ -77,10 +76,9 @@
zoneSettings.lookupValue("id", id);
- thisZoneConfig.minthermalrpm =
- zoneSettings.lookup("minthermalrpm");
+ thisZoneConfig.minthermalrpm = zoneSettings.lookup("minthermalrpm");
thisZoneConfig.failsafepercent =
- zoneSettings.lookup("failsafepercent");
+ zoneSettings.lookup("failsafepercent");
const Setting& pids = zoneSettings["pids"];
int pidCount = pids.getLength();
@@ -136,7 +134,7 @@
zoneConfig[static_cast<int64_t>(id)] = thisZoneConfig;
}
}
- catch (const SettingTypeException &setex)
+ catch (const SettingTypeException& setex)
{
std::cerr << "Setting '" << setex.getPath() << "' type exception!"
<< std::endl;
diff --git a/pid/builderconfig.hpp b/pid/builderconfig.hpp
index ad83932..a7f41f8 100644
--- a/pid/builderconfig.hpp
+++ b/pid/builderconfig.hpp
@@ -1,14 +1,13 @@
#pragma once
+#include "pid/zone.hpp"
+#include "sensors/manager.hpp"
+
#include <memory>
#include <sdbusplus/bus.hpp>
#include <string>
#include <unordered_map>
-#include "pid/zone.hpp"
-#include "sensors/manager.hpp"
-
-std::unordered_map<int64_t, std::unique_ptr<PIDZone>> BuildZonesFromConfig(
- const std::string& path,
- SensorManager& mgr,
- sdbusplus::bus::bus& modeControlBus);
+std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
+ BuildZonesFromConfig(const std::string& path, SensorManager& mgr,
+ sdbusplus::bus::bus& modeControlBus);
diff --git a/pid/controller.cpp b/pid/controller.cpp
index a5360fe..138268b 100644
--- a/pid/controller.cpp
+++ b/pid/controller.cpp
@@ -14,6 +14,10 @@
* limitations under the License.
*/
+#include "controller.hpp"
+
+#include "ec/pid.hpp"
+
#include <algorithm>
#include <chrono>
#include <iostream>
@@ -22,10 +26,6 @@
#include <thread>
#include <vector>
-#include "controller.hpp"
-#include "ec/pid.hpp"
-
-
void PIDController::pid_process(void)
{
float input;
diff --git a/pid/controller.hpp b/pid/controller.hpp
index 4220e07..57ee43f 100644
--- a/pid/controller.hpp
+++ b/pid/controller.hpp
@@ -1,11 +1,11 @@
#pragma once
+#include "ec/pid.hpp"
+#include "fan.hpp"
+
#include <memory>
#include <vector>
-#include "fan.hpp"
-#include "ec/pid.hpp"
-
class ZoneInterface;
/*
@@ -14,46 +14,46 @@
*/
class PIDController
{
- public:
- PIDController(const std::string& id, ZoneInterface* owner)
- : _owner(owner),
- _setpoint(0),
- _id(id)
- { }
+ public:
+ PIDController(const std::string& id, ZoneInterface* owner) :
+ _owner(owner), _setpoint(0), _id(id)
+ {
+ }
- virtual ~PIDController() { }
+ virtual ~PIDController()
+ {
+ }
- virtual float input_proc(void) = 0;
- virtual float setpt_proc(void) = 0;
- virtual void output_proc(float value) = 0;
+ virtual float input_proc(void) = 0;
+ virtual float setpt_proc(void) = 0;
+ virtual void output_proc(float value) = 0;
- void pid_process(void);
+ void pid_process(void);
- std::string get_id(void)
- {
- return _id;
- }
- float get_setpoint(void)
- {
- return _setpoint;
- }
- void set_setpoint(float setpoint)
- {
- _setpoint = setpoint;
- }
+ std::string get_id(void)
+ {
+ return _id;
+ }
+ float get_setpoint(void)
+ {
+ return _setpoint;
+ }
+ void set_setpoint(float setpoint)
+ {
+ _setpoint = setpoint;
+ }
- ec::pid_info_t* get_pid_info(void)
- {
- return &_pid_info;
- }
+ ec::pid_info_t* get_pid_info(void)
+ {
+ return &_pid_info;
+ }
- protected:
- ZoneInterface* _owner;
+ protected:
+ ZoneInterface* _owner;
- private:
- // parameters
- ec::pid_info_t _pid_info;
- float _setpoint;
- std::string _id;
+ private:
+ // parameters
+ ec::pid_info_t _pid_info;
+ float _setpoint;
+ std::string _id;
};
-
diff --git a/pid/ec/pid.cpp b/pid/ec/pid.cpp
index a1c4e41..ef0df14 100644
--- a/pid/ec/pid.cpp
+++ b/pid/ec/pid.cpp
@@ -53,15 +53,15 @@
// calculate P, I, D, FF
// Pid
- error = setpoint - input;
- p_term = pidinfoptr->p_c * error;
+ error = setpoint - input;
+ p_term = pidinfoptr->p_c * error;
// pId
if (0.0f != pidinfoptr->i_c)
{
- i_term = pidinfoptr->integral;
- i_term += error * pidinfoptr->i_c * pidinfoptr->ts;
- i_term = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
+ i_term = pidinfoptr->integral;
+ i_term += error * pidinfoptr->i_c * pidinfoptr->ts;
+ i_term = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
}
// FF
@@ -79,8 +79,8 @@
if (pidinfoptr->slew_neg != 0.0f)
{
// Don't decrease too fast
- float min_out = pidinfoptr->last_output + pidinfoptr->slew_neg *
- pidinfoptr->ts;
+ float min_out =
+ pidinfoptr->last_output + pidinfoptr->slew_neg * pidinfoptr->ts;
if (output < min_out)
{
output = min_out;
@@ -89,8 +89,8 @@
if (pidinfoptr->slew_pos != 0.0f)
{
// Don't increase too fast
- float max_out = pidinfoptr->last_output + pidinfoptr->slew_pos *
- pidinfoptr->ts;
+ float max_out =
+ pidinfoptr->last_output + pidinfoptr->slew_pos * pidinfoptr->ts;
if (output > max_out)
{
output = max_out;
@@ -107,12 +107,12 @@
// Clamp again because having limited the output may result in a
// larger integral term
- i_term = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
+ i_term = clamp(i_term, pidinfoptr->i_lim.min, pidinfoptr->i_lim.max);
pidinfoptr->integral = i_term;
- pidinfoptr->initialized = true;
- pidinfoptr->last_output = output;
+ pidinfoptr->initialized = true;
+ pidinfoptr->last_output = output;
return output;
}
-}
+} // namespace ec
diff --git a/pid/ec/pid.hpp b/pid/ec/pid.hpp
index e138933..6b1030a 100644
--- a/pid/ec/pid.hpp
+++ b/pid/ec/pid.hpp
@@ -7,8 +7,8 @@
typedef struct
{
- float min;
- float max;
+ float min;
+ float max;
} limits_t;
/* Note: If you update these structs you need to update the copy code in
@@ -16,21 +16,21 @@
*/
typedef struct
{
- bool initialized; // has pid been initialized
+ bool initialized; // has pid been initialized
- float ts; // sample time in seconds
- float integral; // intergal of error
- float last_output; // value of last output
+ float ts; // sample time in seconds
+ float integral; // intergal of error
+ float last_output; // value of last output
- float p_c; // coeff for P
- float i_c; // coeff for I
- float ff_off; // offset coeff for feed-forward term
- float ff_gain; // gain for feed-forward term
+ float p_c; // coeff for P
+ float i_c; // coeff for I
+ float ff_off; // offset coeff for feed-forward term
+ float ff_gain; // gain for feed-forward term
- limits_t i_lim; // clamp of integral
- limits_t out_lim; // clamp of output
- float slew_neg;
- float slew_pos;
+ limits_t i_lim; // clamp of integral
+ limits_t out_lim; // clamp of output
+ float slew_neg;
+ float slew_pos;
} pid_info_t;
float pid(pid_info_t* pidinfoptr, float input, float setpoint);
@@ -38,16 +38,15 @@
/* Condensed version for use by the configuration. */
struct pidinfo
{
- float ts; // sample time in seconds
- float p_c; // coeff for P
- float i_c; // coeff for I
- float ff_off; // offset coeff for feed-forward term
- float ff_gain; // gain for feed-forward term
- ec::limits_t i_lim; // clamp of integral
- ec::limits_t out_lim; // clamp of output
- float slew_neg;
- float slew_pos;
+ float ts; // sample time in seconds
+ float p_c; // coeff for P
+ float i_c; // coeff for I
+ float ff_off; // offset coeff for feed-forward term
+ float ff_gain; // gain for feed-forward term
+ ec::limits_t i_lim; // clamp of integral
+ ec::limits_t out_lim; // clamp of output
+ float slew_neg;
+ float slew_pos;
};
-
-}
+} // namespace ec
diff --git a/pid/fancontroller.cpp b/pid/fancontroller.cpp
index 9407689..4a94458 100644
--- a/pid/fancontroller.cpp
+++ b/pid/fancontroller.cpp
@@ -14,18 +14,18 @@
* limitations under the License.
*/
-#include <algorithm>
-#include <iostream>
-
#include "fancontroller.hpp"
+
#include "util.hpp"
#include "zone.hpp"
-std::unique_ptr<PIDController> FanController::CreateFanPid(
- ZoneInterface* owner,
- const std::string& id,
- std::vector<std::string>& inputs,
- ec::pidinfo initial)
+#include <algorithm>
+#include <iostream>
+
+std::unique_ptr<PIDController>
+ FanController::CreateFanPid(ZoneInterface* owner, const std::string& id,
+ std::vector<std::string>& inputs,
+ ec::pidinfo initial)
{
if (inputs.size() == 0)
{
@@ -79,7 +79,7 @@
/* When this is a configuration option in a later update, this code
* will be updated.
*/
- //value = sum / _inputs.size();
+ // value = sum / _inputs.size();
/* the fan PID algorithm was unstable with average, and seemed to work
* better with minimum. I had considered making this choice a variable
@@ -145,4 +145,3 @@
return;
}
-
diff --git a/pid/fancontroller.hpp b/pid/fancontroller.hpp
index 3354bb6..aaccd4b 100644
--- a/pid/fancontroller.hpp
+++ b/pid/fancontroller.hpp
@@ -1,14 +1,13 @@
#pragma once
+#include "controller.hpp"
+#include "ec/pid.hpp"
+#include "fan.hpp"
+
#include <memory>
#include <string>
#include <vector>
-#include "controller.hpp"
-#include "fan.hpp"
-#include "ec/pid.hpp"
-
-
/*
* A FanController is a PID controller that reads a number of fans and given
* the output then tries to set them to the goal values set by the thermal
@@ -16,36 +15,33 @@
*/
class FanController : public PIDController
{
- public:
- static std::unique_ptr<PIDController> CreateFanPid(
- ZoneInterface* owner,
- const std::string& id,
- std::vector<std::string>& inputs,
- ec::pidinfo initial);
+ public:
+ static std::unique_ptr<PIDController>
+ CreateFanPid(ZoneInterface* owner, const std::string& id,
+ std::vector<std::string>& inputs, ec::pidinfo initial);
- FanController(const std::string& id,
- std::vector<std::string>& inputs,
- ZoneInterface* owner)
- : PIDController(id, owner),
- _inputs(inputs),
- _direction(FanSpeedDirection::NEUTRAL)
- { }
+ FanController(const std::string& id, std::vector<std::string>& inputs,
+ ZoneInterface* owner) :
+ PIDController(id, owner),
+ _inputs(inputs), _direction(FanSpeedDirection::NEUTRAL)
+ {
+ }
- float input_proc(void) override;
- float setpt_proc(void) override;
- void output_proc(float value) override;
+ float input_proc(void) override;
+ float setpt_proc(void) override;
+ void output_proc(float value) override;
- FanSpeedDirection getFanDirection(void) const
- {
- return _direction;
- }
+ FanSpeedDirection getFanDirection(void) const
+ {
+ return _direction;
+ }
- void setFanDirection(FanSpeedDirection direction)
- {
- _direction = direction;
- };
+ void setFanDirection(FanSpeedDirection direction)
+ {
+ _direction = direction;
+ };
- private:
- std::vector<std::string> _inputs;
- FanSpeedDirection _direction;
+ private:
+ std::vector<std::string> _inputs;
+ FanSpeedDirection _direction;
};
diff --git a/pid/pidthread.cpp b/pid/pidthread.cpp
index d387ac9..490b70e 100644
--- a/pid/pidthread.cpp
+++ b/pid/pidthread.cpp
@@ -14,17 +14,16 @@
* limitations under the License.
*/
-#include <chrono>
-#include <map>
-#include <memory>
-#include <thread>
-#include <vector>
-
#include "pidthread.hpp"
#include "pid/controller.hpp"
#include "sensors/sensor.hpp"
+#include <chrono>
+#include <map>
+#include <memory>
+#include <thread>
+#include <vector>
static void ProcessThermals(PIDZone* zone)
{
@@ -38,7 +37,6 @@
zone->determineMaxRPMRequest();
}
-
void PIDControlThread(PIDZone* zone)
{
int ms100cnt = 0;
@@ -104,5 +102,3 @@
return;
}
-
-
diff --git a/pid/thermalcontroller.cpp b/pid/thermalcontroller.cpp
index 81e3e80..1422bef 100644
--- a/pid/thermalcontroller.cpp
+++ b/pid/thermalcontroller.cpp
@@ -15,16 +15,13 @@
*/
#include "thermalcontroller.hpp"
+
#include "util.hpp"
#include "zone.hpp"
-
std::unique_ptr<PIDController> ThermalController::CreateThermalPid(
- ZoneInterface* owner,
- const std::string& id,
- std::vector<std::string>& inputs,
- float setpoint,
- ec::pidinfo initial)
+ ZoneInterface* owner, const std::string& id,
+ std::vector<std::string>& inputs, float setpoint, ec::pidinfo initial)
{
// ThermalController currently only supports precisely one input.
if (inputs.size() != 1)
@@ -42,7 +39,7 @@
return thermal;
}
-//bmc_host_sensor_value_float
+// bmc_host_sensor_value_float
float ThermalController::input_proc(void)
{
/*
@@ -79,4 +76,3 @@
return;
}
-
diff --git a/pid/thermalcontroller.hpp b/pid/thermalcontroller.hpp
index 32d4a7f..ed94acb 100644
--- a/pid/thermalcontroller.hpp
+++ b/pid/thermalcontroller.hpp
@@ -1,12 +1,11 @@
#pragma once
-#include <memory>
-#include <string>
-#include <vector>
-
#include "controller.hpp"
#include "ec/pid.hpp"
+#include <memory>
+#include <string>
+#include <vector>
/*
* A ThermalController is a PID controller that reads a number of sensors and
@@ -14,26 +13,23 @@
*/
class ThermalController : public PIDController
{
- public:
- static std::unique_ptr<PIDController> CreateThermalPid(
- ZoneInterface* owner,
- const std::string& id,
- std::vector<std::string>& inputs,
- float setpoint,
- ec::pidinfo initial);
+ public:
+ static std::unique_ptr<PIDController>
+ CreateThermalPid(ZoneInterface* owner, const std::string& id,
+ std::vector<std::string>& inputs, float setpoint,
+ ec::pidinfo initial);
- ThermalController(const std::string& id,
- std::vector<std::string>& inputs,
- ZoneInterface* owner)
- : PIDController(id, owner),
- _inputs(inputs)
- { }
+ ThermalController(const std::string& id, std::vector<std::string>& inputs,
+ ZoneInterface* owner) :
+ PIDController(id, owner),
+ _inputs(inputs)
+ {
+ }
- float input_proc(void) override;
- float setpt_proc(void) override;
- void output_proc(float value) override;
+ float input_proc(void) override;
+ float setpt_proc(void) override;
+ void output_proc(float value) override;
- private:
- std::vector<std::string> _inputs;
+ private:
+ std::vector<std::string> _inputs;
};
-
diff --git a/pid/util.cpp b/pid/util.cpp
index 79da7e1..9004059 100644
--- a/pid/util.cpp
+++ b/pid/util.cpp
@@ -14,11 +14,11 @@
* limitations under the License.
*/
+#include "ec/pid.hpp"
+
#include <cstring>
#include <iostream>
-#include "ec/pid.hpp"
-
void InitializePIDStruct(ec::pid_info_t* info, ec::pidinfo* initial)
{
std::memset(info, 0x00, sizeof(ec::pid_info_t));
@@ -36,12 +36,10 @@
info->slew_pos = initial->slew_pos;
}
-void DumpPIDStruct(ec::pid_info_t *info)
+void DumpPIDStruct(ec::pid_info_t* info)
{
- std::cerr << " ts: " << info->ts
- << " p_c: " << info->p_c
- << " i_c: " << info->i_c
- << " ff_off: " << info->ff_off
+ std::cerr << " ts: " << info->ts << " p_c: " << info->p_c
+ << " i_c: " << info->i_c << " ff_off: " << info->ff_off
<< " ff_gain: " << info->ff_gain
<< " i_lim.min: " << info->i_lim.min
<< " i_lim.max: " << info->i_lim.max
@@ -50,8 +48,7 @@
<< " slew_neg: " << info->slew_neg
<< " slew_pos: " << info->slew_pos
<< " last_output: " << info->last_output
- << " integral: " << info->integral
- << std::endl;
+ << " integral: " << info->integral << std::endl;
return;
}
diff --git a/pid/util.hpp b/pid/util.hpp
index eb6e713..0f37afe 100644
--- a/pid/util.hpp
+++ b/pid/util.hpp
@@ -2,11 +2,10 @@
#include "ec/pid.hpp"
-
/*
* Given a configuration structure, fill out the information we use within the
* PID loop.
*/
void InitializePIDStruct(ec::pid_info_t* info, ec::pidinfo* initial);
-void DumpPIDStruct(ec::pid_info_t *info);
+void DumpPIDStruct(ec::pid_info_t* info);
diff --git a/pid/zone.cpp b/pid/zone.cpp
index fdf16fc..9e948f0 100644
--- a/pid/zone.cpp
+++ b/pid/zone.cpp
@@ -15,10 +15,14 @@
*/
/* Configuration. */
-#include "conf.hpp"
-
#include "zone.hpp"
+#include "conf.hpp"
+#include "pid/controller.hpp"
+#include "pid/ec/pid.hpp"
+#include "pid/fancontroller.hpp"
+#include "pid/thermalcontroller.hpp"
+
#include <algorithm>
#include <chrono>
#include <cstring>
@@ -27,12 +31,6 @@
#include <libconfig.h++>
#include <memory>
-#include "pid/controller.hpp"
-#include "pid/fancontroller.hpp"
-#include "pid/thermalcontroller.hpp"
-#include "pid/ec/pid.hpp"
-
-
using tstamp = std::chrono::high_resolution_clock::time_point;
using namespace std::literals::chrono_literals;
@@ -136,7 +134,8 @@
int value;
std::ifstream ifs;
ifs.open(setpointpath);
- if (ifs.good()) {
+ if (ifs.good())
+ {
ifs >> value;
max = value; // expecting RPM set-point, not pwm%
}
@@ -202,7 +201,9 @@
*/
#ifdef __TUNING_LOGGING__
tstamp now = std::chrono::high_resolution_clock::now();
- _log << std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+ _log << std::chrono::duration_cast<std::chrono::milliseconds>(
+ now.time_since_epoch())
+ .count();
_log << "," << _maximumRPMSetPt;
#endif
@@ -252,12 +253,12 @@
*/
if (timeout > 0)
{
- auto duration = duration_cast<std::chrono::seconds>
- (now - then).count();
+ auto duration =
+ duration_cast<std::chrono::seconds>(now - then).count();
auto period = std::chrono::seconds(timeout).count();
if (duration >= period)
{
- //std::cerr << "Entering fail safe mode.\n";
+ // std::cerr << "Entering fail safe mode.\n";
_failSafeSensors.insert(t);
}
else
diff --git a/pid/zone.hpp b/pid/zone.hpp
index 1934a66..99a8f14 100644
--- a/pid/zone.hpp
+++ b/pid/zone.hpp
@@ -1,39 +1,36 @@
#pragma once
+#include "conf.hpp"
+#include "controller.hpp"
+#include "sensors/manager.hpp"
+#include "sensors/sensor.hpp"
+#include "xyz/openbmc_project/Control/Mode/server.hpp"
+
#include <fstream>
#include <map>
#include <memory>
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server.hpp>
#include <set>
#include <string>
#include <vector>
-#include "conf.hpp"
-#include "controller.hpp"
-#include "sensors/sensor.hpp"
-#include "sensors/manager.hpp"
-
-#include "xyz/openbmc_project/Control/Mode/server.hpp"
-#include <sdbusplus/bus.hpp>
-#include <sdbusplus/server.hpp>
-
-
template <typename... T>
using ServerObject = typename sdbusplus::server::object::object<T...>;
-using ModeInterface =
- sdbusplus::xyz::openbmc_project::Control::server::Mode;
+using ModeInterface = sdbusplus::xyz::openbmc_project::Control::server::Mode;
using ModeObject = ServerObject<ModeInterface>;
class ZoneInterface
{
- public:
- virtual ~ZoneInterface() = default;
+ public:
+ virtual ~ZoneInterface() = default;
- virtual double getCachedValue(const std::string& name) = 0;
- virtual void addRPMSetPoint(float setpoint) = 0;
- virtual float getMaxRPMRequest() const = 0;
- virtual bool getFailSafeMode() const = 0;
- virtual float getFailSafePercent() const = 0;
- virtual Sensor* getSensor(std::string name) = 0;
+ virtual double getCachedValue(const std::string& name) = 0;
+ virtual void addRPMSetPoint(float setpoint) = 0;
+ virtual float getMaxRPMRequest() const = 0;
+ virtual bool getFailSafeMode() const = 0;
+ virtual float getFailSafePercent() const = 0;
+ virtual Sensor* getSensor(std::string name) = 0;
};
/*
@@ -43,84 +40,77 @@
*/
class PIDZone : public ZoneInterface, public ModeObject
{
- public:
- PIDZone(int64_t zone,
- float minThermalRpm,
- float failSafePercent,
- const SensorManager& mgr,
- sdbusplus::bus::bus& bus,
- const char* objPath,
- bool defer)
- : ModeObject(bus, objPath, defer),
- _zoneId(zone),
- _maximumRPMSetPt(),
- _minThermalRpmSetPt(minThermalRpm),
- _failSafePercent(failSafePercent),
- _mgr(mgr)
- {
+ public:
+ PIDZone(int64_t zone, float minThermalRpm, float failSafePercent,
+ const SensorManager& mgr, sdbusplus::bus::bus& bus,
+ const char* objPath, bool defer) :
+ ModeObject(bus, objPath, defer),
+ _zoneId(zone), _maximumRPMSetPt(), _minThermalRpmSetPt(minThermalRpm),
+ _failSafePercent(failSafePercent), _mgr(mgr)
+ {
#ifdef __TUNING_LOGGING__
- _log.open("/tmp/swampd.log");
+ _log.open("/tmp/swampd.log");
#endif
- }
+ }
- float getMaxRPMRequest(void) const override;
- bool getManualMode(void) const;
+ float getMaxRPMRequest(void) const override;
+ bool getManualMode(void) const;
- /* Could put lock around this since it's accessed from two threads, but
- * only one reader/one writer.
- */
- void setManualMode(bool mode);
- bool getFailSafeMode(void) const override;
- int64_t getZoneId(void) const;
- void addRPMSetPoint(float setpoint) override;
- void clearRPMSetPoints(void);
- float getFailSafePercent(void) const override;
- float getMinThermalRpmSetPt(void) const;
+ /* Could put lock around this since it's accessed from two threads, but
+ * only one reader/one writer.
+ */
+ void setManualMode(bool mode);
+ bool getFailSafeMode(void) const override;
+ int64_t getZoneId(void) const;
+ void addRPMSetPoint(float setpoint) override;
+ void clearRPMSetPoints(void);
+ float getFailSafePercent(void) const override;
+ float getMinThermalRpmSetPt(void) const;
- Sensor* getSensor(std::string name) override;
- void determineMaxRPMRequest(void);
- void updateFanTelemetry(void);
- void updateSensors(void);
- void initializeCache(void);
- void dumpCache(void);
- void process_fans(void);
- void process_thermals(void);
+ Sensor* getSensor(std::string name) override;
+ void determineMaxRPMRequest(void);
+ void updateFanTelemetry(void);
+ void updateSensors(void);
+ void initializeCache(void);
+ void dumpCache(void);
+ void process_fans(void);
+ void process_thermals(void);
- void addFanPID(std::unique_ptr<PIDController> pid);
- void addThermalPID(std::unique_ptr<PIDController> pid);
- double getCachedValue(const std::string& name) override;
- void addFanInput(std::string fan);
- void addThermalInput(std::string therm);
+ void addFanPID(std::unique_ptr<PIDController> pid);
+ void addThermalPID(std::unique_ptr<PIDController> pid);
+ double getCachedValue(const std::string& name) override;
+ void addFanInput(std::string fan);
+ void addThermalInput(std::string therm);
#ifdef __TUNING_LOGGING__
- void initializeLog(void);
- std::ofstream& getLogHandle(void);
+ void initializeLog(void);
+ std::ofstream& getLogHandle(void);
#endif
- /* Method for setting the manual mode over dbus */
- bool manual(bool value) override;
- /* Method for reading whether in fail-safe mode over dbus */
- bool failSafe() const override;
+ /* Method for setting the manual mode over dbus */
+ bool manual(bool value) override;
+ /* Method for reading whether in fail-safe mode over dbus */
+ bool failSafe() const override;
- private:
+ private:
#ifdef __TUNING_LOGGING__
- std::ofstream _log;
+ std::ofstream _log;
#endif
- const int64_t _zoneId;
- float _maximumRPMSetPt = 0;
- bool _manualMode = false;
- const float _minThermalRpmSetPt;
- const float _failSafePercent;
+ const int64_t _zoneId;
+ float _maximumRPMSetPt = 0;
+ bool _manualMode = false;
+ const float _minThermalRpmSetPt;
+ const float _failSafePercent;
- std::set<std::string> _failSafeSensors;
+ std::set<std::string> _failSafeSensors;
- std::vector<float> _RPMSetPoints;
- std::vector<std::string> _fanInputs;
- std::vector<std::string> _thermalInputs;
- std::map<std::string, double> _cachedValuesByName;
- const SensorManager& _mgr;
+ std::vector<float> _RPMSetPoints;
+ std::vector<std::string> _fanInputs;
+ std::vector<std::string> _thermalInputs;
+ std::map<std::string, double> _cachedValuesByName;
+ const SensorManager& _mgr;
- std::vector<std::unique_ptr<PIDController>> _fans;
- std::vector<std::unique_ptr<PIDController>> _thermals;
+ std::vector<std::unique_ptr<PIDController>> _fans;
+ std::vector<std::unique_ptr<PIDController>> _thermals;
};