blob: ca0f67f1431e944b4446f07d1bc6293a8284076a [file] [log] [blame]
Patrick Ventured8012182018-03-08 08:21:38 -08001/**
2 * Copyright 2017 Google Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/* Configuration. */
Patrick Ventured8012182018-03-08 08:21:38 -080018#include "zone.hpp"
19
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070020#include "conf.hpp"
21#include "pid/controller.hpp"
22#include "pid/ec/pid.hpp"
23#include "pid/fancontroller.hpp"
James Feist22c257a2018-08-31 14:07:12 -070024#include "pid/stepwisecontroller.hpp"
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070025#include "pid/thermalcontroller.hpp"
Patrick Venturec32e3fc2019-02-28 10:01:11 -080026#include "pid/tuning.hpp"
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070027
Patrick Ventured8012182018-03-08 08:21:38 -080028#include <algorithm>
29#include <chrono>
30#include <cstring>
31#include <fstream>
32#include <iostream>
Patrick Ventured8012182018-03-08 08:21:38 -080033#include <memory>
34
Patrick Venturea0764872020-08-08 07:48:43 -070035namespace pid_control
36{
37
Patrick Ventured8012182018-03-08 08:21:38 -080038using tstamp = std::chrono::high_resolution_clock::time_point;
39using namespace std::literals::chrono_literals;
40
Patrick Venture597ebd62020-08-11 08:48:19 -070041double DbusPidZone::getMaxSetPointRequest(void) const
Patrick Ventured8012182018-03-08 08:21:38 -080042{
Patrick Venturef7a2dd52019-07-16 14:31:13 -070043 return _maximumSetPoint;
Patrick Ventured8012182018-03-08 08:21:38 -080044}
45
Patrick Venture597ebd62020-08-11 08:48:19 -070046bool DbusPidZone::getManualMode(void) const
Patrick Ventured8012182018-03-08 08:21:38 -080047{
48 return _manualMode;
49}
50
Patrick Venture597ebd62020-08-11 08:48:19 -070051void DbusPidZone::setManualMode(bool mode)
Patrick Ventured8012182018-03-08 08:21:38 -080052{
53 _manualMode = mode;
54}
55
Patrick Venture597ebd62020-08-11 08:48:19 -070056bool DbusPidZone::getFailSafeMode(void) const
Patrick Ventured8012182018-03-08 08:21:38 -080057{
58 // If any keys are present at least one sensor is in fail safe mode.
59 return !_failSafeSensors.empty();
60}
61
Patrick Venture597ebd62020-08-11 08:48:19 -070062int64_t DbusPidZone::getZoneID(void) const
Patrick Ventured8012182018-03-08 08:21:38 -080063{
64 return _zoneId;
65}
66
Patrick Venture597ebd62020-08-11 08:48:19 -070067void DbusPidZone::addSetPoint(double setpoint)
Patrick Ventured8012182018-03-08 08:21:38 -080068{
Patrick Venture9bbf3332019-07-16 10:50:37 -070069 _SetPoints.push_back(setpoint);
Patrick Ventured8012182018-03-08 08:21:38 -080070}
71
Patrick Venture597ebd62020-08-11 08:48:19 -070072void DbusPidZone::addRPMCeiling(double ceiling)
James Feist608304d2019-02-25 10:01:42 -080073{
74 _RPMCeilings.push_back(ceiling);
75}
76
Patrick Venture597ebd62020-08-11 08:48:19 -070077void DbusPidZone::clearRPMCeilings(void)
James Feist608304d2019-02-25 10:01:42 -080078{
79 _RPMCeilings.clear();
80}
81
Patrick Venture597ebd62020-08-11 08:48:19 -070082void DbusPidZone::clearSetPoints(void)
Patrick Ventured8012182018-03-08 08:21:38 -080083{
Patrick Venture9bbf3332019-07-16 10:50:37 -070084 _SetPoints.clear();
Patrick Ventured8012182018-03-08 08:21:38 -080085}
86
Patrick Venture597ebd62020-08-11 08:48:19 -070087double DbusPidZone::getFailSafePercent(void) const
Patrick Ventured8012182018-03-08 08:21:38 -080088{
89 return _failSafePercent;
90}
91
Patrick Venture597ebd62020-08-11 08:48:19 -070092double DbusPidZone::getMinThermalSetpoint(void) const
Patrick Ventured8012182018-03-08 08:21:38 -080093{
James Feist3484bed2019-02-25 13:28:18 -080094 return _minThermalOutputSetPt;
Patrick Ventured8012182018-03-08 08:21:38 -080095}
96
Patrick Venture597ebd62020-08-11 08:48:19 -070097void DbusPidZone::addFanPID(std::unique_ptr<Controller> pid)
Patrick Ventured8012182018-03-08 08:21:38 -080098{
99 _fans.push_back(std::move(pid));
100}
101
Patrick Venture597ebd62020-08-11 08:48:19 -0700102void DbusPidZone::addThermalPID(std::unique_ptr<Controller> pid)
Patrick Ventured8012182018-03-08 08:21:38 -0800103{
104 _thermals.push_back(std::move(pid));
105}
106
Patrick Venture597ebd62020-08-11 08:48:19 -0700107double DbusPidZone::getCachedValue(const std::string& name)
Patrick Ventured8012182018-03-08 08:21:38 -0800108{
109 return _cachedValuesByName.at(name);
110}
111
Patrick Venture597ebd62020-08-11 08:48:19 -0700112void DbusPidZone::addFanInput(const std::string& fan)
Patrick Ventured8012182018-03-08 08:21:38 -0800113{
114 _fanInputs.push_back(fan);
115}
116
Patrick Venture597ebd62020-08-11 08:48:19 -0700117void DbusPidZone::addThermalInput(const std::string& therm)
Patrick Ventured8012182018-03-08 08:21:38 -0800118{
119 _thermalInputs.push_back(therm);
120}
121
Patrick Venture597ebd62020-08-11 08:48:19 -0700122void DbusPidZone::determineMaxSetPointRequest(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800123{
Patrick Venture5f59c0f2018-11-11 12:55:14 -0800124 double max = 0;
125 std::vector<double>::iterator result;
Patrick Ventured8012182018-03-08 08:21:38 -0800126
Patrick Venture9bbf3332019-07-16 10:50:37 -0700127 if (_SetPoints.size() > 0)
Patrick Ventured8012182018-03-08 08:21:38 -0800128 {
Patrick Venture9bbf3332019-07-16 10:50:37 -0700129 result = std::max_element(_SetPoints.begin(), _SetPoints.end());
Patrick Ventured8012182018-03-08 08:21:38 -0800130 max = *result;
131 }
132
James Feist608304d2019-02-25 10:01:42 -0800133 if (_RPMCeilings.size() > 0)
134 {
135 result = std::min_element(_RPMCeilings.begin(), _RPMCeilings.end());
136 max = std::min(max, *result);
137 }
138
Patrick Ventured8012182018-03-08 08:21:38 -0800139 /*
Patrick Venture7280e272019-02-11 10:45:32 -0800140 * If the maximum RPM setpoint output is below the minimum RPM
141 * setpoint, set it to the minimum.
Patrick Ventured8012182018-03-08 08:21:38 -0800142 */
Patrick Venturef7a2dd52019-07-16 14:31:13 -0700143 max = std::max(getMinThermalSetpoint(), max);
Patrick Ventured8012182018-03-08 08:21:38 -0800144
Patrick Venturede79ee02019-05-08 14:50:00 -0700145 if (tuningEnabled)
Patrick Ventured8012182018-03-08 08:21:38 -0800146 {
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800147 /*
148 * We received no setpoints from thermal sensors.
149 * This is a case experienced during tuning where they only specify
150 * fan sensors and one large fan PID for all the fans.
151 */
152 static constexpr auto setpointpath = "/etc/thermal.d/setpoint";
153 try
Patrick Ventureda4a5dd2018-08-31 09:42:48 -0700154 {
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800155 std::ifstream ifs;
156 ifs.open(setpointpath);
157 if (ifs.good())
158 {
159 int value;
160 ifs >> value;
Patrick Venturedf766f22018-10-13 09:30:58 -0700161
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800162 /* expecting RPM setpoint, not pwm% */
163 max = static_cast<double>(value);
164 }
165 }
166 catch (const std::exception& e)
167 {
168 /* This exception is uninteresting. */
169 std::cerr << "Unable to read from '" << setpointpath << "'\n";
Patrick Ventured8012182018-03-08 08:21:38 -0800170 }
171 }
Patrick Ventured8012182018-03-08 08:21:38 -0800172
Patrick Venturef7a2dd52019-07-16 14:31:13 -0700173 _maximumSetPoint = max;
Patrick Ventured8012182018-03-08 08:21:38 -0800174 return;
175}
176
Patrick Venture597ebd62020-08-11 08:48:19 -0700177void DbusPidZone::initializeLog(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800178{
Patrick Venture5f02ad22018-04-24 10:18:40 -0700179 /* Print header for log file:
180 * epoch_ms,setpt,fan1,fan2,fanN,sensor1,sensor2,sensorN,failsafe
181 */
Patrick Ventured8012182018-03-08 08:21:38 -0800182
183 _log << "epoch_ms,setpt";
184
Patrick Venture4a2dc4d2018-10-23 09:02:55 -0700185 for (const auto& f : _fanInputs)
Patrick Ventured8012182018-03-08 08:21:38 -0800186 {
187 _log << "," << f;
188 }
Patrick Venture4a2dc4d2018-10-23 09:02:55 -0700189 for (const auto& t : _thermalInputs)
Patrick Venture5f02ad22018-04-24 10:18:40 -0700190 {
191 _log << "," << t;
192 }
193 _log << ",failsafe";
Patrick Ventured8012182018-03-08 08:21:38 -0800194 _log << std::endl;
195
196 return;
197}
198
Patrick Venture597ebd62020-08-11 08:48:19 -0700199std::ofstream& DbusPidZone::getLogHandle(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800200{
201 return _log;
202}
Patrick Ventured8012182018-03-08 08:21:38 -0800203
204/*
205 * TODO(venture) This is effectively updating the cache and should check if the
206 * values they're using to update it are new or old, or whatnot. For instance,
207 * if we haven't heard from the host in X time we need to detect this failure.
208 *
209 * I haven't decided if the Sensor should have a lastUpdated method or whether
210 * that should be for the ReadInterface or etc...
211 */
212
213/**
214 * We want the PID loop to run with values cached, so this will get all the
215 * fan tachs for the loop.
216 */
Patrick Venture597ebd62020-08-11 08:48:19 -0700217void DbusPidZone::updateFanTelemetry(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800218{
219 /* TODO(venture): Should I just make _log point to /dev/null when logging
220 * is disabled? I think it's a waste to try and log things even if the
221 * data is just being dropped though.
222 */
Will Liangded0ab52019-05-15 17:10:06 +0800223 tstamp now = std::chrono::high_resolution_clock::now();
Patrick Venturede79ee02019-05-08 14:50:00 -0700224 if (loggingEnabled)
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800225 {
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800226 _log << std::chrono::duration_cast<std::chrono::milliseconds>(
227 now.time_since_epoch())
228 .count();
Patrick Venturef7a2dd52019-07-16 14:31:13 -0700229 _log << "," << _maximumSetPoint;
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800230 }
Patrick Ventured8012182018-03-08 08:21:38 -0800231
Patrick Venture4a2dc4d2018-10-23 09:02:55 -0700232 for (const auto& f : _fanInputs)
Patrick Ventured8012182018-03-08 08:21:38 -0800233 {
Patrick Venturea58197c2018-06-11 15:29:45 -0700234 auto sensor = _mgr.getSensor(f);
Patrick Ventured8012182018-03-08 08:21:38 -0800235 ReadReturn r = sensor->read();
236 _cachedValuesByName[f] = r.value;
Will Liangded0ab52019-05-15 17:10:06 +0800237 int64_t timeout = sensor->getTimeout();
238 tstamp then = r.updated;
Patrick Ventured8012182018-03-08 08:21:38 -0800239
Will Liangded0ab52019-05-15 17:10:06 +0800240 auto duration =
241 std::chrono::duration_cast<std::chrono::seconds>(now - then)
242 .count();
243 auto period = std::chrono::seconds(timeout).count();
Patrick Ventured8012182018-03-08 08:21:38 -0800244 /*
245 * TODO(venture): We should check when these were last read.
246 * However, these are the fans, so if I'm not getting updated values
247 * for them... what should I do?
248 */
Patrick Venturede79ee02019-05-08 14:50:00 -0700249 if (loggingEnabled)
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800250 {
251 _log << "," << r.value;
252 }
Will Liangded0ab52019-05-15 17:10:06 +0800253
254 // check if fan fail.
255 if (sensor->getFailed())
256 {
257 _failSafeSensors.insert(f);
258 }
259 else if (timeout != 0 && duration >= period)
260 {
261 _failSafeSensors.insert(f);
262 }
263 else
264 {
265 // Check if it's in there: remove it.
266 auto kt = _failSafeSensors.find(f);
267 if (kt != _failSafeSensors.end())
268 {
269 _failSafeSensors.erase(kt);
270 }
271 }
Patrick Ventured8012182018-03-08 08:21:38 -0800272 }
273
Patrick Venturede79ee02019-05-08 14:50:00 -0700274 if (loggingEnabled)
Patrick Venture5f02ad22018-04-24 10:18:40 -0700275 {
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800276 for (const auto& t : _thermalInputs)
277 {
278 _log << "," << _cachedValuesByName[t];
279 }
Patrick Venture5f02ad22018-04-24 10:18:40 -0700280 }
Patrick Venture5f02ad22018-04-24 10:18:40 -0700281
Patrick Ventured8012182018-03-08 08:21:38 -0800282 return;
283}
284
Patrick Venture597ebd62020-08-11 08:48:19 -0700285void DbusPidZone::updateSensors(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800286{
287 using namespace std::chrono;
288 /* margin and temp are stored as temp */
289 tstamp now = high_resolution_clock::now();
290
Patrick Venture4a2dc4d2018-10-23 09:02:55 -0700291 for (const auto& t : _thermalInputs)
Patrick Ventured8012182018-03-08 08:21:38 -0800292 {
Patrick Venturea58197c2018-06-11 15:29:45 -0700293 auto sensor = _mgr.getSensor(t);
Patrick Ventured8012182018-03-08 08:21:38 -0800294 ReadReturn r = sensor->read();
Patrick Venture563a3562018-10-30 09:31:26 -0700295 int64_t timeout = sensor->getTimeout();
Patrick Ventured8012182018-03-08 08:21:38 -0800296
297 _cachedValuesByName[t] = r.value;
298 tstamp then = r.updated;
299
James Feist473d68d2019-02-25 09:19:13 -0800300 auto duration = duration_cast<std::chrono::seconds>(now - then).count();
301 auto period = std::chrono::seconds(timeout).count();
302
James Feist36b7d8e2018-10-05 15:39:01 -0700303 if (sensor->getFailed())
304 {
305 _failSafeSensors.insert(t);
306 }
James Feist473d68d2019-02-25 09:19:13 -0800307 else if (timeout != 0 && duration >= period)
Patrick Ventured8012182018-03-08 08:21:38 -0800308 {
James Feist473d68d2019-02-25 09:19:13 -0800309 // std::cerr << "Entering fail safe mode.\n";
310 _failSafeSensors.insert(t);
311 }
312 else
313 {
314 // Check if it's in there: remove it.
315 auto kt = _failSafeSensors.find(t);
316 if (kt != _failSafeSensors.end())
Patrick Ventured8012182018-03-08 08:21:38 -0800317 {
James Feist473d68d2019-02-25 09:19:13 -0800318 _failSafeSensors.erase(kt);
Patrick Ventured8012182018-03-08 08:21:38 -0800319 }
320 }
321 }
322
323 return;
324}
325
Patrick Venture597ebd62020-08-11 08:48:19 -0700326void DbusPidZone::initializeCache(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800327{
Patrick Venture4a2dc4d2018-10-23 09:02:55 -0700328 for (const auto& f : _fanInputs)
Patrick Ventured8012182018-03-08 08:21:38 -0800329 {
330 _cachedValuesByName[f] = 0;
Will Liangded0ab52019-05-15 17:10:06 +0800331
332 // Start all fans in fail-safe mode.
333 _failSafeSensors.insert(f);
Patrick Ventured8012182018-03-08 08:21:38 -0800334 }
335
Patrick Venture4a2dc4d2018-10-23 09:02:55 -0700336 for (const auto& t : _thermalInputs)
Patrick Ventured8012182018-03-08 08:21:38 -0800337 {
338 _cachedValuesByName[t] = 0;
339
340 // Start all sensors in fail-safe mode.
341 _failSafeSensors.insert(t);
342 }
343}
344
Patrick Venture597ebd62020-08-11 08:48:19 -0700345void DbusPidZone::dumpCache(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800346{
347 std::cerr << "Cache values now: \n";
Patrick Venture4a2dc4d2018-10-23 09:02:55 -0700348 for (const auto& k : _cachedValuesByName)
Patrick Ventured8012182018-03-08 08:21:38 -0800349 {
350 std::cerr << k.first << ": " << k.second << "\n";
351 }
352}
353
Patrick Venture597ebd62020-08-11 08:48:19 -0700354void DbusPidZone::processFans(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800355{
356 for (auto& p : _fans)
357 {
James Feist22c257a2018-08-31 14:07:12 -0700358 p->process();
Patrick Ventured8012182018-03-08 08:21:38 -0800359 }
360}
361
Patrick Venture597ebd62020-08-11 08:48:19 -0700362void DbusPidZone::processThermals(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800363{
364 for (auto& p : _thermals)
365 {
James Feist22c257a2018-08-31 14:07:12 -0700366 p->process();
Patrick Ventured8012182018-03-08 08:21:38 -0800367 }
368}
369
Patrick Venture597ebd62020-08-11 08:48:19 -0700370Sensor* DbusPidZone::getSensor(const std::string& name)
Patrick Ventured8012182018-03-08 08:21:38 -0800371{
Patrick Venturefe75b192018-06-08 11:19:43 -0700372 return _mgr.getSensor(name);
Patrick Ventured8012182018-03-08 08:21:38 -0800373}
374
Patrick Venture597ebd62020-08-11 08:48:19 -0700375bool DbusPidZone::manual(bool value)
Patrick Ventured8012182018-03-08 08:21:38 -0800376{
377 std::cerr << "manual: " << value << std::endl;
378 setManualMode(value);
379 return ModeObject::manual(value);
380}
381
Patrick Venture597ebd62020-08-11 08:48:19 -0700382bool DbusPidZone::failSafe() const
Patrick Ventured8012182018-03-08 08:21:38 -0800383{
384 return getFailSafeMode();
385}
Patrick Venturea0764872020-08-08 07:48:43 -0700386
387} // namespace pid_control