Compressor Drain Timer

#include <Arduino.h>
#include <Wire.h>
#include <Preferences.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

constexpr uint8_t RELAY_PIN = 25;
constexpr uint8_t SDA_PIN = 21;
constexpr uint8_t SCL_PIN = 22;
constexpr uint8_t ACK_BUTTON_PIN = 4;
constexpr uint8_t MOTOR_RUN_PIN = 27;
constexpr uint8_t AIR_ENABLE_RELAY_PIN = 26;
constexpr uint8_t MAIN_SWITCH_PIN = 33;
constexpr uint8_t OLED_ADDRESS = 0x3C;
// ================================================================
// HIER DIE ZEITEN FUER DIE WARTUNG EINSTELLEN:
// Nach 8 Stunden Motorlaufzeit erscheint die Aufforderung zum Ablassen.
constexpr uint32_t DRAIN_WARNING_HOURS = 8UL;
// Nach 12 Stunden Motorlaufzeit wird die Luftzufuhr gesperrt,
// bis das Kondenswasser abgelassen wurde. Diese Zahl muss mindestens
// so gross sein wie DRAIN_WARNING_HOURS.
constexpr uint32_t AIR_LOCKOUT_HOURS = 12UL;
constexpr uint32_t DRAIN_WARNING_SECONDS = DRAIN_WARNING_HOURS * 60UL * 60UL;
constexpr uint32_t AIR_LOCKOUT_SECONDS = AIR_LOCKOUT_HOURS * 60UL * 60UL;
// HIER DIE ABLAUFZEIT EINSTELLEN: 10000UL = Ventil 10 Sekunden offen.
constexpr uint32_t DRAIN_OPEN_MS = 10000UL;
constexpr uint32_t SAVE_PERIOD_MS = 60000UL;
constexpr uint32_t DISPLAY_PERIOD_MS = 1000UL;
constexpr uint32_t DEBOUNCE_MS = 40UL;
constexpr uint32_t RESET_HOLD_MS = 10000UL;
// The 3.3 V opto-isolated relay is active LOW.
constexpr uint8_t RELAY_ON = LOW;
constexpr uint8_t RELAY_OFF = HIGH;

Adafruit_SSD1306 display(128, 64, &Wire, -1);
Preferences preferences;
// accumulatedSeconds ist der sichtbare Gesamt-Laufzeitzähler.
// serviceSeconds zählt nur bis zur nächsten vorgeschriebenen Entwässerung.
uint32_t accumulatedSeconds = 0, serviceSeconds = 0, runningMilliseconds = 0;
uint32_t lastRunSampleAt = 0, lastSaveAt = 0, lastDisplayAt = 0, valveOpenedAt = 0;
bool valveOpen = false, serviceDue = false, airLockout = false;
bool lastButtonReading = HIGH, stableButtonState = HIGH, longPressReported = false;
uint32_t buttonChangedAt = 0, buttonPressedAt = 0;

enum ButtonAction { NONE, SHORT_PRESS, LONG_PRESS };

void saveRunTime() {
  preferences.putUInt("runSecs", accumulatedSeconds);
  preferences.putUInt("serviceSecs", serviceSeconds);
  preferences.putUInt("runMs", runningMilliseconds);
  lastSaveAt = millis();
}

void drawText(const char *line1, const char *line2, const char *line3) {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  display.setCursor(0, 0); display.println(line1);
  display.setCursor(0, 20); display.println(line2);
  display.setCursor(0, 42); display.println(line3);
  display.display();
}

void updateAirEnable() {
  // Der 230-V-Relaiskontakt ist bei eingeschaltetem Hauptschalter geschlossen.
  const bool mainSwitchOn = digitalRead(MAIN_SWITCH_PIN) == LOW;
  // Zwischen Warnung und Sperre bleibt die Luft noch eingeschaltet.
  // Erst nach AIR_LOCKOUT_HOURS oder waehrend des Ablassens wird sie gesperrt.
  const bool allowAir = mainSwitchOn && !airLockout && !valveOpen;
  digitalWrite(AIR_ENABLE_RELAY_PIN, allowAir ? RELAY_ON : RELAY_OFF);
}

void showStatus() {
  if ((uint32_t)(millis() - lastDisplayAt) < DISPLAY_PERIOD_MS) return;
  lastDisplayAt = millis();
  char line1[22], line2[22], line3[25];
  if (valveOpen) {
    const uint32_t elapsed = millis() - valveOpenedAt;
    const uint32_t secondsLeft = (DRAIN_OPEN_MS - min(elapsed, DRAIN_OPEN_MS) + 999UL) / 1000UL;
    snprintf(line1, sizeof(line1), "Kondenswasser");
    snprintf(line2, sizeof(line2), "ablassen: %lu s", (unsigned long)secondsLeft);
    snprintf(line3, sizeof(line3), "");
  } else if (airLockout) {
    snprintf(line1, sizeof(line1), "Kondenswasser");
    snprintf(line2, sizeof(line2), "ablassen - Taste");
    snprintf(line3, sizeof(line3), "Luftzufuhr gesperrt");
  } else if (serviceDue) {
    const uint32_t remainingSeconds = AIR_LOCKOUT_SECONDS - min(serviceSeconds, AIR_LOCKOUT_SECONDS);
    const uint32_t remainingMinutes = (remainingSeconds + 59UL) / 60UL;
    snprintf(line1, sizeof(line1), "Kondenswasser");
    snprintf(line2, sizeof(line2), "ablassen - Taste");
    snprintf(line3, sizeof(line3), "Luft noch %lum", (unsigned long)remainingMinutes);
  } else {
    const uint32_t mins = accumulatedSeconds / 60UL;
    snprintf(line1, sizeof(line1), "Laufzeit: %luh %02lum", (unsigned long)(mins / 60UL), (unsigned long)(mins % 60UL));
    snprintf(line2, sizeof(line2), "%s", digitalRead(MOTOR_RUN_PIN) == LOW ? "Motor laeuft" : "Motor steht");
    snprintf(line3, sizeof(line3), "Ablassen nach %lu h", (unsigned long)DRAIN_WARNING_HOURS);
  }
  drawText(line1, line2, line3);
}

ButtonAction readButton() {
  const bool reading = digitalRead(ACK_BUTTON_PIN);
  const uint32_t now = millis();
  if (reading != lastButtonReading) { buttonChangedAt = now; lastButtonReading = reading; }
  if ((uint32_t)(now - buttonChangedAt) >= DEBOUNCE_MS && reading != stableButtonState) {
    stableButtonState = reading;
    if (reading == LOW) { buttonPressedAt = now; longPressReported = false; }
    else if (!longPressReported) return SHORT_PRESS;
  }
  if (stableButtonState == LOW && !longPressReported && (uint32_t)(now - buttonPressedAt) >= RESET_HOLD_MS) {
    longPressReported = true;
    return LONG_PRESS;
  }
  return NONE;
}

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, RELAY_OFF);
  pinMode(AIR_ENABLE_RELAY_PIN, OUTPUT);
  digitalWrite(AIR_ENABLE_RELAY_PIN, RELAY_OFF);
  pinMode(ACK_BUTTON_PIN, INPUT_PULLUP);
  pinMode(MOTOR_RUN_PIN, INPUT_PULLUP);
  pinMode(MAIN_SWITCH_PIN, INPUT_PULLUP);
  Wire.begin(SDA_PIN, SCL_PIN);
  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS)) {
    for (;;) delay(1000);
  }
  preferences.begin("compressor", false);
  accumulatedSeconds = preferences.getUInt("runSecs", 0);
  serviceSeconds = preferences.getUInt("serviceSecs", 0);
  runningMilliseconds = preferences.getUInt("runMs", 0);
  serviceDue = serviceSeconds >= DRAIN_WARNING_SECONDS;
  airLockout = serviceSeconds >= AIR_LOCKOUT_SECONDS;
  lastRunSampleAt = millis();
  lastSaveAt = millis();
  drawText("Kompressor", "Startet...", "");
}

void loop() {
  const uint32_t now = millis();
  const uint32_t elapsed = now - lastRunSampleAt;
  lastRunSampleAt = now;

  // Auch nach der 8-Stunden-Warnung wird weitergezaehlt, damit die
  // 12-Stunden-Sperre erreicht werden kann. Nur waehrend des Ablassens
  // wird keine Motorlaufzeit hinzugefuegt.
  if (!valveOpen && digitalRead(MOTOR_RUN_PIN) == LOW) {
    runningMilliseconds += elapsed;
    while (runningMilliseconds >= 1000UL) {
      runningMilliseconds -= 1000UL;
      ++accumulatedSeconds;
      ++serviceSeconds;
    }
    const bool wasServiceDue = serviceDue;
    const bool wasAirLockout = airLockout;
    serviceDue = serviceSeconds >= DRAIN_WARNING_SECONDS;
    airLockout = serviceSeconds >= AIR_LOCKOUT_SECONDS;
    if ((!wasServiceDue && serviceDue) || (!wasAirLockout && airLockout)) saveRunTime();
  }

  const ButtonAction action = readButton();
  if (!valveOpen && action == LONG_PRESS) {
    accumulatedSeconds = 0;
    serviceSeconds = 0;
    runningMilliseconds = 0;
    serviceDue = false;
    airLockout = false;
    saveRunTime();
  } else if (!valveOpen && serviceDue && action == SHORT_PRESS) {
    digitalWrite(RELAY_PIN, RELAY_ON);
    valveOpen = true;
    valveOpenedAt = now;
  }

  if (valveOpen && (uint32_t)(now - valveOpenedAt) >= DRAIN_OPEN_MS) {
    digitalWrite(RELAY_PIN, RELAY_OFF);
    valveOpen = false;
    // Nur der Wartungszähler beginnt nach erfolgreichem Ablassen neu.
    // Der sichtbare Gesamt-Laufzeitzähler bleibt unverändert.
    serviceSeconds = 0;
    serviceDue = false;
    airLockout = false;
    saveRunTime();
  }
  updateAirEnable();
  if (!valveOpen && (uint32_t)(now - lastSaveAt) >= SAVE_PERIOD_MS) saveRunTime();
  showStatus();
  delay(10);
}