1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
/**
* 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.
*/
#include "pidloop.hpp"
#include "pid/pidcontroller.hpp"
#include "pid/tuning.hpp"
#include "sensors/sensor.hpp"
#include <boost/asio/steady_timer.hpp>
#include <chrono>
#include <map>
#include <memory>
#include <thread>
#include <vector>
static void processThermals(PIDZone* zone)
{
// Get the latest margins.
zone->updateSensors();
// Zero out the set point goals.
zone->clearSetPoints();
zone->clearRPMCeilings();
// Run the margin PIDs.
zone->processThermals();
// Get the maximum RPM setpoint.
zone->determineMaxSetPointRequest();
}
void pidControlLoop(PIDZone* zone, boost::asio::steady_timer& timer, bool first,
int ms100cnt)
{
if (first)
{
if (loggingEnabled)
{
zone->initializeLog();
}
zone->initializeCache();
processThermals(zone);
}
timer.expires_after(std::chrono::milliseconds(100));
timer.async_wait(
[zone, &timer, ms100cnt](const boost::system::error_code& ec) mutable {
if (ec == boost::asio::error::operation_aborted)
{
return; // timer being canceled, stop loop
}
/*
* This should sleep on the conditional wait for the listen thread
* to tell us it's in sync. But then we also need a timeout option
* in case phosphor-hwmon is down, we can go into some weird failure
* more.
*
* Another approach would be to start all sensors in worst-case
* values, and fail-safe mode and then clear out of fail-safe mode
* once we start getting values. Which I think it is a solid
* approach.
*
* For now this runs before it necessarily has any sensor values.
* For the host sensors they start out in fail-safe mode. For the
* fans, they start out as 0 as input and then are adjusted once
* they have values.
*
* If a fan has failed, it's value will be whatever we're told or
* however we retrieve it. This program disregards fan values of 0,
* so any code providing a fan speed can set to 0 on failure and
* that fan value will be effectively ignored. The PID algorithm
* will be unhappy but nothing bad will happen.
*
* TODO(venture): If the fan value is 0 should that loop just be
* skipped? Right now, a 0 value is ignored in
* FanController::inputProc()
*/
// Check if we should just go back to sleep.
if (zone->getManualMode())
{
pidControlLoop(zone, timer, false, ms100cnt);
return;
}
// Get the latest fan speeds.
zone->updateFanTelemetry();
if (10 <= ms100cnt)
{
ms100cnt = 0;
processThermals(zone);
}
// Run the fan PIDs every iteration.
zone->processFans();
if (loggingEnabled)
{
zone->getLogHandle() << "," << zone->getFailSafeMode();
zone->getLogHandle() << std::endl;
}
ms100cnt += 1;
pidControlLoop(zone, timer, false, ms100cnt);
});
}
|
