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 #include "pidloop.hpp" 18 19 #include "pid/pidcontroller.hpp" 20 #include "pid/tuning.hpp" 21 #include "pid/zone_interface.hpp" 22 #include "sensors/sensor.hpp" 23 24 #include <boost/asio/steady_timer.hpp> 25 26 #include <chrono> 27 #include <map> 28 #include <memory> 29 #include <sstream> 30 #include <vector> 31 32 namespace pid_control 33 { 34 35 static void processThermals(const std::shared_ptr<ZoneInterface>& zone) 36 { 37 // Get the latest margins. 38 zone->updateSensors(); 39 // Zero out the set point goals. 40 zone->clearSetPoints(); 41 zone->clearRPMCeilings(); 42 // Run the margin PIDs. 43 zone->processThermals(); 44 // Get the maximum RPM setpoint. 45 zone->determineMaxSetPointRequest(); 46 } 47 48 void pidControlLoop(const std::shared_ptr<ZoneInterface>& zone, 49 const std::shared_ptr<boost::asio::steady_timer>& timer, 50 const bool* isCanceling, bool first, uint64_t cycleCnt) 51 { 52 if (*isCanceling) 53 { 54 return; 55 } 56 57 std::chrono::steady_clock::time_point nextTime; 58 59 if (first) 60 { 61 if (loggingEnabled) 62 { 63 zone->initializeLog(); 64 } 65 66 zone->initializeCache(); 67 processThermals(zone); 68 69 nextTime = std::chrono::steady_clock::now(); 70 } 71 else 72 { 73 nextTime = timer->expiry(); 74 } 75 76 uint64_t msPerFanCycle = zone->getCycleIntervalTime(); 77 78 // Push forward the original expiration time of timer, instead of just 79 // resetting it with expires_after() from now, to make sure the interval 80 // is of the expected duration, and not stretched out by CPU time taken. 81 nextTime += std::chrono::milliseconds(msPerFanCycle); 82 timer->expires_at(nextTime); 83 timer->async_wait([zone, timer, cycleCnt, isCanceling, msPerFanCycle]( 84 const boost::system::error_code& ec) mutable { 85 if (ec == boost::asio::error::operation_aborted) 86 { 87 return; // timer being canceled, stop loop 88 } 89 90 /* 91 * This should sleep on the conditional wait for the listen thread 92 * to tell us it's in sync. But then we also need a timeout option 93 * in case phosphor-hwmon is down, we can go into some weird failure 94 * more. 95 * 96 * Another approach would be to start all sensors in worst-case 97 * values, and fail-safe mode and then clear out of fail-safe mode 98 * once we start getting values. Which I think it is a solid 99 * approach. 100 * 101 * For now this runs before it necessarily has any sensor values. 102 * For the host sensors they start out in fail-safe mode. For the 103 * fans, they start out as 0 as input and then are adjusted once 104 * they have values. 105 * 106 * If a fan has failed, it's value will be whatever we're told or 107 * however we retrieve it. This program disregards fan values of 0, 108 * so any code providing a fan speed can set to 0 on failure and 109 * that fan value will be effectively ignored. The PID algorithm 110 * will be unhappy but nothing bad will happen. 111 * 112 * TODO(venture): If the fan value is 0 should that loop just be 113 * skipped? Right now, a 0 value is ignored in 114 * FanController::inputProc() 115 */ 116 117 // Check if we should just go back to sleep. 118 if (zone->getManualMode()) 119 { 120 pidControlLoop(zone, timer, isCanceling, false, cycleCnt); 121 return; 122 } 123 124 // Get the latest fan speeds. 125 zone->updateFanTelemetry(); 126 127 uint64_t msPerThermalCycle = zone->getUpdateThermalsCycle(); 128 129 // Process thermal cycles at a rate that is less often than fan 130 // cycles. If thermal time is not an exact multiple of fan time, 131 // there will be some remainder left over, to keep the timing 132 // correct, as the intervals are staggered into one another. 133 if (cycleCnt >= msPerThermalCycle) 134 { 135 cycleCnt -= msPerThermalCycle; 136 137 processThermals(zone); 138 } 139 140 // Run the fan PIDs every iteration. 141 zone->processFans(); 142 143 if (loggingEnabled) 144 { 145 std::ostringstream out; 146 out << "," << zone->getFailSafeMode() << std::endl; 147 zone->writeLog(out.str()); 148 } 149 150 // Count how many milliseconds have elapsed, so we can know when 151 // to perform thermal cycles, in proper ratio with fan cycles. 152 cycleCnt += msPerFanCycle; 153 154 pidControlLoop(zone, timer, isCanceling, false, cycleCnt); 155 }); 156 } 157 158 } // namespace pid_control 159