Dual-Zone Fan Controller

#include <Arduino.h>
#include <OneWire.h>
#include <DallasTemperature.h>

// Set to 1 only after entering real network and MQTT details below.
// Cooling is entirely local and does not depend on this feature.
#define ENABLE_MQTT 0
#if ENABLE_MQTT
#include <WiFi.h>
#include <PubSubClient.h>
const char *WIFI_SSID = "YOUR_WIFI_NAME";
const char *WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";
const char *MQTT_HOST = "192.168.1.10";
const uint16_t MQTT_PORT = 1883;
const char *MQTT_TOPIC = "adsb-enclosure/cooling/state";
WiFiClient wifiClient;
PubSubClient mqttClient(wifiClient);
#endif

#define ONEWIRE_PIN 4
#define FAN_PWM_PIN 5
#define FAN_TACH_PIN 6

constexpr uint32_t PWM_FREQUENCY_HZ = 25000;
constexpr uint8_t PWM_RESOLUTION_BITS = 10;
constexpr uint16_t PWM_MAX = (1U << PWM_RESOLUTION_BITS) - 1U;
constexpr float MIN_FAN_PERCENT = 35.0f;
constexpr float FULL_FAN_PERCENT = 100.0f;
constexpr float TEMP_START_C = 30.0f;
constexpr float TEMP_FULL_C = 55.0f;
constexpr float TEMP_HYSTERESIS_C = 1.5f;
constexpr float SLEW_PERCENT_PER_STEP = 1.0f;
constexpr uint32_t CONTROL_INTERVAL_MS = 250;
constexpr uint32_t TEMP_INTERVAL_MS = 1000;
constexpr uint32_t TACH_WINDOW_MS = 5000;
constexpr uint32_t STARTUP_FULL_SPEED_MS = 5000;
constexpr uint16_t STALL_RPM_LIMIT = 200;
constexpr uint8_t FAN_PULSES_PER_REV = 2;

OneWire oneWire(ONEWIRE_PIN);
DallasTemperature sensors(&oneWire);
DeviceAddress sensorAddress[2];
bool sensorPresent[2] = {false, false};
float compartmentC[2] = {NAN, NAN};
volatile uint32_t tachPulses = 0;
float fanPercent = FULL_FAN_PERCENT;
float requestedPercent = FULL_FAN_PERCENT;
uint16_t fanRpm = 0;
bool sensorFault = true;
bool stallFault = false;
uint32_t startupUntil = 0;
uint32_t lastControlMs = 0;
uint32_t lastTempMs = 0;
uint32_t lastTachMs = 0;
uint32_t lastMqttMs = 0;

void IRAM_ATTR onTachPulse() {
  tachPulses++;
}

void applyFanPercent(float percent) {
  percent = constrain(percent, 0.0f, 100.0f);
  // GPIO high turns Q1 on, pulling the fan's PWM wire low. This is the
  // active-low open-drain control expected by a compliant 4-wire PWM fan.
  const uint16_t duty = static_cast<uint16_t>((percent * PWM_MAX) / 100.0f);
  ledcWrite(FAN_PWM_PIN, duty);
  fanPercent = percent;
}

float demandForTemperature(float temperatureC) {
  if (temperatureC <= TEMP_START_C - TEMP_HYSTERESIS_C) return MIN_FAN_PERCENT;
  if (temperatureC >= TEMP_FULL_C) return FULL_FAN_PERCENT;
  const float span = TEMP_FULL_C - (TEMP_START_C - TEMP_HYSTERESIS_C);
  return MIN_FAN_PERCENT + (temperatureC - (TEMP_START_C - TEMP_HYSTERESIS_C)) *
         (FULL_FAN_PERCENT - MIN_FAN_PERCENT) / span;
}

void discoverSensors() {
  sensors.begin();
  const uint8_t found = sensors.getDeviceCount();
  for (uint8_t i = 0; i < 2; i++) {
    sensorPresent[i] = (i < found) && sensors.getAddress(sensorAddress[i], i);
    if (sensorPresent[i]) sensors.setResolution(sensorAddress[i], 12);
  }
}

void readTemperatures() {
  sensorFault = false;
  sensors.requestTemperatures();
  for (uint8_t i = 0; i < 2; i++) {
    if (!sensorPresent[i]) {
      sensorFault = true;
      compartmentC[i] = NAN;
      continue;
    }
    const float value = sensors.getTempC(sensorAddress[i]);
    // DallasTemperature returns DEVICE_DISCONNECTED_C (-127) when absent.
    if (value == DEVICE_DISCONNECTED_C || value < -55.0f || value > 125.0f) {
      sensorFault = true;
      compartmentC[i] = NAN;
    } else {
      compartmentC[i] = value;
    }
  }
}

void updateTachometer(uint32_t now) {
  if (now - lastTachMs < TACH_WINDOW_MS) return;
  noInterrupts();
  const uint32_t pulses = tachPulses;
  tachPulses = 0;
  interrupts();
  const uint32_t elapsed = now - lastTachMs;
  lastTachMs = now;
  fanRpm = static_cast<uint16_t>((pulses * 60000UL) / (FAN_PULSES_PER_REV * elapsed));
  // Do not report a stall while deliberately asking for a low fan speed.
  stallFault = (fanPercent >= 45.0f && fanRpm < STALL_RPM_LIMIT);
}

#if ENABLE_MQTT
void publishTelemetry(uint32_t now) {
  if (now - lastMqttMs < 10000) return;
  lastMqttMs = now;
  if (WiFi.status() != WL_CONNECTED) {
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    return;
  }
  if (!mqttClient.connected()) {
    mqttClient.connect("adsb-cooling-controller");
    return;
  }
  char payload[220];
  snprintf(payload, sizeof(payload),
           "{\"upper_c\":%.2f,\"lower_c\":%.2f,\"fan_rpm\":%u,\"pwm_percent\":%.1f,\"sensor_fault\":%s,\"stall_fault\":%s}",
           compartmentC[0], compartmentC[1], fanRpm, fanPercent,
           sensorFault ? "true" : "false", stallFault ? "true" : "false");
  mqttClient.publish(MQTT_TOPIC, payload, true);
}
#endif

void setup() {
  // Default to full speed before temperature discovery or any network activity.
  ledcAttach(FAN_PWM_PIN, PWM_FREQUENCY_HZ, PWM_RESOLUTION_BITS);
  applyFanPercent(FULL_FAN_PERCENT);
  pinMode(FAN_TACH_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(FAN_TACH_PIN), onTachPulse, FALLING);
  Serial.begin(115200);
  discoverSensors();
  startupUntil = millis() + STARTUP_FULL_SPEED_MS;
  lastTachMs = millis();
#if ENABLE_MQTT
  WiFi.mode(WIFI_STA);
  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
#endif
}

void loop() {
  const uint32_t now = millis();
  if (now - lastTempMs >= TEMP_INTERVAL_MS) {
    lastTempMs = now;
    readTemperatures();
  }
  updateTachometer(now);

  if (now - lastControlMs >= CONTROL_INTERVAL_MS) {
    lastControlMs = now;
    if (now < startupUntil || sensorFault || stallFault) {
      requestedPercent = FULL_FAN_PERCENT;
    } else {
      const float hotterC = max(compartmentC[0], compartmentC[1]);
      requestedPercent = demandForTemperature(hotterC);
    }
    if (fanPercent < requestedPercent) fanPercent = min(fanPercent + SLEW_PERCENT_PER_STEP, requestedPercent);
    if (fanPercent > requestedPercent) fanPercent = max(fanPercent - SLEW_PERCENT_PER_STEP, requestedPercent);
    applyFanPercent(fanPercent);
  }

#if ENABLE_MQTT
  mqttClient.loop();
  publishTelemetry(now);
#endif
  delay(10);
}