Variable Heater Temperature Control

#include <Arduino.h>
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>
#include <max6675.h>

constexpr int TFT_CS = 4;
constexpr int TFT_DC = 16;
constexpr int TFT_RST = 17;
constexpr int SPI_SCK = 18;
constexpr int SPI_MISO = 19;
constexpr int SPI_MOSI = 23;
constexpr int THERMO_CS = 25;
constexpr int SSR_PIN = 26;
constexpr int BUTTON_ENABLE = 27;
constexpr int BUTTON_UP = 32;
constexpr int BUTTON_DOWN = 33;

constexpr float MIN_SETPOINT_C = 30.0F;
constexpr float MAX_SETPOINT_C = 280.0F;
constexpr float START_SETPOINT_C = 150.0F;
constexpr float HARD_LIMIT_C = 300.0F;
constexpr float SETPOINT_STEP_C = 5.0F;
constexpr unsigned long SENSOR_INTERVAL_MS = 250;
constexpr unsigned long CONTROL_WINDOW_MS = 2000;
constexpr unsigned long DEBOUNCE_MS = 35;

Adafruit_ST7735 tft(TFT_CS, TFT_DC, TFT_RST);
MAX6675 thermocouple(SPI_SCK, THERMO_CS, SPI_MISO);

struct Button {
  int pin;
  bool rawLast;
  bool stablePressed;
  unsigned long changedAt;
};

Button enableButton = {BUTTON_ENABLE, false, false, 0};
Button upButton = {BUTTON_UP, false, false, 0};
Button downButton = {BUTTON_DOWN, false, false, 0};

float temperatureC = NAN;
float setpointC = START_SETPOINT_C;
bool heatEnabled = false;
bool safetyFault = false;
bool ssrOn = false;
unsigned long lastSensorAt = 0;
unsigned long controlWindowStart = 0;

char lastTempText[18] = "";
char lastSetText[18] = "";
char lastStatusText[20] = "";

bool buttonPressed(Button &button, unsigned long now) {
  bool rawPressed = digitalRead(button.pin) == LOW;
  if (rawPressed != button.rawLast) {
    button.rawLast = rawPressed;
    button.changedAt = now;
  }
  if ((now - button.changedAt) >= DEBOUNCE_MS && rawPressed != button.stablePressed) {
    button.stablePressed = rawPressed;
    return button.stablePressed;
  }
  return false;
}

void drawStaticScreen() {
  tft.fillScreen(ST77XX_BLACK);
  tft.setTextWrap(false);
  tft.setTextSize(1);
  tft.setTextColor(ST77XX_CYAN);
  tft.setCursor(4, 4);
  tft.print("CARTRIDGE HEATER");
  tft.drawFastHLine(0, 16, 160, ST77XX_BLUE);
  tft.setTextColor(ST77XX_WHITE);
  tft.setCursor(4, 27);
  tft.print("NOW");
  tft.setCursor(4, 67);
  tft.print("SET");
  tft.setCursor(4, 120);
  tft.print("UP/DN: 5C  EN: start");
}

void drawField(int16_t y, const char *text, uint16_t color, char *lastText, size_t lastTextSize) {
  if (strcmp(text, lastText) == 0) {
    return;
  }
  tft.fillRect(4, y, 152, 24, ST77XX_BLACK);
  tft.setTextSize(2);
  tft.setTextColor(color);
  tft.setCursor(4, y + 3);
  tft.print(text);
  strncpy(lastText, text, lastTextSize - 1);
  lastText[lastTextSize - 1] = '\0';
}

void updateDisplay() {
  char tempText[18];
  char setText[18];
  char statusText[20];

  if (isnan(temperatureC)) {
    snprintf(tempText, sizeof(tempText), "TEMP: --.- C");
  } else {
    snprintf(tempText, sizeof(tempText), "TEMP:%5.1f C", temperatureC);
  }
  snprintf(setText, sizeof(setText), "SET :%5.0f C", setpointC);

  uint16_t statusColor = ST77XX_YELLOW;
  if (safetyFault) {
    snprintf(statusText, sizeof(statusText), "FAULT: OFF");
    statusColor = ST77XX_RED;
  } else if (!heatEnabled) {
    snprintf(statusText, sizeof(statusText), "STOPPED");
  } else if (ssrOn) {
    snprintf(statusText, sizeof(statusText), "HEATING");
    statusColor = ST77XX_GREEN;
  } else {
    snprintf(statusText, sizeof(statusText), "HOLDING");
    statusColor = ST77XX_GREEN;
  }

  drawField(38, tempText, ST77XX_WHITE, lastTempText, sizeof(lastTempText));
  drawField(78, setText, ST77XX_YELLOW, lastSetText, sizeof(lastSetText));
  drawField(96, statusText, statusColor, lastStatusText, sizeof(lastStatusText));
}

void setHeater(bool on) {
  ssrOn = on;
  digitalWrite(SSR_PIN, on ? HIGH : LOW);
}

void updateControl(unsigned long now) {
  if (safetyFault || !heatEnabled || isnan(temperatureC)) {
    setHeater(false);
    return;
  }

  if (temperatureC >= HARD_LIMIT_C) {
    safetyFault = true;
    heatEnabled = false;
    setHeater(false);
    return;
  }

  float errorC = setpointC - temperatureC;
  float powerPercent = constrain(errorC * 12.0F, 0.0F, 100.0F);
  if (errorC <= -1.0F) {
    powerPercent = 0.0F;
  }

  if (now - controlWindowStart >= CONTROL_WINDOW_MS) {
    controlWindowStart = now;
  }
  unsigned long onTime = (unsigned long)(CONTROL_WINDOW_MS * (powerPercent / 100.0F));
  setHeater((now - controlWindowStart) < onTime);
}

void setup() {
  pinMode(SSR_PIN, OUTPUT);
  digitalWrite(SSR_PIN, LOW);
  pinMode(BUTTON_ENABLE, INPUT_PULLUP);
  pinMode(BUTTON_UP, INPUT_PULLUP);
  pinMode(BUTTON_DOWN, INPUT_PULLUP);

  SPI.begin(SPI_SCK, SPI_MISO, SPI_MOSI, TFT_CS);
  tft.initR(INITR_BLACKTAB);
  tft.setRotation(1);
  drawStaticScreen();
  updateDisplay();
  controlWindowStart = millis();
}

void loop() {
  const unsigned long now = millis();

  if (buttonPressed(upButton, now)) {
    setpointC = min(MAX_SETPOINT_C, setpointC + SETPOINT_STEP_C);
  }
  if (buttonPressed(downButton, now)) {
    setpointC = max(MIN_SETPOINT_C, setpointC - SETPOINT_STEP_C);
  }
  if (buttonPressed(enableButton, now) && !safetyFault) {
    heatEnabled = !heatEnabled;
  }

  if (now - lastSensorAt >= SENSOR_INTERVAL_MS) {
    lastSensorAt = now;
    float reading = thermocouple.readCelsius();
    if (isnan(reading) || reading < 0.0F || reading > 1024.0F) {
      temperatureC = NAN;
      safetyFault = true;
      heatEnabled = false;
    } else {
      temperatureC = reading;
    }
  }

  updateControl(now);
  updateDisplay();
  delay(5);
}