HVAC thermostat on an Arduino Uno

// HVAC thermostat: a two-stage heat and cool thermostat that behaves like a
// real one, with the compressor protected and the fan on its delays.
//
// THIS IS A TEACHING MODEL. A real thermostat switches 24 VAC with relays or
// triacs between R (the 24 V hot from the transformer) and the call wires,
// with C as the transformer's common. Here the calls are five LEDs on 5 V
// logic, and none of that 24 VAC wiring is modeled beyond using its names.
// Never connect this to a real furnace, air conditioner or heat pump.
//
//   pin 2    DS18B20 data (4.7 kohm pull-up to 5 V), the room temperature
//   pin 4    mode switch, bit 0   (switch to GND = 1)
//   pin 5    mode switch, bit 1   (switch to GND = 1)
//   A0       heat setpoint knob   55 to 80 F
//   A1       cool setpoint knob   65 to 90 F
//   pin 6    W1  heat, first stage      (red LED)
//   pin 7    W2  heat, second stage     (red LED)
//   pin 8    Y1  cool, compressor       (blue LED)
//   pin 9    Y2  cool, second stage     (blue LED)
//   pin 10   G   fan                    (green LED)
//
// MODE (bit 1, bit 0):  00 OFF   01 HEAT   10 COOL   11 AUTO
//
// STAGES, in whole degrees F around the setpoint
//   Heat  W1 on at setpoint - 1, off at the setpoint (1 F of hysteresis).
//         W2 on when the gap grows to 3 F, or when W1 has run past the stage
//         timer and the room is still 1 F short; W2 off again at 0.5 F short.
//   Cool  Y1 on at setpoint + 1, off at the setpoint.
//         Y2 on at +3 F, or after the stage timer with the room still +1 F;
//         off again at +0.5 F.
//   AUTO  uses both setpoints; the cool setpoint is held at least 3 F above
//         the heat setpoint so the two can never chase each other.
//
// COMPRESSOR PROTECTION (Y1 and Y2)
//   Minimum off time: after the compressor stops, Y1 will not start again
//   until the time is up, and also not for that long after power-up. A call
//   that wants it sooner just waits.
//   Minimum on time: once Y1 starts it runs at least that long, even if the
//   room is satisfied or the mode is switched away.
//
// FAN (G)
//   Cooling: G comes on with the Y1 call and runs on for the cooling fan
//   off-delay after Y1 drops, to blow the last of the cold off the coil.
//   Heating: G waits for the heating fan on-delay after W1, so the heat
//   exchanger warms up before the blower pushes air through it, and drops
//   with the call. (A real furnace runs its own off-delay as well.)
//
// INTERLOCK
//   Heat and cool are never called together. W1 will not start while Y1 or
//   Y2 is on, and Y1 will not start while W1 or W2 is on, so a changeover
//   (a mode switch from COOL to HEAT, say) waits for the first side to stop.
//
// SCALED TIME
//   The real times are a 3 minute minimum off, a 2 minute minimum on, a 60 s
//   cooling fan off-delay, a 30 s heating fan on-delay and a 10 minute stage
//   timer. So that a simulation shows them in seconds, every one is divided
//   by SCALE (20): 9 s, 6 s, 3 s, 1.5 s and 30 s here. Set SCALE to 1 for the
//   real times.
//
// If the sensor is missing the thermostat calls for nothing (a fault line is
// printed), and the compressor still honors its minimum on time.

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

const int PIN_SENSOR = 2;
const int PIN_MODE_BIT0 = 4;
const int PIN_MODE_BIT1 = 5;
const int PIN_W1 = 6;
const int PIN_W2 = 7;
const int PIN_Y1 = 8;
const int PIN_Y2 = 9;
const int PIN_G = 10;
const int PIN_HEAT_KNOB = A0;
const int PIN_COOL_KNOB = A1;

const unsigned long SCALE = 20;
const unsigned long MIN_OFF_MS = 180000UL / SCALE;
const unsigned long MIN_ON_MS = 120000UL / SCALE;
const unsigned long COOL_FAN_OFF_MS = 60000UL / SCALE;
const unsigned long HEAT_FAN_ON_MS = 30000UL / SCALE;
const unsigned long STAGE2_TIMER_MS = 600000UL / SCALE;

// Temperatures are whole tenths of a degree F.
const int STAGE1_BAND = 10;
const int STAGE2_BAND = 30;
const int STAGE2_RELEASE = 5;
const int AUTO_GAP = 30;

enum Mode { OFF, HEAT, COOL, AUTO };
const char *const MODE_NAME[] = {"OFF", "HEAT", "COOL", "AUTO"};

OneWire oneWire(PIN_SENSOR);
DallasTemperature sensors(&oneWire);
DeviceAddress room;
bool haveSensor = false;

bool w1 = false, w2 = false, y1 = false, y2 = false, g = false;
unsigned long w1On = 0, y1On = 0;
unsigned long y1OffAt = 0;       // 0 at power-up: the minimum off time runs from boot
unsigned long coolFanUntil = 0;
bool holdW1 = false, holdY1Start = false, holdY1Stop = false;

int tempTenths = 700;
bool tempOk = false;
bool converting = false;
unsigned long requestedAt = 0;
unsigned long lastStatus = 0;
int heatSp = 70, coolSp = 75;
int coolEff = 75;               // the cool setpoint in use (AUTO keeps it 3 F above heat)

void printTenths(int t) {
  Serial.print(t / 10);
  Serial.print('.');
  Serial.print(t % 10);
}

void drive(int pin, bool &state, bool next, const char *name) {
  if (state == next) return;
  state = next;
  digitalWrite(pin, next ? HIGH : LOW);
  Serial.print(name);
  Serial.print(next ? " on   T " : " off  T ");
  printTenths(tempTenths);
  Serial.println("F");
}

// Print a hold line once, when the wait begins.
void note(bool &flag, bool holding, const char *text, unsigned long msLeft) {
  if (holding && !flag) {
    Serial.print("HOLD ");
    Serial.print(text);
    if (msLeft > 0) {
      Serial.print(" (");
      Serial.print((msLeft + 999) / 1000);
      Serial.print(" s left)");
    }
    Serial.println();
  }
  flag = holding;
}

void control(int mode) {
  unsigned long now = millis();
  int hsp = heatSp * 10;
  int csp = coolSp * 10;
  if (mode == AUTO && csp < hsp + AUTO_GAP) csp = hsp + AUTO_GAP;
  coolEff = csp / 10;
  int t = tempTenths;
  bool heatMode = tempOk && (mode == HEAT || mode == AUTO);
  bool coolMode = tempOk && (mode == COOL || mode == AUTO);

  // Heat: W1 first, so a changeover releases the heat side before cool asks.
  bool wantW1 = heatMode && (w1 ? t < hsp : t <= hsp - STAGE1_BAND);
  bool holding = false;
  if (wantW1 && !w1) {
    if (y1 || y2) {
      holding = true;
    } else {
      drive(PIN_W1, w1, true, "W1");
      w1On = now;
    }
  } else if (!wantW1 && w1) {
    drive(PIN_W2, w2, false, "W2");
    drive(PIN_W1, w1, false, "W1");
  }
  note(holdW1, holding, "W1: cooling is still on", 0);

  bool wantW2 = w1 && wantW1 &&
                (w2 ? t < hsp - STAGE2_RELEASE
                    : (t <= hsp - STAGE2_BAND ||
                       (now - w1On >= STAGE2_TIMER_MS && t <= hsp - STAGE1_BAND)));
  drive(PIN_W2, w2, wantW2, "W2");

  // Cool: Y1 is the compressor contactor.
  bool wantY1 = coolMode && (y1 ? t > csp : t >= csp + STAGE1_BAND);
  holding = false;
  if (wantY1 && !y1) {
    if (w1 || w2) {
      holding = true;
    } else if (now - y1OffAt < MIN_OFF_MS) {
      note(holdY1Start, true, "Y1: compressor minimum off", MIN_OFF_MS - (now - y1OffAt));
      holding = true;
    } else {
      drive(PIN_Y1, y1, true, "Y1");
      y1On = now;
    }
  }
  if (!(wantY1 && !y1)) holdY1Start = false;
  if (!wantY1 && y1) {
    if (now - y1On < MIN_ON_MS) {
      note(holdY1Stop, true, "Y1: compressor minimum on", MIN_ON_MS - (now - y1On));
    } else {
      holdY1Stop = false;
      drive(PIN_Y2, y2, false, "Y2");
      drive(PIN_Y1, y1, false, "Y1");
      y1OffAt = now;
    }
  } else {
    holdY1Stop = false;
  }
  bool wantY2 = y1 && wantY1 &&
                (y2 ? t > csp + STAGE2_RELEASE
                    : (t >= csp + STAGE2_BAND ||
                       (now - y1On >= STAGE2_TIMER_MS && t >= csp + STAGE1_BAND)));
  drive(PIN_Y2, y2, wantY2, "Y2");

  // Fan: with cooling at once and for the off-delay after; for heat, after
  // the on-delay.
  if (y1) coolFanUntil = now + COOL_FAN_OFF_MS;
  bool fan = y1 || (long)(coolFanUntil - now) > 0 || (w1 && now - w1On >= HEAT_FAN_ON_MS);
  drive(PIN_G, g, fan, "G");
}

void readSensor() {
  if (!haveSensor) return;
  if (!converting) {
    sensors.requestTemperatures();
    requestedAt = millis();
    converting = true;
  } else if (millis() - requestedAt >= 800) {
    converting = false;
    long raw = sensors.getTemp(room);
    if (raw == DEVICE_DISCONNECTED_RAW) {
      if (tempOk) Serial.println("FAULT: sensor not answering, no calls");
      tempOk = false;
    } else {
      // raw is 1/128 C; F = C * 1.8 + 32, in tenths.
      tempTenths = (int)((raw * 18 + (raw < 0 ? -64 : 64)) / 128) + 320;
      tempOk = true;
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(PIN_MODE_BIT0, INPUT_PULLUP);
  pinMode(PIN_MODE_BIT1, INPUT_PULLUP);
  const int outs[] = {PIN_W1, PIN_W2, PIN_Y1, PIN_Y2, PIN_G};
  for (int i = 0; i < 5; i++) {
    pinMode(outs[i], OUTPUT);
    digitalWrite(outs[i], LOW);
  }
  Serial.println("Mokxi Arduino Uno: HVAC thermostat (teaching model, 20x faster timers)");
  sensors.begin();
  sensors.setWaitForConversion(false);
  haveSensor = sensors.getAddress(room, 0);
  if (!haveSensor) Serial.println("FAULT: no DS18B20 on pin 2");
  Serial.println("compressor lockout after power-up: Y1 waits for the minimum off time");
}

void loop() {
  int mode = (digitalRead(PIN_MODE_BIT1) == LOW ? 2 : 0) | (digitalRead(PIN_MODE_BIT0) == LOW ? 1 : 0);
  heatSp = 55 + (analogRead(PIN_HEAT_KNOB) * 25L + 511) / 1023;
  coolSp = 65 + (analogRead(PIN_COOL_KNOB) * 25L + 511) / 1023;
  readSensor();
  control(mode);

  if (millis() - lastStatus >= 1000) {
    lastStatus = millis();
    Serial.print("T ");
    printTenths(tempTenths);
    Serial.print("F  ");
    Serial.print(MODE_NAME[mode]);
    Serial.print("  heat ");
    Serial.print(heatSp);
    Serial.print("  cool ");
    Serial.print(coolEff);
    Serial.print("  W1 ");
    Serial.print(w1);
    Serial.print(" W2 ");
    Serial.print(w2);
    Serial.print(" Y1 ");
    Serial.print(y1);
    Serial.print(" Y2 ");
    Serial.print(y2);
    Serial.print(" G ");
    Serial.println(g);
  }
}