| /** |
| * Copyright 2017 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* Configuration. */ |
| #include "zone.hpp" |
| |
| #include "conf.hpp" |
| #include "pid/controller.hpp" |
| #include "pid/ec/pid.hpp" |
| #include "pid/fancontroller.hpp" |
| #include "pid/stepwisecontroller.hpp" |
| #include "pid/thermalcontroller.hpp" |
| #include "pid/tuning.hpp" |
| |
| #include <algorithm> |
| #include <chrono> |
| #include <cstring> |
| #include <fstream> |
| #include <iostream> |
| #include <memory> |
| #include <sstream> |
| #include <string> |
| |
| using tstamp = std::chrono::high_resolution_clock::time_point; |
| using namespace std::literals::chrono_literals; |
| |
| // Enforces minimum duration between events |
| // Rreturns true if event should be allowed, false if disallowed |
| bool allowThrottle(const tstamp& now, const std::chrono::seconds& pace) |
| { |
| static tstamp then; |
| static bool first = true; |
| |
| if (first) |
| { |
| // Special case initialization |
| then = now; |
| first = false; |
| |
| // Initialization, always allow |
| return true; |
| } |
| |
| auto elapsed = now - then; |
| if (elapsed < pace) |
| { |
| // Too soon since last time, disallow |
| return false; |
| } |
| |
| // It has been long enough, allow |
| then = now; |
| return true; |
| } |
| |
| namespace pid_control |
| { |
| |
| double DbusPidZone::getMaxSetPointRequest(void) const |
| { |
| return _maximumSetPoint; |
| } |
| |
| bool DbusPidZone::getManualMode(void) const |
| { |
| return _manualMode; |
| } |
| |
| void DbusPidZone::setManualMode(bool mode) |
| { |
| _manualMode = mode; |
| |
| // If returning to automatic mode, need to restore PWM from PID loop |
| if (!mode) |
| { |
| _redundantWrite = true; |
| } |
| } |
| |
| bool DbusPidZone::getFailSafeMode(void) const |
| { |
| // If any keys are present at least one sensor is in fail safe mode. |
| return !_failSafeSensors.empty(); |
| } |
| |
| void DbusPidZone::markSensorMissing(const std::string& name) |
| { |
| if (_missingAcceptable.find(name) != _missingAcceptable.end()) |
| { |
| // Disallow sensors in MissingIsAcceptable list from causing failsafe |
| return; |
| } |
| |
| _failSafeSensors.emplace(name); |
| } |
| |
| int64_t DbusPidZone::getZoneID(void) const |
| { |
| return _zoneId; |
| } |
| |
| void DbusPidZone::addSetPoint(double setPoint, const std::string& name) |
| { |
| /* exclude disabled pidloop from _maximumSetPoint calculation*/ |
| if (!isPidProcessEnabled(name)) |
| { |
| return; |
| } |
| |
| auto profileName = name; |
| if (getAccSetPoint()) |
| { |
| /* |
| * If the name of controller is Linear_Temp_CPU0. |
| * The profile name will be Temp_CPU0. |
| */ |
| profileName = name.substr(name.find("_") + 1); |
| _SetPoints[profileName] += setPoint; |
| } |
| else |
| { |
| if (_SetPoints[profileName] < setPoint) |
| { |
| _SetPoints[profileName] = setPoint; |
| } |
| } |
| |
| /* |
| * if there are multiple thermal controllers with the same |
| * value, pick the first one in the iterator |
| */ |
| if (_maximumSetPoint < _SetPoints[profileName]) |
| { |
| _maximumSetPoint = _SetPoints[profileName]; |
| _maximumSetPointName = profileName; |
| } |
| } |
| |
| void DbusPidZone::addRPMCeiling(double ceiling) |
| { |
| _RPMCeilings.push_back(ceiling); |
| } |
| |
| void DbusPidZone::clearRPMCeilings(void) |
| { |
| _RPMCeilings.clear(); |
| } |
| |
| void DbusPidZone::clearSetPoints(void) |
| { |
| _SetPoints.clear(); |
| _maximumSetPoint = 0; |
| _maximumSetPointName.clear(); |
| } |
| |
| double DbusPidZone::getFailSafePercent(void) const |
| { |
| return _failSafePercent; |
| } |
| |
| double DbusPidZone::getMinThermalSetPoint(void) const |
| { |
| return _minThermalOutputSetPt; |
| } |
| |
| uint64_t DbusPidZone::getCycleIntervalTime(void) const |
| { |
| return _cycleTime.cycleIntervalTimeMS; |
| } |
| |
| uint64_t DbusPidZone::getUpdateThermalsCycle(void) const |
| { |
| return _cycleTime.updateThermalsTimeMS; |
| } |
| |
| void DbusPidZone::addFanPID(std::unique_ptr<Controller> pid) |
| { |
| _fans.push_back(std::move(pid)); |
| } |
| |
| void DbusPidZone::addThermalPID(std::unique_ptr<Controller> pid) |
| { |
| _thermals.push_back(std::move(pid)); |
| } |
| |
| double DbusPidZone::getCachedValue(const std::string& name) |
| { |
| return _cachedValuesByName.at(name).scaled; |
| } |
| |
| ValueCacheEntry DbusPidZone::getCachedValues(const std::string& name) |
| { |
| return _cachedValuesByName.at(name); |
| } |
| |
| void DbusPidZone::setOutputCache(std::string_view name, |
| const ValueCacheEntry& values) |
| { |
| _cachedFanOutputs[std::string{name}] = values; |
| } |
| |
| void DbusPidZone::addFanInput(const std::string& fan, bool missingAcceptable) |
| { |
| _fanInputs.push_back(fan); |
| |
| if (missingAcceptable) |
| { |
| _missingAcceptable.emplace(fan); |
| } |
| } |
| |
| void DbusPidZone::addThermalInput(const std::string& therm, |
| bool missingAcceptable) |
| { |
| /* |
| * One sensor may have stepwise and PID at the same time. |
| * Searching the sensor name before inserting it to avoid duplicated sensor |
| * names. |
| */ |
| if (std::find(_thermalInputs.begin(), _thermalInputs.end(), therm) == |
| _thermalInputs.end()) |
| { |
| _thermalInputs.push_back(therm); |
| } |
| |
| if (missingAcceptable) |
| { |
| _missingAcceptable.emplace(therm); |
| } |
| } |
| |
| // Updates desired RPM setpoint from optional text file |
| // Returns true if rpmValue updated, false if left unchanged |
| static bool fileParseRpm(const std::string& fileName, double& rpmValue) |
| { |
| static constexpr std::chrono::seconds throttlePace{3}; |
| |
| std::string errText; |
| |
| try |
| { |
| std::ifstream ifs; |
| ifs.open(fileName); |
| if (ifs) |
| { |
| int value; |
| ifs >> value; |
| |
| if (value <= 0) |
| { |
| errText = "File content could not be parsed to a number"; |
| } |
| else if (value <= 100) |
| { |
| errText = "File must contain RPM value, not PWM value"; |
| } |
| else |
| { |
| rpmValue = static_cast<double>(value); |
| return true; |
| } |
| } |
| } |
| catch (const std::exception& e) |
| { |
| errText = "Exception: "; |
| errText += e.what(); |
| } |
| |
| // The file is optional, intentionally not an error if file not found |
| if (!(errText.empty())) |
| { |
| tstamp now = std::chrono::high_resolution_clock::now(); |
| if (allowThrottle(now, throttlePace)) |
| { |
| std::cerr << "Unable to read from '" << fileName << "': " << errText |
| << "\n"; |
| } |
| } |
| |
| return false; |
| } |
| |
| void DbusPidZone::determineMaxSetPointRequest(void) |
| { |
| std::vector<double>::iterator result; |
| double minThermalThreshold = getMinThermalSetPoint(); |
| |
| if (_RPMCeilings.size() > 0) |
| { |
| result = std::min_element(_RPMCeilings.begin(), _RPMCeilings.end()); |
| // if Max set point is larger than the lowest ceiling, reset to lowest |
| // ceiling. |
| if (*result < _maximumSetPoint) |
| { |
| _maximumSetPoint = *result; |
| // When using lowest ceiling, controller name is ceiling. |
| _maximumSetPointName = "Ceiling"; |
| } |
| } |
| |
| /* |
| * Combine the maximum SetPoint Name if the controllers have same profile |
| * name. e.g., PID_BB_INLET_TEMP_C + Stepwise_BB_INLET_TEMP_C. |
| */ |
| if (getAccSetPoint()) |
| { |
| auto profileName = _maximumSetPointName; |
| _maximumSetPointName = ""; |
| |
| for (auto& p : _thermals) |
| { |
| auto controllerID = p->getID(); |
| auto found = controllerID.find(profileName); |
| if (found != std::string::npos) |
| { |
| if (_maximumSetPointName.empty()) |
| { |
| _maximumSetPointName = controllerID; |
| } |
| else |
| { |
| _maximumSetPointName += " + " + controllerID; |
| } |
| } |
| } |
| } |
| |
| /* |
| * If the maximum RPM setpoint output is below the minimum RPM |
| * setpoint, set it to the minimum. |
| */ |
| if (minThermalThreshold >= _maximumSetPoint) |
| { |
| _maximumSetPoint = minThermalThreshold; |
| _maximumSetPointName = "Minimum"; |
| } |
| else if (_maximumSetPointName.compare(_maximumSetPointNamePrev)) |
| { |
| std::cerr << "PID Zone " << _zoneId << " max SetPoint " |
| << _maximumSetPoint << " requested by " |
| << _maximumSetPointName; |
| for (const auto& sensor : _failSafeSensors) |
| { |
| if (sensor.find("Fan") == std::string::npos) |
| { |
| std::cerr << " " << sensor; |
| } |
| } |
| std::cerr << "\n"; |
| _maximumSetPointNamePrev.assign(_maximumSetPointName); |
| } |
| if (tuningEnabled) |
| { |
| /* |
| * We received no setpoints from thermal sensors. |
| * This is a case experienced during tuning where they only specify |
| * fan sensors and one large fan PID for all the fans. |
| */ |
| static constexpr auto setpointpath = "/etc/thermal.d/setpoint"; |
| |
| fileParseRpm(setpointpath, _maximumSetPoint); |
| |
| // Allow per-zone setpoint files to override overall setpoint file |
| std::ostringstream zoneSuffix; |
| zoneSuffix << ".zone" << _zoneId; |
| std::string zoneSetpointPath = setpointpath + zoneSuffix.str(); |
| |
| fileParseRpm(zoneSetpointPath, _maximumSetPoint); |
| } |
| return; |
| } |
| |
| void DbusPidZone::initializeLog(void) |
| { |
| /* Print header for log file: |
| * 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 |
| */ |
| |
| _log << "epoch_ms,setpt,requester"; |
| |
| for (const auto& f : _fanInputs) |
| { |
| _log << "," << f << "," << f << "_raw"; |
| _log << "," << f << "_pwm," << f << "_pwm_raw"; |
| } |
| for (const auto& t : _thermalInputs) |
| { |
| _log << "," << t << "," << t << "_raw"; |
| } |
| |
| _log << ",failsafe"; |
| _log << std::endl; |
| } |
| |
| void DbusPidZone::writeLog(const std::string& value) |
| { |
| _log << value; |
| } |
| |
| /* |
| * TODO(venture) This is effectively updating the cache and should check if the |
| * values they're using to update it are new or old, or whatnot. For instance, |
| * if we haven't heard from the host in X time we need to detect this failure. |
| * |
| * I haven't decided if the Sensor should have a lastUpdated method or whether |
| * that should be for the ReadInterface or etc... |
| */ |
| |
| /** |
| * We want the PID loop to run with values cached, so this will get all the |
| * fan tachs for the loop. |
| */ |
| void DbusPidZone::updateFanTelemetry(void) |
| { |
| /* TODO(venture): Should I just make _log point to /dev/null when logging |
| * is disabled? I think it's a waste to try and log things even if the |
| * data is just being dropped though. |
| */ |
| const auto now = std::chrono::high_resolution_clock::now(); |
| if (loggingEnabled) |
| { |
| _log << std::chrono::duration_cast<std::chrono::milliseconds>( |
| now.time_since_epoch()) |
| .count(); |
| _log << "," << _maximumSetPoint; |
| _log << "," << _maximumSetPointName; |
| } |
| |
| processSensorInputs</* fanSensorLogging */ true>(_fanInputs, now); |
| |
| if (loggingEnabled) |
| { |
| for (const auto& t : _thermalInputs) |
| { |
| const auto& v = _cachedValuesByName[t]; |
| _log << "," << v.scaled << "," << v.unscaled; |
| } |
| } |
| |
| return; |
| } |
| |
| void DbusPidZone::updateSensors(void) |
| { |
| processSensorInputs</* fanSensorLogging */ false>( |
| _thermalInputs, std::chrono::high_resolution_clock::now()); |
| |
| return; |
| } |
| |
| void DbusPidZone::initializeCache(void) |
| { |
| auto nan = std::numeric_limits<double>::quiet_NaN(); |
| |
| for (const auto& f : _fanInputs) |
| { |
| _cachedValuesByName[f] = {nan, nan}; |
| _cachedFanOutputs[f] = {nan, nan}; |
| |
| // Start all fans in fail-safe mode. |
| markSensorMissing(f); |
| } |
| |
| for (const auto& t : _thermalInputs) |
| { |
| _cachedValuesByName[t] = {nan, nan}; |
| |
| // Start all sensors in fail-safe mode. |
| markSensorMissing(t); |
| } |
| // Initialize Pid FailSafePercent |
| initPidFailSafePercent(); |
| } |
| |
| void DbusPidZone::dumpCache(void) |
| { |
| std::cerr << "Cache values now: \n"; |
| for (const auto& [name, value] : _cachedValuesByName) |
| { |
| std::cerr << name << ": " << value.scaled << " " << value.unscaled |
| << "\n"; |
| } |
| |
| std::cerr << "Fan outputs now: \n"; |
| for (const auto& [name, value] : _cachedFanOutputs) |
| { |
| std::cerr << name << ": " << value.scaled << " " << value.unscaled |
| << "\n"; |
| } |
| } |
| |
| void DbusPidZone::processFans(void) |
| { |
| for (auto& p : _fans) |
| { |
| p->process(); |
| } |
| |
| if (_redundantWrite) |
| { |
| // This is only needed once |
| _redundantWrite = false; |
| } |
| } |
| |
| void DbusPidZone::processThermals(void) |
| { |
| for (auto& p : _thermals) |
| { |
| p->process(); |
| } |
| } |
| |
| Sensor* DbusPidZone::getSensor(const std::string& name) |
| { |
| return _mgr.getSensor(name); |
| } |
| |
| bool DbusPidZone::getRedundantWrite(void) const |
| { |
| return _redundantWrite; |
| } |
| |
| bool DbusPidZone::manual(bool value) |
| { |
| std::cerr << "manual: " << value << std::endl; |
| setManualMode(value); |
| return ModeObject::manual(value); |
| } |
| |
| bool DbusPidZone::failSafe() const |
| { |
| return getFailSafeMode(); |
| } |
| |
| void DbusPidZone::addPidControlProcess(std::string name, std::string type, |
| double setpoint, sdbusplus::bus_t& bus, |
| std::string objPath, bool defer) |
| { |
| _pidsControlProcess[name] = std::make_unique<ProcessObject>( |
| bus, objPath.c_str(), |
| defer ? ProcessObject::action::defer_emit |
| : ProcessObject::action::emit_object_added); |
| // Default enable setting = true |
| _pidsControlProcess[name]->enabled(true); |
| _pidsControlProcess[name]->setpoint(setpoint); |
| |
| if (type == "temp") |
| { |
| _pidsControlProcess[name]->classType("Temperature"); |
| } |
| else if (type == "margin") |
| { |
| _pidsControlProcess[name]->classType("Margin"); |
| } |
| else if (type == "power") |
| { |
| _pidsControlProcess[name]->classType("Power"); |
| } |
| else if (type == "powersum") |
| { |
| _pidsControlProcess[name]->classType("PowerSum"); |
| } |
| } |
| |
| bool DbusPidZone::isPidProcessEnabled(std::string name) |
| { |
| return _pidsControlProcess[name]->enabled(); |
| } |
| |
| void DbusPidZone::initPidFailSafePercent(void) |
| { |
| // Currently, find the max failsafe percent pwm settings from zone and |
| // controller, and assign it to zone failsafe percent. |
| |
| _failSafePercent = _zoneFailSafePercent; |
| std::cerr << "zone: Zone" << _zoneId |
| << " zoneFailSafePercent: " << _zoneFailSafePercent << "\n"; |
| |
| for (const auto& [name, value] : _pidsFailSafePercent) |
| { |
| _failSafePercent = std::max(_failSafePercent, value); |
| std::cerr << "pid: " << name << " failSafePercent: " << value << "\n"; |
| } |
| |
| // when the final failsafe percent is zero , it indicate no failsafe |
| // percent is configured , set it to 100% as the default setting. |
| if (_failSafePercent == 0) |
| { |
| _failSafePercent = 100; |
| } |
| std::cerr << "Final zone" << _zoneId |
| << " failSafePercent: " << _failSafePercent << "\n"; |
| } |
| |
| void DbusPidZone::addPidFailSafePercent(std::string name, double percent) |
| { |
| _pidsFailSafePercent[name] = percent; |
| } |
| |
| std::string DbusPidZone::leader() const |
| { |
| return _maximumSetPointName; |
| } |
| |
| void DbusPidZone::updateThermalPowerDebugInterface(std::string pidName, |
| std::string leader, |
| double input, double output) |
| { |
| if (leader.empty()) |
| { |
| _pidsControlProcess[pidName]->output(output); |
| } |
| else |
| { |
| _pidsControlProcess[pidName]->leader(leader); |
| _pidsControlProcess[pidName]->input(input); |
| } |
| } |
| |
| bool DbusPidZone::getAccSetPoint(void) const |
| { |
| return _accumulateSetPoint; |
| } |
| |
| } // namespace pid_control |