1 #pragma once 2 3 #include "sensors/sensor.hpp" 4 5 #include <string> 6 7 namespace pid_control 8 { 9 10 /** 11 * In a Zone you have a set of PIDs which feed each other. Fan PIDs are fed set 12 * points from Thermal PIDs. 13 */ 14 class ZoneInterface 15 { 16 public: 17 virtual ~ZoneInterface() = default; 18 19 /** If the zone implementation supports logging, initialize the log. */ 20 virtual void initializeLog(void) = 0; 21 /** If the zone implementation supports logging, write string to log. */ 22 virtual void writeLog(const std::string& value) = 0; 23 24 /** Return a pointer to the sensor specified by name. */ 25 virtual Sensor* getSensor(const std::string& name) = 0; 26 27 /* updateFanTelemetry() and updateSensors() both clear the failsafe state 28 * for a sensor if it's no longer in that state. 29 */ 30 /** For each fan input in the zone, read each to update the cachedValue and 31 * check if the fan is beyond its timeout to trigger a failsafe condition. 32 */ 33 virtual void updateFanTelemetry(void) = 0; 34 /** For each thermal input in the zone, read each to update the cachedValue 35 * and check if the sensor is beyond its timeout to trigger a failsafe 36 * condition. 37 */ 38 virtual void updateSensors(void) = 0; 39 /** For each fan and thermal input in the zone, set the cachedValue to 0 and 40 * set the input as failsafe - to default the zone to failsafe before it 41 * starts processing values to control fans. 42 */ 43 virtual void initializeCache(void) = 0; 44 45 /** Optionally adds fan outputs to an output cache, which is different 46 * from the input cache accessed by getCachedValue(), so it is possible 47 * to have entries with the same name in both the output cache and 48 * the input cache. The output cache is used for logging, to show 49 * the PWM values determined by the PID loop, next to the resulting RPM. 50 */ 51 virtual void setOutputCache(std::string_view name, 52 const ValueCacheEntry& values) = 0; 53 54 /** Return cached value for sensor by name. */ 55 virtual double getCachedValue(const std::string& name) = 0; 56 /** Return cached values, both scaled and original unscaled values, 57 * for sensor by name. Subclasses can add trivial return {value, value}, 58 * for subclasses that only implement getCachedValue() and do not care 59 * about maintaining the distinction between scaled and unscaled values. 60 */ 61 virtual ValueCacheEntry getCachedValues(const std::string& name) = 0; 62 63 /** Add a set point value for the Max Set Point computation. */ 64 virtual void addSetPoint(double setpoint, const std::string& name) = 0; 65 /** Clear all set points specified via addSetPoint */ 66 virtual void clearSetPoints(void) = 0; 67 68 /** Add maximum RPM value to drive fan pids. */ 69 virtual void addRPMCeiling(double ceiling) = 0; 70 /** Clear any RPM value set with addRPMCeiling. */ 71 virtual void clearRPMCeilings(void) = 0; 72 73 /** Compute the value returned by getMaxSetPointRequest - called from the 74 * looping mechanism before triggering any Fan PIDs. The value computed is 75 * used by each fan PID. 76 */ 77 virtual void determineMaxSetPointRequest(void) = 0; 78 /** Given the set points added via addSetPoint, return the maximum value - 79 * called from the PID loop that uses that value to drive the fans. 80 */ 81 virtual double getMaxSetPointRequest() const = 0; 82 83 /** Return if the zone has any sensors in fail safe mode. */ 84 virtual bool getFailSafeMode() const = 0; 85 /** Return the rpm or pwm percent value to drive fan pids when zone is in 86 * fail safe. 87 */ 88 virtual double getFailSafePercent() const = 0; 89 90 /** Return the zone's cycle time settings */ 91 virtual uint64_t getCycleIntervalTime(void) const = 0; 92 virtual uint64_t getUpdateThermalsCycle(void) const = 0; 93 94 /** Return if the zone is set to manual mode. false equates to automatic 95 * mode (the default). 96 */ 97 virtual bool getManualMode(void) const = 0; 98 99 /** Returns true if a redundant fan PWM write is needed. Redundant write 100 * is used when returning the fan to automatic mode from manual mode. 101 */ 102 virtual bool getRedundantWrite(void) const = 0; 103 104 /** For each fan pid, do processing. */ 105 virtual void processFans(void) = 0; 106 /** For each thermal pid, do processing. */ 107 virtual void processThermals(void) = 0; 108 }; 109 110 } // namespace pid_control 111