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