src/lib/THERMAL/devThermal.cpp

   1 #include "targets.h"
   2 #include "devThermal.h"
   3
   4 #if defined(HAS_THERMAL) || defined(HAS_FAN)
   5
   6 #include "config.h"
   7 #include "logging.h"
   8
   9 #if defined(TARGET_RX)
  10 extern RxConfig config;
  11 #else
  12 extern TxConfig config;
  13 #endif
  14 #define THERMAL_DURATION 1000
  15
  16 #if defined(HAS_THERMAL)
  17 #include "common.h"
  18 #include "thermal.h"
  19
  20 Thermal thermal;
  21
  22 #if defined(HAS_SMART_FAN)
  23 bool is_smart_fan_control = false;
  24 bool is_smart_fan_working = false;
  25 #endif
  26
  27 #ifdef HAS_THERMAL_LM75A
  28     #ifndef OPT_HAS_THERMAL_LM75A
  29         #define OPT_HAS_THERMAL_LM75A true
  30     #endif
  31 #else
  32     #define OPT_HAS_THERMAL_LM75A true
  33 #endif
  34
  35 #endif // HAS_THERMAL
  36
  37 #include "POWERMGNT.h"
  38
  39 #if defined(GPIO_PIN_FAN_PWM)
  40 constexpr uint8_t fanChannel = 0;
  41 #endif
  42
  43 #if !defined(FAN_MIN_RUNTIME)
  44     #define FAN_MIN_RUNTIME 30U // intervals (seconds)
  45 #endif
  46
  47 #define FAN_MIN_CHANGETIME 10U  // intervals (seconds)
  48
  49 #if !defined(TACHO_PULSES_PER_REV)
  50 #define TACHO_PULSES_PER_REV 4
  51 #endif
  52
  53 static uint16_t currentRPM = 0;
  54
  55 void init_rpm_counter(int pin);
  56 uint32_t get_rpm();
  57
  58 static void initialize()
  59 {
  60 #if defined(HAS_THERMAL)
  61 #if defined(PLATFORM_ESP32_S3)
  62     thermal.init();
  63 #else
  64     if (OPT_HAS_THERMAL_LM75A && GPIO_PIN_SCL != UNDEF_PIN && GPIO_PIN_SDA != UNDEF_PIN)
  65     {
  66         thermal.init();
  67     }
  68 #endif
  69 #endif
  70     if (GPIO_PIN_FAN_EN != UNDEF_PIN)
  71     {
  72         pinMode(GPIO_PIN_FAN_EN, OUTPUT);
  73     }
  74 }
  75
  76 static void timeoutThermal()
  77 {
  78 #if defined(HAS_THERMAL)
  79 #if !defined(PLATFORM_ESP32_S3)
  80     if(OPT_HAS_THERMAL_LM75A)
  81 #endif
  82     {
  83         thermal.handle();
  84 #ifdef HAS_SMART_FAN
  85         if(is_smart_fan_control & !is_smart_fan_working){
  86             is_smart_fan_working = true;
  87             thermal.update_threshold(USER_SMARTFAN_OFF);
  88         }
  89         if(!is_smart_fan_control & is_smart_fan_working){
  90             is_smart_fan_working = false;
  91 #endif
  92             thermal.update_threshold(config.GetFanMode());
  93 #ifdef HAS_SMART_FAN
  94         }
  95 #endif
  96     }
  97 #endif
  98 }
  99
 100 #if defined(PLATFORM_ESP32)
 101 #ifndef TARGET_RX
 102 static void setFanSpeed()
 103 {
 104     const uint8_t defaultFanSpeeds[] = {
 105         31,  // 10mW
 106         47,  // 25mW
 107         63,  // 50mW
 108         95,  // 100mW
 109         127, // 250mW
 110         191, // 500mW
 111         255, // 1000mW
 112         255  // 2000mW
 113     };
 114
 115     uint32_t speed = GPIO_PIN_FAN_SPEEDS == nullptr ? defaultFanSpeeds[POWERMGNT::currPower()] : GPIO_PIN_FAN_SPEEDS[POWERMGNT::currPower()-POWERMGNT::getMinPower()];
 116     ledcWrite(fanChannel, speed);
 117     DBGLN("Fan speed: %d (power) -> %u (pwm)", POWERMGNT::currPower(), speed);
 118 }
 119 #endif
 120 #endif
 121
 122 /*
 123  * For enable-only fans:
 124  *  Checks the PowerFanThreshold vs CurrPower and enables the fan if at or above the threshold
 125  *  using a hysteresis. To turn on it must be at/above the threshold for a small time
 126  *  and then to turn off it must be below the threshold for FAN_MIN_RUNTIME intervals.
 127  * For PWM fans:
 128  *  all of the above applies, but rather than just turning the fan on, the speed of the fan
 129  *  is set according to the power output level.
 130  */
 131 static void timeoutFan()
 132 {
 133 #if defined(HAS_FAN)
 134     static uint8_t fanStateDuration;
 135     static bool fanIsOn;
 136 #if defined(TARGET_RX)
 137     bool fanShouldBeOn = true;
 138 #else
 139     bool fanShouldBeOn = POWERMGNT::currPower() >= (PowerLevels_e)config.GetPowerFanThreshold();
 140 #endif
 141     if (fanIsOn)
 142     {
 143         if (fanShouldBeOn)
 144         {
 145 #if defined(PLATFORM_ESP32)
 146 #ifndef TARGET_RX
 147             if (GPIO_PIN_FAN_PWM != UNDEF_PIN)
 148             {
 149                 static PowerLevels_e lastPower = MinPower;
 150                 if (POWERMGNT::currPower() < lastPower && fanStateDuration < FAN_MIN_CHANGETIME)
 151                 {
 152                     ++fanStateDuration;
 153                 }
 154                 if (POWERMGNT::currPower() > lastPower || fanStateDuration >= FAN_MIN_CHANGETIME)
 155                 {
 156                     setFanSpeed();
 157                     lastPower = POWERMGNT::currPower();
 158                     fanStateDuration = 0; // reset the timeout
 159                 }
 160             }
 161             else
 162 #endif
 163 #endif
 164             {
 165                 fanStateDuration = 0; // reset the timeout
 166             }
 167         }
 168         else if (fanStateDuration < firmwareOptions.fan_min_runtime)
 169         {
 170             ++fanStateDuration; // counting to turn off
 171         }
 172         else
 173         {
 174             // turn off expired
 175             if (GPIO_PIN_FAN_EN != UNDEF_PIN)
 176             {
 177                 digitalWrite(GPIO_PIN_FAN_EN, LOW);
 178             }
 179 #if defined(PLATFORM_ESP32)
 180             else if (GPIO_PIN_FAN_PWM != UNDEF_PIN)
 181             {
 182                 ledcWrite(fanChannel, 0);
 183             }
 184 #endif
 185             fanStateDuration = 0;
 186             fanIsOn = false;
 187         }
 188     }
 189     // vv else fan is off currently vv
 190     else if (fanShouldBeOn)
 191     {
 192         // Delay turning the fan on for 4 cycles to be sure it really should be on
 193         if (fanStateDuration < 3)
 194         {
 195             ++fanStateDuration; // counting to turn on
 196         }
 197         else
 198         {
 199             if (GPIO_PIN_FAN_EN != UNDEF_PIN)
 200             {
 201                 digitalWrite(GPIO_PIN_FAN_EN, HIGH);
 202                 fanStateDuration = 0;
 203             }
 204 #if defined(PLATFORM_ESP32)
 205             else if (GPIO_PIN_FAN_PWM != UNDEF_PIN)
 206             {
 207                 // bump the fan to full power for one cycle in case
 208                 // the PWM level is not sufficient to get it moving
 209                 ledcWrite(fanChannel, 192);
 210                 fanStateDuration = FAN_MIN_CHANGETIME;
 211             }
 212 #endif
 213             fanIsOn = true;
 214         }
 215     }
 216 #endif
 217 }
 218
 219 uint16_t getCurrentRPM()
 220 {
 221     return currentRPM;
 222 }
 223
 224 static void timeoutTacho()
 225 {
 226 #if defined(PLATFORM_ESP32)
 227     if (GPIO_PIN_FAN_TACHO != UNDEF_PIN)
 228     {
 229         currentRPM = get_rpm();
 230         DBGVLN("RPM %d", currentRPM);
 231     }
 232 #endif
 233 }
 234
 235 static int start()
 236 {
 237 #if defined(PLATFORM_ESP32)
 238     if (GPIO_PIN_FAN_PWM != UNDEF_PIN)
 239     {
 240         ledcSetup(fanChannel, 25000, 8);
 241         ledcAttachPin(GPIO_PIN_FAN_PWM, fanChannel);
 242         ledcWrite(fanChannel, 0);
 243     }
 244     if (GPIO_PIN_FAN_TACHO != UNDEF_PIN)
 245     {
 246         init_rpm_counter(GPIO_PIN_FAN_TACHO);
 247     }
 248 #endif
 249     return DURATION_IMMEDIATELY;
 250 }
 251
 252 static int event()
 253 {
 254 #if defined(HAS_THERMAL)
 255     if (OPT_HAS_THERMAL_LM75A && GPIO_PIN_SCL != UNDEF_PIN && GPIO_PIN_SDA != UNDEF_PIN)
 256     {
 257 #ifdef HAS_SMART_FAN
 258         if(!is_smart_fan_control)
 259         {
 260 #endif
 261             thermal.update_threshold(config.GetFanMode());
 262 #ifdef HAS_SMART_FAN
 263         }
 264 #endif
 265     }
 266 #endif
 267     return DURATION_IGNORE;
 268 }
 269
 270 static int timeout()
 271 {
 272     timeoutThermal();
 273     timeoutFan();
 274     timeoutTacho();
 275     return THERMAL_DURATION;
 276 }
 277
 278 device_t Thermal_device = {
 279     .initialize = initialize,
 280     .start = start,
 281     .event = event,
 282     .timeout = timeout
 283 };
 284
 285 #endif // HAS_THERMAL || HAS_FAN