blob: ddfea203dc45f9632dc98ee7834697826b5e1494 [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
Patrick Ventured8012182018-03-08 08:21:38 -080017#include "fancontroller.hpp"
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070018
Patrick Venturec32e3fc2019-02-28 10:01:11 -080019#include "tuning.hpp"
Patrick Ventured8012182018-03-08 08:21:38 -080020#include "util.hpp"
21#include "zone.hpp"
22
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070023#include <algorithm>
Josh Lehanca791152020-09-20 23:41:39 -070024#include <cmath>
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070025#include <iostream>
26
Patrick Venturea0764872020-08-08 07:48:43 -070027namespace pid_control
28{
29
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070030std::unique_ptr<PIDController>
Patrick Venture563a3562018-10-30 09:31:26 -070031 FanController::createFanPid(ZoneInterface* owner, const std::string& id,
Patrick Venture4a2dc4d2018-10-23 09:02:55 -070032 const std::vector<std::string>& inputs,
Patrick Venturef77d5a52018-10-23 09:32:52 -070033 const ec::pidinfo& initial)
Patrick Ventured8012182018-03-08 08:21:38 -080034{
Patrick Venture566a1512018-06-12 14:51:07 -070035 if (inputs.size() == 0)
36 {
37 return nullptr;
38 }
Patrick Ventured8012182018-03-08 08:21:38 -080039 auto fan = std::make_unique<FanController>(id, inputs, owner);
Patrick Venture563a3562018-10-30 09:31:26 -070040 ec::pid_info_t* info = fan->getPIDInfo();
Patrick Ventured8012182018-03-08 08:21:38 -080041
Patrick Venture7af157b2018-10-30 11:24:40 -070042 initializePIDStruct(info, initial);
Patrick Ventured8012182018-03-08 08:21:38 -080043
44 return fan;
45}
46
Patrick Venture5f59c0f2018-11-11 12:55:14 -080047double FanController::inputProc(void)
Patrick Ventured8012182018-03-08 08:21:38 -080048{
Josh Lehand38ae272020-11-13 02:59:30 -080049 double value = 0.0;
50 std::vector<double> values;
51 std::vector<double>::iterator result;
Patrick Ventured8012182018-03-08 08:21:38 -080052
53 try
54 {
55 for (const auto& name : _inputs)
56 {
Josh Lehand38ae272020-11-13 02:59:30 -080057 // Read the unscaled value, to correctly recover the RPM
58 value = _owner->getCachedValues(name).unscaled;
59
Patrick Ventured8012182018-03-08 08:21:38 -080060 /* If we have a fan we can't read, its value will be 0 for at least
61 * some boards, while others... the fan will drop off dbus (if
62 * that's how it's being read and in that case its value will never
63 * be updated anymore, which is relatively harmless, except, when
64 * something tries to read its value through IPMI, and can't, they
65 * sort of have to guess -- all the other fans are reporting, why
66 * not this one? Maybe it's unable to be read, so it's "bad."
67 */
Josh Lehanca791152020-09-20 23:41:39 -070068 if (!(std::isfinite(value)))
Patrick Ventured8012182018-03-08 08:21:38 -080069 {
Josh Lehanca791152020-09-20 23:41:39 -070070 continue;
Patrick Ventured8012182018-03-08 08:21:38 -080071 }
Josh Lehand38ae272020-11-13 02:59:30 -080072 if (value <= 0.0)
Josh Lehanca791152020-09-20 23:41:39 -070073 {
74 continue;
75 }
76
77 values.push_back(value);
Patrick Ventured8012182018-03-08 08:21:38 -080078 }
79 }
80 catch (const std::exception& e)
81 {
Patrick Venture563a3562018-10-30 09:31:26 -070082 std::cerr << "exception on inputProc.\n";
Patrick Ventured8012182018-03-08 08:21:38 -080083 throw;
84 }
85
Patrick Venture566a1512018-06-12 14:51:07 -070086 /* Reset the value from the above loop. */
Josh Lehand38ae272020-11-13 02:59:30 -080087 value = 0.0;
Patrick Ventured8012182018-03-08 08:21:38 -080088 if (values.size() > 0)
89 {
Patrick Ventured8012182018-03-08 08:21:38 -080090 /* the fan PID algorithm was unstable with average, and seemed to work
91 * better with minimum. I had considered making this choice a variable
Patrick Venturedf766f22018-10-13 09:30:58 -070092 * in the configuration, and it's a nice-to-have..
Patrick Ventured8012182018-03-08 08:21:38 -080093 */
94 result = std::min_element(values.begin(), values.end());
95 value = *result;
96 }
97
Patrick Venture5f59c0f2018-11-11 12:55:14 -080098 return value;
Patrick Ventured8012182018-03-08 08:21:38 -080099}
100
Patrick Venture5f59c0f2018-11-11 12:55:14 -0800101double FanController::setptProc(void)
Patrick Ventured8012182018-03-08 08:21:38 -0800102{
Patrick Venturef7a2dd52019-07-16 14:31:13 -0700103 double maxRPM = _owner->getMaxSetPointRequest();
Patrick Ventured8012182018-03-08 08:21:38 -0800104
105 // store for reference, and check if more or less.
Patrick Venture5f59c0f2018-11-11 12:55:14 -0800106 double prev = getSetpoint();
Patrick Ventured8012182018-03-08 08:21:38 -0800107
108 if (maxRPM > prev)
109 {
110 setFanDirection(FanSpeedDirection::UP);
111 }
112 else if (prev > maxRPM)
113 {
114 setFanDirection(FanSpeedDirection::DOWN);
115 }
116 else
117 {
118 setFanDirection(FanSpeedDirection::NEUTRAL);
119 }
120
Patrick Venture563a3562018-10-30 09:31:26 -0700121 setSetpoint(maxRPM);
Patrick Ventured8012182018-03-08 08:21:38 -0800122
123 return (maxRPM);
124}
125
Patrick Venture5f59c0f2018-11-11 12:55:14 -0800126void FanController::outputProc(double value)
Patrick Ventured8012182018-03-08 08:21:38 -0800127{
Patrick Venture5f59c0f2018-11-11 12:55:14 -0800128 double percent = value;
Patrick Ventured8012182018-03-08 08:21:38 -0800129
Patrick Venturede79ee02019-05-08 14:50:00 -0700130 /* If doing tuning, don't go into failsafe mode. */
131 if (!tuningEnabled)
Patrick Ventured8012182018-03-08 08:21:38 -0800132 {
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800133 if (_owner->getFailSafeMode())
Patrick Ventured8012182018-03-08 08:21:38 -0800134 {
Brandon Kimbcdeb832022-08-15 23:27:36 +0000135 double failsafePercent = _owner->getFailSafePercent();
136
137#ifdef STRICT_FAILSAFE_PWM
138 // Unconditionally replace the computed PWM with the
139 // failsafe PWM if STRICT_FAILSAFE_PWM is defined.
140 percent = failsafePercent;
141#else
142 // Ensure PWM is never lower than the failsafe PWM.
143 // The computed PWM is still allowed to rise higher than
144 // failsafe PWM if STRICT_FAILSAFE_PWM is NOT defined.
145 // This is the default behavior.
146 if (percent < failsafePercent)
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800147 {
Brandon Kimbcdeb832022-08-15 23:27:36 +0000148 percent = failsafePercent;
Patrick Venturec32e3fc2019-02-28 10:01:11 -0800149 }
Bonnie Loc51ba912022-10-12 14:07:22 +0800150
151 if (failsafePrint || debugEnabled)
152 {
153 std::cerr << "Zone " << _owner->getZoneID()
154 << " fans output failsafe pwm: " << percent << "\n";
155 failsafePrint = false;
156 }
Brandon Kimbcdeb832022-08-15 23:27:36 +0000157#endif
Patrick Ventured8012182018-03-08 08:21:38 -0800158 }
Bonnie Loc51ba912022-10-12 14:07:22 +0800159 else
160 {
161 failsafePrint = true;
162 if (debugEnabled)
163 {
164 std::cerr << "Zone " << _owner->getZoneID()
165 << " fans output pwm: " << percent << "\n";
166 }
167 }
Patrick Ventured8012182018-03-08 08:21:38 -0800168 }
Patrick Ventured8012182018-03-08 08:21:38 -0800169
170 // value and kFanFailSafeDutyCycle are 10 for 10% so let's fix that.
Josh Lehand38ae272020-11-13 02:59:30 -0800171 percent /= 100.0;
Patrick Ventured8012182018-03-08 08:21:38 -0800172
173 // PidSensorMap for writing.
Patrick Venture4a2dc4d2018-10-23 09:02:55 -0700174 for (const auto& it : _inputs)
Patrick Ventured8012182018-03-08 08:21:38 -0800175 {
Patrick Venturea58197c2018-06-11 15:29:45 -0700176 auto sensor = _owner->getSensor(it);
Josh Lehana4146eb2020-10-01 11:49:09 -0700177 auto redundantWrite = _owner->getRedundantWrite();
Josh Lehan3f0f7bc2023-02-13 01:45:29 -0800178 int64_t rawWritten = -1;
Josh Lehana4146eb2020-10-01 11:49:09 -0700179 sensor->write(percent, redundantWrite, &rawWritten);
Josh Lehanb3005752022-02-22 20:48:07 -0800180
181 // The outputCache will be used later,
182 // to store a record of the PWM commanded,
183 // so that this information can be included during logging.
184 auto unscaledWritten = static_cast<double>(rawWritten);
185 _owner->setOutputCache(sensor->getName(), {percent, unscaledWritten});
Patrick Ventured8012182018-03-08 08:21:38 -0800186 }
187
Patrick Ventured8012182018-03-08 08:21:38 -0800188 return;
189}
Patrick Venturea0764872020-08-08 07:48:43 -0700190
191} // namespace pid_control