blob: 9604c73de7fe44abc50bd13ab12ef7e54546451f [file] [log] [blame]
Patrick Ventured8012182018-03-08 08:21:38 -08001#pragma once
2
Patrick Ventureda4a5dd2018-08-31 09:42:48 -07003#include "conf.hpp"
4#include "controller.hpp"
James Feist22c257a2018-08-31 14:07:12 -07005#include "pidcontroller.hpp"
Patrick Ventureda4a5dd2018-08-31 09:42:48 -07006#include "sensors/manager.hpp"
7#include "sensors/sensor.hpp"
Patrick Venturec32e3fc2019-02-28 10:01:11 -08008#include "tuning.hpp"
Patrick Venture1a153792020-08-11 08:41:47 -07009#include "zone_interface.hpp"
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070010
Patrick Venturea83a3ec2020-08-04 09:52:05 -070011#include <sdbusplus/bus.hpp>
12#include <sdbusplus/server.hpp>
13#include <xyz/openbmc_project/Control/Mode/server.hpp>
ykchiu7c6d35d2023-05-10 17:01:46 +080014#include <xyz/openbmc_project/Object/Enable/server.hpp>
Patrick Venturea83a3ec2020-08-04 09:52:05 -070015
Patrick Ventured8012182018-03-08 08:21:38 -080016#include <fstream>
Tom Tungdf1f1832022-11-14 19:26:52 +080017#include <iostream>
Patrick Ventured8012182018-03-08 08:21:38 -080018#include <map>
19#include <memory>
20#include <set>
21#include <string>
22#include <vector>
23
Patrick Ventured8012182018-03-08 08:21:38 -080024template <typename... T>
Patrick Williamsb228bc32022-07-22 19:26:56 -050025using ServerObject = typename sdbusplus::server::object_t<T...>;
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070026using ModeInterface = sdbusplus::xyz::openbmc_project::Control::server::Mode;
Patrick Ventured8012182018-03-08 08:21:38 -080027using ModeObject = ServerObject<ModeInterface>;
ykchiu7c6d35d2023-05-10 17:01:46 +080028using ProcessInterface =
29 sdbusplus::xyz::openbmc_project::Object::server::Enable;
30using ProcessObject = ServerObject<ProcessInterface>;
Patrick Ventured8012182018-03-08 08:21:38 -080031
Patrick Venturea0764872020-08-08 07:48:43 -070032namespace pid_control
33{
34
Patrick Ventured8012182018-03-08 08:21:38 -080035/*
Patrick Venture597ebd62020-08-11 08:48:19 -070036 * The DbusPidZone inherits from the Mode object so that it can listen for
37 * control mode changes. It primarily holds all PID loops and holds the sensor
38 * value cache that's used per iteration of the PID loops.
Patrick Ventured8012182018-03-08 08:21:38 -080039 */
Patrick Venture597ebd62020-08-11 08:48:19 -070040class DbusPidZone : public ZoneInterface, public ModeObject
Patrick Ventured8012182018-03-08 08:21:38 -080041{
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070042 public:
Patrick Venture597ebd62020-08-11 08:48:19 -070043 DbusPidZone(int64_t zone, double minThermalOutput, double failSafePercent,
Bonnie Lo0e8fc392022-10-05 10:20:55 +080044 conf::CycleTime cycleTime, const SensorManager& mgr,
45 sdbusplus::bus_t& bus, const char* objPath, bool defer) :
Patrick Williamsd8c5a452022-04-07 16:08:56 -050046 ModeObject(bus, objPath,
47 defer ? ModeObject::action::defer_emit
48 : ModeObject::action::emit_object_added),
Patrick Venturef7a2dd52019-07-16 14:31:13 -070049 _zoneId(zone), _maximumSetPoint(),
James Feist3484bed2019-02-25 13:28:18 -080050 _minThermalOutputSetPt(minThermalOutput),
Bonnie Lo0e8fc392022-10-05 10:20:55 +080051 _failSafePercent(failSafePercent), _cycleTime(cycleTime), _mgr(mgr)
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070052 {
Patrick Venturede79ee02019-05-08 14:50:00 -070053 if (loggingEnabled)
Patrick Venturec32e3fc2019-02-28 10:01:11 -080054 {
Patrick Venture89002db2019-05-08 15:02:55 -070055 _log.open(loggingPath + "/zone_" + std::to_string(zone) + ".log");
Patrick Venturec32e3fc2019-02-28 10:01:11 -080056 }
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070057 }
Patrick Ventured8012182018-03-08 08:21:38 -080058
Patrick Venture7a98c192020-08-12 08:35:16 -070059 bool getManualMode(void) const override;
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070060 /* Could put lock around this since it's accessed from two threads, but
61 * only one reader/one writer.
62 */
Josh Lehana4146eb2020-10-01 11:49:09 -070063
64 bool getRedundantWrite(void) const override;
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070065 void setManualMode(bool mode);
66 bool getFailSafeMode(void) const override;
Patrick Venture7a98c192020-08-12 08:35:16 -070067
Bonnie Loc51ba912022-10-12 14:07:22 +080068 int64_t getZoneID(void) const override;
Nirav Shahccc8bb62022-02-17 21:06:51 -080069 void addSetPoint(double setPoint, const std::string& name) override;
Patrick Venture7a98c192020-08-12 08:35:16 -070070 double getMaxSetPointRequest(void) const override;
James Feist608304d2019-02-25 10:01:42 -080071 void addRPMCeiling(double ceiling) override;
Patrick Venture7a98c192020-08-12 08:35:16 -070072 void clearSetPoints(void) override;
73 void clearRPMCeilings(void) override;
Patrick Venture5f59c0f2018-11-11 12:55:14 -080074 double getFailSafePercent(void) const override;
Nirav Shahccc8bb62022-02-17 21:06:51 -080075 double getMinThermalSetPoint(void) const;
Bonnie Lo0e8fc392022-10-05 10:20:55 +080076 uint64_t getCycleIntervalTime(void) const override;
77 uint64_t getUpdateThermalsCycle(void) const override;
Patrick Ventured8012182018-03-08 08:21:38 -080078
Patrick Venture2d8e7852018-10-30 19:14:07 -070079 Sensor* getSensor(const std::string& name) override;
Patrick Venture7a98c192020-08-12 08:35:16 -070080 void determineMaxSetPointRequest(void) override;
81 void updateFanTelemetry(void) override;
82 void updateSensors(void) override;
83 void initializeCache(void) override;
Josh Lehanb3005752022-02-22 20:48:07 -080084 void setOutputCache(std::string_view, const ValueCacheEntry&) override;
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070085 void dumpCache(void);
Josh Lehana4146eb2020-10-01 11:49:09 -070086
Patrick Venture7a98c192020-08-12 08:35:16 -070087 void processFans(void) override;
88 void processThermals(void) override;
Patrick Ventured8012182018-03-08 08:21:38 -080089
James Feist22c257a2018-08-31 14:07:12 -070090 void addFanPID(std::unique_ptr<Controller> pid);
91 void addThermalPID(std::unique_ptr<Controller> pid);
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070092 double getCachedValue(const std::string& name) override;
Josh Lehanb3005752022-02-22 20:48:07 -080093 ValueCacheEntry getCachedValues(const std::string& name) override;
94
Patrick Venturec399f6f2018-10-30 19:24:47 -070095 void addFanInput(const std::string& fan);
96 void addThermalInput(const std::string& therm);
Patrick Ventured8012182018-03-08 08:21:38 -080097
Patrick Venture7a98c192020-08-12 08:35:16 -070098 void initializeLog(void) override;
99 void writeLog(const std::string& value) override;
Patrick Ventured8012182018-03-08 08:21:38 -0800100
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700101 /* Method for setting the manual mode over dbus */
102 bool manual(bool value) override;
103 /* Method for reading whether in fail-safe mode over dbus */
104 bool failSafe() const override;
ykchiu7c6d35d2023-05-10 17:01:46 +0800105 /* Method for control process for each loop at runtime */
106 void addPidControlProcess(std::string name, sdbusplus::bus_t& bus,
107 std::string objPath, bool defer);
108 bool isPidProcessEnabled(std::string name);
Patrick Ventured8012182018-03-08 08:21:38 -0800109
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700110 private:
Tom Tungdf1f1832022-11-14 19:26:52 +0800111 template <bool fanSensorLogging>
112 void processSensorInputs(const std::vector<std::string>& sensorInputs,
113 std::chrono::high_resolution_clock::time_point now)
114 {
115 for (const auto& sensorInput : sensorInputs)
116 {
117 auto sensor = _mgr.getSensor(sensorInput);
118 ReadReturn r = sensor->read();
119 _cachedValuesByName[sensorInput] = {r.value, r.unscaled};
120 int64_t timeout = sensor->getTimeout();
121 std::chrono::high_resolution_clock::time_point then = r.updated;
122
123 auto duration =
124 std::chrono::duration_cast<std::chrono::seconds>(now - then)
125 .count();
126 auto period = std::chrono::seconds(timeout).count();
127 /*
128 * TODO(venture): We should check when these were last read.
129 * However, these are the fans, so if I'm not getting updated values
130 * for them... what should I do?
131 */
132 if constexpr (fanSensorLogging)
133 {
134 if (loggingEnabled)
135 {
136 const auto& v = _cachedValuesByName[sensorInput];
137 _log << "," << v.scaled << "," << v.unscaled;
138 const auto& p = _cachedFanOutputs[sensorInput];
139 _log << "," << p.scaled << "," << p.unscaled;
140 }
141 }
142
143 if (debugEnabled)
144 {
145 std::cerr << sensorInput << " sensor reading: " << r.value
146 << "\n";
147 }
148
149 // check if fan fail.
150 if (sensor->getFailed())
151 {
152 _failSafeSensors.insert(sensorInput);
153 if (debugEnabled)
154 {
155 std::cerr << sensorInput << " sensor get failed\n";
156 }
157 }
158 else if (timeout != 0 && duration >= period)
159 {
160 _failSafeSensors.insert(sensorInput);
161 if (debugEnabled)
162 {
163 std::cerr << sensorInput << " sensor timeout\n";
164 }
165 }
166 else
167 {
168 // Check if it's in there: remove it.
169 auto kt = _failSafeSensors.find(sensorInput);
170 if (kt != _failSafeSensors.end())
171 {
172 if (debugEnabled)
173 {
174 std::cerr << sensorInput
175 << " is erased from failsafe sensor set\n";
176 }
177 _failSafeSensors.erase(kt);
178 }
179 }
180 }
181 }
182
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700183 std::ofstream _log;
Patrick Ventured8012182018-03-08 08:21:38 -0800184
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700185 const int64_t _zoneId;
Patrick Venturef7a2dd52019-07-16 14:31:13 -0700186 double _maximumSetPoint = 0;
Nirav Shahccc8bb62022-02-17 21:06:51 -0800187 std::string _maximumSetPointName;
188 std::string _maximumSetPointNamePrev;
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700189 bool _manualMode = false;
Josh Lehana4146eb2020-10-01 11:49:09 -0700190 bool _redundantWrite = false;
James Feist3484bed2019-02-25 13:28:18 -0800191 const double _minThermalOutputSetPt;
Patrick Venture5f59c0f2018-11-11 12:55:14 -0800192 const double _failSafePercent;
Bonnie Lo0e8fc392022-10-05 10:20:55 +0800193 const conf::CycleTime _cycleTime;
Patrick Ventured8012182018-03-08 08:21:38 -0800194
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700195 std::set<std::string> _failSafeSensors;
Patrick Ventured8012182018-03-08 08:21:38 -0800196
Patrick Venture9bbf3332019-07-16 10:50:37 -0700197 std::vector<double> _SetPoints;
James Feist608304d2019-02-25 10:01:42 -0800198 std::vector<double> _RPMCeilings;
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700199 std::vector<std::string> _fanInputs;
200 std::vector<std::string> _thermalInputs;
Josh Lehanb3005752022-02-22 20:48:07 -0800201 std::map<std::string, ValueCacheEntry> _cachedValuesByName;
202 std::map<std::string, ValueCacheEntry> _cachedFanOutputs;
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700203 const SensorManager& _mgr;
Patrick Ventured8012182018-03-08 08:21:38 -0800204
James Feist22c257a2018-08-31 14:07:12 -0700205 std::vector<std::unique_ptr<Controller>> _fans;
206 std::vector<std::unique_ptr<Controller>> _thermals;
ykchiu7c6d35d2023-05-10 17:01:46 +0800207
208 std::map<std::string, std::unique_ptr<ProcessObject>> _pidsControlProcess;
Patrick Ventured8012182018-03-08 08:21:38 -0800209};
Patrick Venturea0764872020-08-08 07:48:43 -0700210
211} // namespace pid_control