blob: 1934a6630913a4ccf8f20d753de7d51e575efaab [file] [log] [blame]
#pragma once
#include <fstream>
#include <map>
#include <memory>
#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 ModeObject = ServerObject<ModeInterface>;
class ZoneInterface
{
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;
};
/*
* The PIDZone inherits from the Mode object so that it can listen for control
* mode changes. It primarily holds all PID loops and holds the sensor value
* cache that's used per iteration of the PID loops.
*/
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)
{
#ifdef __TUNING_LOGGING__
_log.open("/tmp/swampd.log");
#endif
}
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;
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);
#ifdef __TUNING_LOGGING__
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;
private:
#ifdef __TUNING_LOGGING__
std::ofstream _log;
#endif
const int64_t _zoneId;
float _maximumRPMSetPt = 0;
bool _manualMode = false;
const float _minThermalRpmSetPt;
const float _failSafePercent;
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<std::unique_ptr<PIDController>> _fans;
std::vector<std::unique_ptr<PIDController>> _thermals;
};