Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 1 | /** |
| 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 Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 18 | #include "zone.hpp" |
| 19 | |
Patrick Venture | da4a5dd | 2018-08-31 09:42:48 -0700 | [diff] [blame] | 20 | #include "conf.hpp" |
| 21 | #include "pid/controller.hpp" |
| 22 | #include "pid/ec/pid.hpp" |
| 23 | #include "pid/fancontroller.hpp" |
James Feist | 22c257a | 2018-08-31 14:07:12 -0700 | [diff] [blame] | 24 | #include "pid/stepwisecontroller.hpp" |
Patrick Venture | da4a5dd | 2018-08-31 09:42:48 -0700 | [diff] [blame] | 25 | #include "pid/thermalcontroller.hpp" |
Patrick Venture | c32e3fc | 2019-02-28 10:01:11 -0800 | [diff] [blame] | 26 | #include "pid/tuning.hpp" |
Patrick Venture | da4a5dd | 2018-08-31 09:42:48 -0700 | [diff] [blame] | 27 | |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 28 | #include <algorithm> |
| 29 | #include <chrono> |
| 30 | #include <cstring> |
| 31 | #include <fstream> |
| 32 | #include <iostream> |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 33 | #include <memory> |
Josh Lehan | 55ccad6 | 2020-09-20 23:57:49 -0700 | [diff] [blame] | 34 | #include <sstream> |
Patrick Venture | 7a98c19 | 2020-08-12 08:35:16 -0700 | [diff] [blame] | 35 | #include <string> |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 36 | |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 37 | using tstamp = std::chrono::high_resolution_clock::time_point; |
| 38 | using namespace std::literals::chrono_literals; |
| 39 | |
Josh Lehan | 55ccad6 | 2020-09-20 23:57:49 -0700 | [diff] [blame] | 40 | // Enforces minimum duration between events |
| 41 | // Rreturns true if event should be allowed, false if disallowed |
| 42 | bool allowThrottle(const tstamp& now, const std::chrono::seconds& pace) |
| 43 | { |
| 44 | static tstamp then; |
| 45 | static bool first = true; |
| 46 | |
| 47 | if (first) |
| 48 | { |
| 49 | // Special case initialization |
| 50 | then = now; |
| 51 | first = false; |
| 52 | |
| 53 | // Initialization, always allow |
| 54 | return true; |
| 55 | } |
| 56 | |
| 57 | auto elapsed = now - then; |
| 58 | if (elapsed < pace) |
| 59 | { |
| 60 | // Too soon since last time, disallow |
| 61 | return false; |
| 62 | } |
| 63 | |
| 64 | // It has been long enough, allow |
| 65 | then = now; |
| 66 | return true; |
| 67 | } |
| 68 | |
| 69 | namespace pid_control |
| 70 | { |
| 71 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 72 | double DbusPidZone::getMaxSetPointRequest(void) const |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 73 | { |
Patrick Venture | f7a2dd5 | 2019-07-16 14:31:13 -0700 | [diff] [blame] | 74 | return _maximumSetPoint; |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 75 | } |
| 76 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 77 | bool DbusPidZone::getManualMode(void) const |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 78 | { |
| 79 | return _manualMode; |
| 80 | } |
| 81 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 82 | void DbusPidZone::setManualMode(bool mode) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 83 | { |
| 84 | _manualMode = mode; |
Josh Lehan | a4146eb | 2020-10-01 11:49:09 -0700 | [diff] [blame] | 85 | |
| 86 | // If returning to automatic mode, need to restore PWM from PID loop |
| 87 | if (!mode) |
| 88 | { |
| 89 | _redundantWrite = true; |
| 90 | } |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 91 | } |
| 92 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 93 | bool DbusPidZone::getFailSafeMode(void) const |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 94 | { |
| 95 | // If any keys are present at least one sensor is in fail safe mode. |
| 96 | return !_failSafeSensors.empty(); |
| 97 | } |
| 98 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 99 | int64_t DbusPidZone::getZoneID(void) const |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 100 | { |
| 101 | return _zoneId; |
| 102 | } |
| 103 | |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 104 | void DbusPidZone::addSetPoint(double setPoint, const std::string& name) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 105 | { |
ykchiu | 7c6d35d | 2023-05-10 17:01:46 +0800 | [diff] [blame] | 106 | /* exclude disabled pidloop from _maximumSetPoint calculation*/ |
| 107 | if (!isPidProcessEnabled(name)) |
| 108 | { |
| 109 | return; |
| 110 | } |
| 111 | |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 112 | _SetPoints.push_back(setPoint); |
| 113 | /* |
| 114 | * if there are multiple thermal controllers with the same |
| 115 | * value, pick the first one in the iterator |
| 116 | */ |
| 117 | if (_maximumSetPoint < setPoint) |
| 118 | { |
| 119 | _maximumSetPoint = setPoint; |
| 120 | _maximumSetPointName = name; |
| 121 | } |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 122 | } |
| 123 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 124 | void DbusPidZone::addRPMCeiling(double ceiling) |
James Feist | 608304d | 2019-02-25 10:01:42 -0800 | [diff] [blame] | 125 | { |
| 126 | _RPMCeilings.push_back(ceiling); |
| 127 | } |
| 128 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 129 | void DbusPidZone::clearRPMCeilings(void) |
James Feist | 608304d | 2019-02-25 10:01:42 -0800 | [diff] [blame] | 130 | { |
| 131 | _RPMCeilings.clear(); |
| 132 | } |
| 133 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 134 | void DbusPidZone::clearSetPoints(void) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 135 | { |
Patrick Venture | 9bbf333 | 2019-07-16 10:50:37 -0700 | [diff] [blame] | 136 | _SetPoints.clear(); |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 137 | _maximumSetPoint = 0; |
ykchiu | 7c6d35d | 2023-05-10 17:01:46 +0800 | [diff] [blame] | 138 | _maximumSetPointName.clear(); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 139 | } |
| 140 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 141 | double DbusPidZone::getFailSafePercent(void) const |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 142 | { |
| 143 | return _failSafePercent; |
| 144 | } |
| 145 | |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 146 | double DbusPidZone::getMinThermalSetPoint(void) const |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 147 | { |
James Feist | 3484bed | 2019-02-25 13:28:18 -0800 | [diff] [blame] | 148 | return _minThermalOutputSetPt; |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 149 | } |
| 150 | |
Bonnie Lo | 0e8fc39 | 2022-10-05 10:20:55 +0800 | [diff] [blame] | 151 | uint64_t DbusPidZone::getCycleIntervalTime(void) const |
| 152 | { |
| 153 | return _cycleTime.cycleIntervalTimeMS; |
| 154 | } |
| 155 | |
| 156 | uint64_t DbusPidZone::getUpdateThermalsCycle(void) const |
| 157 | { |
| 158 | return _cycleTime.updateThermalsTimeMS; |
| 159 | } |
| 160 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 161 | void DbusPidZone::addFanPID(std::unique_ptr<Controller> pid) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 162 | { |
| 163 | _fans.push_back(std::move(pid)); |
| 164 | } |
| 165 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 166 | void DbusPidZone::addThermalPID(std::unique_ptr<Controller> pid) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 167 | { |
| 168 | _thermals.push_back(std::move(pid)); |
| 169 | } |
| 170 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 171 | double DbusPidZone::getCachedValue(const std::string& name) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 172 | { |
Josh Lehan | b300575 | 2022-02-22 20:48:07 -0800 | [diff] [blame] | 173 | return _cachedValuesByName.at(name).scaled; |
| 174 | } |
| 175 | |
| 176 | ValueCacheEntry DbusPidZone::getCachedValues(const std::string& name) |
| 177 | { |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 178 | return _cachedValuesByName.at(name); |
| 179 | } |
| 180 | |
Josh Lehan | b300575 | 2022-02-22 20:48:07 -0800 | [diff] [blame] | 181 | void DbusPidZone::setOutputCache(std::string_view name, |
| 182 | const ValueCacheEntry& values) |
| 183 | { |
| 184 | _cachedFanOutputs[std::string{name}] = values; |
| 185 | } |
| 186 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 187 | void DbusPidZone::addFanInput(const std::string& fan) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 188 | { |
| 189 | _fanInputs.push_back(fan); |
| 190 | } |
| 191 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 192 | void DbusPidZone::addThermalInput(const std::string& therm) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 193 | { |
| 194 | _thermalInputs.push_back(therm); |
| 195 | } |
| 196 | |
Josh Lehan | 55ccad6 | 2020-09-20 23:57:49 -0700 | [diff] [blame] | 197 | // Updates desired RPM setpoint from optional text file |
| 198 | // Returns true if rpmValue updated, false if left unchanged |
| 199 | static bool fileParseRpm(const std::string& fileName, double& rpmValue) |
| 200 | { |
| 201 | static constexpr std::chrono::seconds throttlePace{3}; |
| 202 | |
| 203 | std::string errText; |
| 204 | |
| 205 | try |
| 206 | { |
| 207 | std::ifstream ifs; |
| 208 | ifs.open(fileName); |
| 209 | if (ifs) |
| 210 | { |
| 211 | int value; |
| 212 | ifs >> value; |
| 213 | |
| 214 | if (value <= 0) |
| 215 | { |
| 216 | errText = "File content could not be parsed to a number"; |
| 217 | } |
| 218 | else if (value <= 100) |
| 219 | { |
| 220 | errText = "File must contain RPM value, not PWM value"; |
| 221 | } |
| 222 | else |
| 223 | { |
| 224 | rpmValue = static_cast<double>(value); |
| 225 | return true; |
| 226 | } |
| 227 | } |
| 228 | } |
| 229 | catch (const std::exception& e) |
| 230 | { |
| 231 | errText = "Exception: "; |
| 232 | errText += e.what(); |
| 233 | } |
| 234 | |
| 235 | // The file is optional, intentionally not an error if file not found |
| 236 | if (!(errText.empty())) |
| 237 | { |
| 238 | tstamp now = std::chrono::high_resolution_clock::now(); |
| 239 | if (allowThrottle(now, throttlePace)) |
| 240 | { |
| 241 | std::cerr << "Unable to read from '" << fileName << "': " << errText |
| 242 | << "\n"; |
| 243 | } |
| 244 | } |
| 245 | |
| 246 | return false; |
| 247 | } |
| 248 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 249 | void DbusPidZone::determineMaxSetPointRequest(void) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 250 | { |
Patrick Venture | 5f59c0f | 2018-11-11 12:55:14 -0800 | [diff] [blame] | 251 | std::vector<double>::iterator result; |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 252 | double minThermalThreshold = getMinThermalSetPoint(); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 253 | |
James Feist | 608304d | 2019-02-25 10:01:42 -0800 | [diff] [blame] | 254 | if (_RPMCeilings.size() > 0) |
| 255 | { |
| 256 | result = std::min_element(_RPMCeilings.begin(), _RPMCeilings.end()); |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 257 | // if Max set point is larger than the lowest ceiling, reset to lowest |
| 258 | // ceiling. |
| 259 | if (*result < _maximumSetPoint) |
| 260 | { |
| 261 | _maximumSetPoint = *result; |
| 262 | // When using lowest ceiling, controller name is ceiling. |
| 263 | _maximumSetPointName = "Ceiling"; |
| 264 | } |
James Feist | 608304d | 2019-02-25 10:01:42 -0800 | [diff] [blame] | 265 | } |
| 266 | |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 267 | /* |
Patrick Venture | 7280e27 | 2019-02-11 10:45:32 -0800 | [diff] [blame] | 268 | * If the maximum RPM setpoint output is below the minimum RPM |
| 269 | * setpoint, set it to the minimum. |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 270 | */ |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 271 | if (minThermalThreshold >= _maximumSetPoint) |
| 272 | { |
| 273 | _maximumSetPoint = minThermalThreshold; |
ykchiu | 7c6d35d | 2023-05-10 17:01:46 +0800 | [diff] [blame] | 274 | _maximumSetPointName = "Minimum"; |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 275 | } |
| 276 | else if (_maximumSetPointName.compare(_maximumSetPointNamePrev)) |
| 277 | { |
| 278 | std::cerr << "PID Zone " << _zoneId << " max SetPoint " |
| 279 | << _maximumSetPoint << " requested by " |
| 280 | << _maximumSetPointName; |
| 281 | for (const auto& sensor : _failSafeSensors) |
| 282 | { |
| 283 | if (sensor.find("Fan") == std::string::npos) |
| 284 | { |
| 285 | std::cerr << " " << sensor; |
| 286 | } |
| 287 | } |
| 288 | std::cerr << "\n"; |
| 289 | _maximumSetPointNamePrev.assign(_maximumSetPointName); |
| 290 | } |
Patrick Venture | de79ee0 | 2019-05-08 14:50:00 -0700 | [diff] [blame] | 291 | if (tuningEnabled) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 292 | { |
Patrick Venture | c32e3fc | 2019-02-28 10:01:11 -0800 | [diff] [blame] | 293 | /* |
| 294 | * We received no setpoints from thermal sensors. |
| 295 | * This is a case experienced during tuning where they only specify |
| 296 | * fan sensors and one large fan PID for all the fans. |
| 297 | */ |
| 298 | static constexpr auto setpointpath = "/etc/thermal.d/setpoint"; |
Patrick Venture | df766f2 | 2018-10-13 09:30:58 -0700 | [diff] [blame] | 299 | |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 300 | fileParseRpm(setpointpath, _maximumSetPoint); |
Josh Lehan | 55ccad6 | 2020-09-20 23:57:49 -0700 | [diff] [blame] | 301 | |
| 302 | // Allow per-zone setpoint files to override overall setpoint file |
| 303 | std::ostringstream zoneSuffix; |
| 304 | zoneSuffix << ".zone" << _zoneId; |
| 305 | std::string zoneSetpointPath = setpointpath + zoneSuffix.str(); |
| 306 | |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 307 | fileParseRpm(zoneSetpointPath, _maximumSetPoint); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 308 | } |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 309 | return; |
| 310 | } |
| 311 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 312 | void DbusPidZone::initializeLog(void) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 313 | { |
Patrick Venture | 5f02ad2 | 2018-04-24 10:18:40 -0700 | [diff] [blame] | 314 | /* Print header for log file: |
Josh Lehan | b300575 | 2022-02-22 20:48:07 -0800 | [diff] [blame] | 315 | * epoch_ms,setpt,fan1,fan1_raw,fan1_pwm,fan1_pwm_raw,fan2,fan2_raw,fan2_pwm,fan2_pwm_raw,fanN,fanN_raw,fanN_pwm,fanN_pwm_raw,sensor1,sensor1_raw,sensor2,sensor2_raw,sensorN,sensorN_raw,failsafe |
Patrick Venture | 5f02ad2 | 2018-04-24 10:18:40 -0700 | [diff] [blame] | 316 | */ |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 317 | |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 318 | _log << "epoch_ms,setpt,requester"; |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 319 | |
Patrick Venture | 4a2dc4d | 2018-10-23 09:02:55 -0700 | [diff] [blame] | 320 | for (const auto& f : _fanInputs) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 321 | { |
Josh Lehan | b300575 | 2022-02-22 20:48:07 -0800 | [diff] [blame] | 322 | _log << "," << f << "," << f << "_raw"; |
| 323 | _log << "," << f << "_pwm," << f << "_pwm_raw"; |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 324 | } |
Patrick Venture | 4a2dc4d | 2018-10-23 09:02:55 -0700 | [diff] [blame] | 325 | for (const auto& t : _thermalInputs) |
Patrick Venture | 5f02ad2 | 2018-04-24 10:18:40 -0700 | [diff] [blame] | 326 | { |
Josh Lehan | b300575 | 2022-02-22 20:48:07 -0800 | [diff] [blame] | 327 | _log << "," << t << "," << t << "_raw"; |
Patrick Venture | 5f02ad2 | 2018-04-24 10:18:40 -0700 | [diff] [blame] | 328 | } |
Josh Lehan | b300575 | 2022-02-22 20:48:07 -0800 | [diff] [blame] | 329 | |
Patrick Venture | 5f02ad2 | 2018-04-24 10:18:40 -0700 | [diff] [blame] | 330 | _log << ",failsafe"; |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 331 | _log << std::endl; |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 332 | } |
| 333 | |
Patrick Venture | 7a98c19 | 2020-08-12 08:35:16 -0700 | [diff] [blame] | 334 | void DbusPidZone::writeLog(const std::string& value) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 335 | { |
Patrick Venture | 7a98c19 | 2020-08-12 08:35:16 -0700 | [diff] [blame] | 336 | _log << value; |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 337 | } |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 338 | |
| 339 | /* |
| 340 | * TODO(venture) This is effectively updating the cache and should check if the |
| 341 | * values they're using to update it are new or old, or whatnot. For instance, |
| 342 | * if we haven't heard from the host in X time we need to detect this failure. |
| 343 | * |
| 344 | * I haven't decided if the Sensor should have a lastUpdated method or whether |
| 345 | * that should be for the ReadInterface or etc... |
| 346 | */ |
| 347 | |
| 348 | /** |
| 349 | * We want the PID loop to run with values cached, so this will get all the |
| 350 | * fan tachs for the loop. |
| 351 | */ |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 352 | void DbusPidZone::updateFanTelemetry(void) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 353 | { |
| 354 | /* TODO(venture): Should I just make _log point to /dev/null when logging |
| 355 | * is disabled? I think it's a waste to try and log things even if the |
| 356 | * data is just being dropped though. |
| 357 | */ |
Tom Tung | df1f183 | 2022-11-14 19:26:52 +0800 | [diff] [blame] | 358 | const auto now = std::chrono::high_resolution_clock::now(); |
Patrick Venture | de79ee0 | 2019-05-08 14:50:00 -0700 | [diff] [blame] | 359 | if (loggingEnabled) |
Patrick Venture | c32e3fc | 2019-02-28 10:01:11 -0800 | [diff] [blame] | 360 | { |
Patrick Venture | c32e3fc | 2019-02-28 10:01:11 -0800 | [diff] [blame] | 361 | _log << std::chrono::duration_cast<std::chrono::milliseconds>( |
| 362 | now.time_since_epoch()) |
| 363 | .count(); |
Patrick Venture | f7a2dd5 | 2019-07-16 14:31:13 -0700 | [diff] [blame] | 364 | _log << "," << _maximumSetPoint; |
Nirav Shah | ccc8bb6 | 2022-02-17 21:06:51 -0800 | [diff] [blame] | 365 | _log << "," << _maximumSetPointName; |
Patrick Venture | c32e3fc | 2019-02-28 10:01:11 -0800 | [diff] [blame] | 366 | } |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 367 | |
Tom Tung | df1f183 | 2022-11-14 19:26:52 +0800 | [diff] [blame] | 368 | processSensorInputs</* fanSensorLogging */ true>(_fanInputs, now); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 369 | |
Patrick Venture | de79ee0 | 2019-05-08 14:50:00 -0700 | [diff] [blame] | 370 | if (loggingEnabled) |
Patrick Venture | 5f02ad2 | 2018-04-24 10:18:40 -0700 | [diff] [blame] | 371 | { |
Patrick Venture | c32e3fc | 2019-02-28 10:01:11 -0800 | [diff] [blame] | 372 | for (const auto& t : _thermalInputs) |
| 373 | { |
Josh Lehan | b300575 | 2022-02-22 20:48:07 -0800 | [diff] [blame] | 374 | const auto& v = _cachedValuesByName[t]; |
| 375 | _log << "," << v.scaled << "," << v.unscaled; |
Patrick Venture | c32e3fc | 2019-02-28 10:01:11 -0800 | [diff] [blame] | 376 | } |
Patrick Venture | 5f02ad2 | 2018-04-24 10:18:40 -0700 | [diff] [blame] | 377 | } |
Patrick Venture | 5f02ad2 | 2018-04-24 10:18:40 -0700 | [diff] [blame] | 378 | |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 379 | return; |
| 380 | } |
| 381 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 382 | void DbusPidZone::updateSensors(void) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 383 | { |
Tom Tung | df1f183 | 2022-11-14 19:26:52 +0800 | [diff] [blame] | 384 | processSensorInputs</* fanSensorLogging */ false>( |
| 385 | _thermalInputs, std::chrono::high_resolution_clock::now()); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 386 | |
| 387 | return; |
| 388 | } |
| 389 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 390 | void DbusPidZone::initializeCache(void) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 391 | { |
Patrick Venture | 4a2dc4d | 2018-10-23 09:02:55 -0700 | [diff] [blame] | 392 | for (const auto& f : _fanInputs) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 393 | { |
Josh Lehan | d38ae27 | 2020-11-13 02:59:30 -0800 | [diff] [blame] | 394 | _cachedValuesByName[f] = {0, 0}; |
| 395 | _cachedFanOutputs[f] = {0, 0}; |
Will Liang | ded0ab5 | 2019-05-15 17:10:06 +0800 | [diff] [blame] | 396 | |
| 397 | // Start all fans in fail-safe mode. |
| 398 | _failSafeSensors.insert(f); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 399 | } |
| 400 | |
Patrick Venture | 4a2dc4d | 2018-10-23 09:02:55 -0700 | [diff] [blame] | 401 | for (const auto& t : _thermalInputs) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 402 | { |
Josh Lehan | d38ae27 | 2020-11-13 02:59:30 -0800 | [diff] [blame] | 403 | _cachedValuesByName[t] = {0, 0}; |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 404 | |
| 405 | // Start all sensors in fail-safe mode. |
| 406 | _failSafeSensors.insert(t); |
| 407 | } |
ykchiu | 9fe3a3c | 2023-05-11 13:43:54 +0800 | [diff] [blame] | 408 | // Initialize Pid FailSafePercent |
| 409 | initPidFailSafePercent(); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 410 | } |
| 411 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 412 | void DbusPidZone::dumpCache(void) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 413 | { |
| 414 | std::cerr << "Cache values now: \n"; |
Patrick Venture | 2a50eda | 2020-08-16 08:26:35 -0700 | [diff] [blame] | 415 | for (const auto& [name, value] : _cachedValuesByName) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 416 | { |
Josh Lehan | b300575 | 2022-02-22 20:48:07 -0800 | [diff] [blame] | 417 | std::cerr << name << ": " << value.scaled << " " << value.unscaled |
| 418 | << "\n"; |
| 419 | } |
| 420 | |
| 421 | std::cerr << "Fan outputs now: \n"; |
| 422 | for (const auto& [name, value] : _cachedFanOutputs) |
| 423 | { |
| 424 | std::cerr << name << ": " << value.scaled << " " << value.unscaled |
| 425 | << "\n"; |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 426 | } |
| 427 | } |
| 428 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 429 | void DbusPidZone::processFans(void) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 430 | { |
| 431 | for (auto& p : _fans) |
| 432 | { |
James Feist | 22c257a | 2018-08-31 14:07:12 -0700 | [diff] [blame] | 433 | p->process(); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 434 | } |
Josh Lehan | a4146eb | 2020-10-01 11:49:09 -0700 | [diff] [blame] | 435 | |
| 436 | if (_redundantWrite) |
| 437 | { |
| 438 | // This is only needed once |
| 439 | _redundantWrite = false; |
| 440 | } |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 441 | } |
| 442 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 443 | void DbusPidZone::processThermals(void) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 444 | { |
| 445 | for (auto& p : _thermals) |
| 446 | { |
James Feist | 22c257a | 2018-08-31 14:07:12 -0700 | [diff] [blame] | 447 | p->process(); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 448 | } |
| 449 | } |
| 450 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 451 | Sensor* DbusPidZone::getSensor(const std::string& name) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 452 | { |
Patrick Venture | fe75b19 | 2018-06-08 11:19:43 -0700 | [diff] [blame] | 453 | return _mgr.getSensor(name); |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 454 | } |
| 455 | |
Josh Lehan | a4146eb | 2020-10-01 11:49:09 -0700 | [diff] [blame] | 456 | bool DbusPidZone::getRedundantWrite(void) const |
| 457 | { |
| 458 | return _redundantWrite; |
| 459 | } |
| 460 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 461 | bool DbusPidZone::manual(bool value) |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 462 | { |
| 463 | std::cerr << "manual: " << value << std::endl; |
| 464 | setManualMode(value); |
| 465 | return ModeObject::manual(value); |
| 466 | } |
| 467 | |
Patrick Venture | 597ebd6 | 2020-08-11 08:48:19 -0700 | [diff] [blame] | 468 | bool DbusPidZone::failSafe() const |
Patrick Venture | d801218 | 2018-03-08 08:21:38 -0800 | [diff] [blame] | 469 | { |
| 470 | return getFailSafeMode(); |
| 471 | } |
Patrick Venture | a076487 | 2020-08-08 07:48:43 -0700 | [diff] [blame] | 472 | |
Harvey Wu | 3718006 | 2023-10-02 09:42:50 +0800 | [diff] [blame] | 473 | void DbusPidZone::addPidControlProcess(std::string name, std::string type, |
| 474 | double setpoint, sdbusplus::bus_t& bus, |
ykchiu | 7c6d35d | 2023-05-10 17:01:46 +0800 | [diff] [blame] | 475 | std::string objPath, bool defer) |
| 476 | { |
| 477 | _pidsControlProcess[name] = std::make_unique<ProcessObject>( |
| 478 | bus, objPath.c_str(), |
| 479 | defer ? ProcessObject::action::defer_emit |
| 480 | : ProcessObject::action::emit_object_added); |
| 481 | // Default enable setting = true |
| 482 | _pidsControlProcess[name]->enabled(true); |
Harvey Wu | 3718006 | 2023-10-02 09:42:50 +0800 | [diff] [blame] | 483 | _pidsControlProcess[name]->setpoint(setpoint); |
| 484 | |
| 485 | if (type == "temp") |
| 486 | { |
| 487 | _pidsControlProcess[name]->classType("Temperature"); |
| 488 | } |
| 489 | else if (type == "margin") |
| 490 | { |
| 491 | _pidsControlProcess[name]->classType("Margin"); |
| 492 | } |
| 493 | else if (type == "power") |
| 494 | { |
| 495 | _pidsControlProcess[name]->classType("Power"); |
| 496 | } |
| 497 | else if (type == "powersum") |
| 498 | { |
| 499 | _pidsControlProcess[name]->classType("PowerSum"); |
| 500 | } |
ykchiu | 7c6d35d | 2023-05-10 17:01:46 +0800 | [diff] [blame] | 501 | } |
| 502 | |
| 503 | bool DbusPidZone::isPidProcessEnabled(std::string name) |
| 504 | { |
| 505 | return _pidsControlProcess[name]->enabled(); |
| 506 | } |
| 507 | |
ykchiu | 9fe3a3c | 2023-05-11 13:43:54 +0800 | [diff] [blame] | 508 | void DbusPidZone::initPidFailSafePercent(void) |
| 509 | { |
| 510 | // Currently, find the max failsafe percent pwm settings from zone and |
| 511 | // controller, and assign it to zone failsafe percent. |
| 512 | |
| 513 | _failSafePercent = _zoneFailSafePercent; |
| 514 | std::cerr << "zone: Zone" << _zoneId |
| 515 | << " zoneFailSafePercent: " << _zoneFailSafePercent << "\n"; |
| 516 | |
| 517 | for (const auto& [name, value] : _pidsFailSafePercent) |
| 518 | { |
| 519 | _failSafePercent = std::max(_failSafePercent, value); |
| 520 | std::cerr << "pid: " << name << " failSafePercent: " << value << "\n"; |
| 521 | } |
| 522 | |
| 523 | // when the final failsafe percent is zero , it indicate no failsafe |
| 524 | // percent is configured , set it to 100% as the default setting. |
| 525 | if (_failSafePercent == 0) |
| 526 | { |
| 527 | _failSafePercent = 100; |
| 528 | } |
| 529 | std::cerr << "Final zone" << _zoneId |
| 530 | << " failSafePercent: " << _failSafePercent << "\n"; |
| 531 | } |
| 532 | |
| 533 | void DbusPidZone::addPidFailSafePercent(std::string name, double percent) |
| 534 | { |
| 535 | _pidsFailSafePercent[name] = percent; |
| 536 | } |
| 537 | |
Harvey Wu | cc0232a | 2023-02-09 14:58:55 +0800 | [diff] [blame] | 538 | std::string DbusPidZone::leader() const |
| 539 | { |
| 540 | return _maximumSetPointName; |
| 541 | } |
| 542 | |
Harvey Wu | 3718006 | 2023-10-02 09:42:50 +0800 | [diff] [blame] | 543 | void DbusPidZone::updateThermalPowerDebugInterface(std::string pidName, |
| 544 | std::string leader, |
| 545 | double input, double output) |
| 546 | { |
| 547 | if (leader.empty()) |
| 548 | { |
| 549 | _pidsControlProcess[pidName]->output(output); |
| 550 | } |
| 551 | else |
| 552 | { |
| 553 | _pidsControlProcess[pidName]->leader(leader); |
| 554 | _pidsControlProcess[pidName]->input(input); |
| 555 | } |
| 556 | } |
| 557 | |
Patrick Venture | a076487 | 2020-08-08 07:48:43 -0700 | [diff] [blame] | 558 | } // namespace pid_control |