Ampelsteuerung mit Shelly Plus RGBW PM -- Script-Problem

// Ampelsteuerung für Shelly Plus RGBW PM
// ===================================================
//
// Ampel-Zustände:
// 0              = alles aus
// Gelb blinken:  101 (gelb ein), 102 (gelb aus, dann zurück zu 101)
// Normale Ampel: 201...208 (Grün -> Gelb -> Rot -> Rot+Gelb)
// Lauflicht:     301...308 (Rot -> Gelb -> Grün -> Rot ... zyklisch)
//
// Eingänge (Schalter) bestimmen, in welchem Modus die Ampel läuft:
// Schalter-Kombinationen (summe der aktivierten Eingänge):
// 0 = alles aus
// 1 = Gelb blinkend
// 2 = normale Ampel
// 3 = Lauflicht
// 4 = alles aus
//
// Die Eingänge werden einzeln abgefragt (S1...S4) und über einfache
// Additionen zu einer "Schalter"-Variable kombiniert, um den Modus zu wählen.

// ============================
// Konfiguration & Konstanten
// ============================

const BRIGHTNESS = 15;       // Standard-Helligkeit
const LOOP_INTERVAL = 500;   // Intervall für den Hauptloop (ms)

// Zustände definieren (Konstanten für bessere Lesbarkeit)
const STATES = {
  OFF: 0,

  YELLOW_BLINK_ON: 101,
  YELLOW_BLINK_OFF: 102,

  NORMAL_GREEN_START: 201,
  NORMAL_GREEN: 202,
  NORMAL_YELLOW_START: 203,
  NORMAL_YELLOW: 204,
  NORMAL_RED_START: 205,
  NORMAL_RED: 206,
  NORMAL_RED_YELLOW_START: 207,
  NORMAL_RED_YELLOW: 208,

  RUN_START: 301,
  RUN_WAIT_1: 302,
  RUN_SWITCH_YELLOW: 303,
  RUN_WAIT_2: 304,
  RUN_SWITCH_GREEN: 305,
  RUN_WAIT_3: 306,
  RUN_SWITCH_RED: 307,
  RUN_WAIT_4: 308,
};

// Dauer der einzelnen Phasen (wie oft Loop durchlaufen wird, bis nächster Schritt)
const TIMINGS = {
  NORMAL_GREEN: 6,
  NORMAL_YELLOW: 4,
  NORMAL_RED: 6,
  NORMAL_RED_YELLOW: 2,

  RUN_PHASE: 2, // Wartezeit für jede Lauflicht-Zwischenphase
};

// ============================
// Globale Variablen
// ============================

let Ampel = STATES.OFF;  
let LoopCount = 0;
let oldSchalter = 10; // Startwert für Schalter, um initialen Wechsel zu erkennen

// ============================
// Hilfsfunktionen
// ============================

// Alle Kanäle ausschalten
function AlleAus() {
  for (let i = 0; i < 4; i++) {
    Shelly.call("Light.set", { id: i, on: false, brightness: BRIGHTNESS });
  }
}

// Eingänge (Schalter) auslesen und kombinierten Wert zurückgeben
function readInputs() {
  const S1 = Shelly.getComponentStatus("input:0").state ? 1 : 0;
  const S2 = Shelly.getComponentStatus("input:1").state ? 2 : 0;
  const S3 = Shelly.getComponentStatus("input:2").state ? 3 : 0;
  const S4 = Shelly.getComponentStatus("input:3").state ? 4 : 0;

  // Summe bildet den "Schalter"-Wert
  return S1 + S2 + S3 + S4;
}

// Ampel-Wert anpassen, wenn sich der Schalterzustand ändert
function updateAmpelFromInputs() {
  const Schalter = readInputs();
  if (oldSchalter !== Schalter) {
    switch (Schalter) {
      case 0:
        Ampel = STATES.OFF;
        break;
      case 1:
        Ampel = STATES.YELLOW_BLINK_ON;
        break;
      case 2:
        Ampel = STATES.NORMAL_GREEN_START;
        break;
      case 3:
        Ampel = STATES.RUN_START;
        break;
      case 4:
        Ampel = STATES.OFF;
        break;
      default:
        Ampel = STATES.OFF; // Fallback, falls unerwarteter Wert
        break;
    }
    print(`Old: ${oldSchalter} Neu: ${Schalter} Ampel: ${Ampel} (${typeof Ampel})`);
    oldSchalter = Schalter;
  }
}

// Zustandslogik anwenden, abhängig von Ampel
function applyState() {
  switch (Ampel) {
    case STATES.OFF:
      AlleAus();
      break;

    // Gelb blinken
    case STATES.YELLOW_BLINK_ON:
      print("Blinklicht AN");
      Shelly.call("Light.set", { id: 1, on: true });
      Ampel = STATES.YELLOW_BLINK_OFF;
      break;

    case STATES.YELLOW_BLINK_OFF:
      Shelly.call("Light.setAll", { on: false });
      Ampel = STATES.YELLOW_BLINK_ON;
      break;

    // Normale Ampel
    case STATES.NORMAL_GREEN_START:
      print("Normale Ampel: Grünphase starten");
      Shelly.call("Light.set", { id: 2, on: true }); // Grün an
      Shelly.call("Light.set", { id: 1, on: false }); // Gelb aus
      Shelly.call("Light.set", { id: 0, on: false }); // Rot aus
      LoopCount = 0;
      Ampel = STATES.NORMAL_GREEN;
      break;

    case STATES.NORMAL_GREEN:
      LoopCount++;
      if (LoopCount > TIMINGS.NORMAL_GREEN) {
        Ampel = STATES.NORMAL_YELLOW_START;
      }
      break;

    case STATES.NORMAL_YELLOW_START:
      Shelly.call("Light.set", { id: 1, on: true });  // Gelb an
      Shelly.call("Light.set", { id: 2, on: false }); // Grün aus
      LoopCount = 0;
      Ampel = STATES.NORMAL_YELLOW;
      break;

    case STATES.NORMAL_YELLOW:
      LoopCount++;
      if (LoopCount > TIMINGS.NORMAL_YELLOW) {
        Ampel = STATES.NORMAL_RED_START;
      }
      break;

    case STATES.NORMAL_RED_START:
      Shelly.call("Light.set", { id: 0, on: true });  // Rot an
      Shelly.call("Light.set", { id: 1, on: false }); // Gelb aus
      LoopCount = 0;
      Ampel = STATES.NORMAL_RED;
      break;

    case STATES.NORMAL_RED:
      LoopCount++;
      if (LoopCount > TIMINGS.NORMAL_RED) {
        Ampel = STATES.NORMAL_RED_YELLOW_START;
      }
      break;

    case STATES.NORMAL_RED_YELLOW_START:
      LoopCount = 0;
      Shelly.call("Light.set", { id: 1, on: true }); // Gelb an
      Ampel = STATES.NORMAL_RED_YELLOW;
      break;

    case STATES.NORMAL_RED_YELLOW:
      LoopCount++;
      if (LoopCount > TIMINGS.NORMAL_RED_YELLOW) {
        Ampel = STATES.NORMAL_GREEN_START; // Zyklus von vorn (Grünphase)
      }
      break;

    // Lauflicht
    case STATES.RUN_START:
      print("Lauflicht starten");
      AlleAus();
      LoopCount = 0;
      Shelly.call("Light.set", { id: 0, on: true }); // Rot an
      Ampel = STATES.RUN_WAIT_1;
      break;

    case STATES.RUN_WAIT_1:
      LoopCount++;
      if (LoopCount > TIMINGS.RUN_PHASE) {
        Ampel = STATES.RUN_SWITCH_YELLOW;
      }
      break;

    case STATES.RUN_SWITCH_YELLOW:
      Shelly.call("Light.set", { id: 0, on: false });
      Shelly.call("Light.set", { id: 1, on: true });
      LoopCount = 0;
      Ampel = STATES.RUN_WAIT_2;
      break;

    case STATES.RUN_WAIT_2:
      LoopCount++;
      if (LoopCount > TIMINGS.RUN_PHASE) {
        Ampel = STATES.RUN_SWITCH_GREEN;
      }
      break;

    case STATES.RUN_SWITCH_GREEN:
      Shelly.call("Light.set", { id: 1, on: false });
      Shelly.call("Light.set", { id: 2, on: true });
      LoopCount = 0;
      Ampel = STATES.RUN_WAIT_3;
      break;

    case STATES.RUN_WAIT_3:
      LoopCount++;
      if (LoopCount > TIMINGS.RUN_PHASE) {
        Ampel = STATES.RUN_SWITCH_RED;
      }
      break;

    case STATES.RUN_SWITCH_RED:
      Shelly.call("Light.set", { id: 2, on: false });
      Shelly.call("Light.set", { id: 0, on: true });
      LoopCount = 0;
      Ampel = STATES.RUN_WAIT_4;
      break;

    case STATES.RUN_WAIT_4:
      LoopCount++;
      if (LoopCount > TIMINGS.RUN_PHASE) {
        Ampel = STATES.RUN_WAIT_1; // Zurück zum Start des Laufs (Endlos-Schleife)
      }
      break;

    default:
      // Unerwarteter Zustand: Sicherheitshalber alles aus und zurück auf OFF
      AlleAus();
      Ampel = STATES.OFF;
      break;
  }
}

// Haupt-Schleifenfunktion, wird alle LOOP_INTERVAL ms aufgerufen
function loop() {
  updateAmpelFromInputs();
  applyState();
}

// Initialisierung: alles aus
AlleAus();

// Timer setzen für die Hauptschleife
Timer.set(LOOP_INTERVAL, true, loop);