Zum Inhalt

steuve.tc

steuve_verbraucher.tc — schaltet Verbraucher (Shelly oder Tasmota im WLAN/LAN) nach der §14a-Grenze, die der

Source on GitHub

// @name: SteuVE Verbraucher
// @version: 20261101_0900
// ─────────────────────────────────────────────────────────────────────
// steuve_verbraucher.tc — schaltet Verbraucher (Shelly oder Tasmota im WLAN/LAN) nach der §14a-Grenze, die der
// Treiber xdrv_128 (steuerbare Verbrauchseinrichtung, Rolle 3) vom Energy Guard empfaengt.
//
// Plaetze: 1..4 = Verbraucher (Platz = Prio; Prio 4 wird zuerst abgeschaltet, Prio 1 zuletzt),
//          5    = Melder (Shelly Plus Plug S, LED-Ring zeigt den Zustand; schaltet nichts ab).
// Die Liste pflegt die Bedienseite /steuve (Reiter Shellys) per STVSET; gespeichert im Flash (persist).
// IP leer oder 1. Oktett 0  -> Platz frei: wird nicht abgefragt, nicht geschaltet, zaehlt nicht.
// Fake = 1                  -> Platz wird SIMULIERT (Testprofil), es geht nichts ins Netz.
// abschaltbar = 0           -> wird nur gemessen und mitgemeldet, nie geschaltet.
//
// Ablauf (TaskLoop, alle ABFRAGE_S Sekunden):
//   1. Leistung aller belegten Verbraucher lesen (echt oder simuliert)
//   2. Summe an den Treiber:  EEBusCsPower <W>   -> geht als Messwert an den Energy Guard
//   3. Zustand vom Treiber:   sensorGet("EEBusCs#...") -> Begrenzt / Grenze / Zustand (Treiber ab SteuVE v008)
//   4. Begrenzt und Summe > Grenze: abschaltbare Verbraucher abschalten, die GERADE ziehen,
//      hoechste Prio-Zahl zuerst, bis Summe <= Grenze (BNetzA BK6-22-300 Anl. 1 Ziff. 4.6:
//      kann ein Geraet nicht genau reduzieren -> naechstniedriger technisch moeglicher Wert = aus)
//   5. Wieder einschalten, gestaffelt einer je EIN_ABSTAND_S (Ziff. 4.3: schrittweise Rueckkehr),
//      nur was DIESES Skript abgeschaltet hat. Waehrend einer Begrenzung nur, wenn
//        - der Verbraucher mindestens MIN_AUS_S aus war (gegen Pendeln) und
//        - Summe + seine NENNLEISTUNG <= Grenze - RESERVE_W (mit Volllast gerechnet, nicht mit dem
//          Momentanwert — eine Waschmaschine zieht nach dem Waschen wieder 2 kW zum Heizen)
//   6. Protokoll /steuve_log.csv (Dateisystem des Skripts, bei SD-Karte dort): minuetlich waehrend einer Begrenzung und 10 min danach
//   7. Melder: LED-Ring gruen = frei, gelb = begrenzt, rot = Failsafe, blau = ohne Energy Guard
//      (Ring-Befehle: Plus Plug S PLUGS_UI, Plug PM Gen3 plugpm_ui)
//
// Testprofile (Fake), ausgedacht, NICHT gemessen — sollen nur wechselnde Leistung erzeugen:
//   1 Waschmaschine  15 min 2100 W Heizen -> 40 min 150/300 W Waschen -> 10 min 500 W Schleudern
//   2 Trockner       60 min Heizung taktet 5 min 2400 W / 1 min 300 W -> 10 min 300 W Abkuehlen
//   3 Geschirrspueler 20 min 2000 W -> 30 min 100 W -> 10 min 2000 W -> 30 min 50 W Trocknen
//   4 Heizstab       Thermostat 30 min 3000 W / 10 min aus
// Simulierte Abschaltung (STVMODE): 0 = Programm haelt an und laeuft danach weiter,
//   1 = Programm startet von vorn, 2 = Geraet bleibt aus (schlimmster Fall, bis neu gespeichert).
//
// Konsole (Praefix STV):
//   STVSTAT                      Kurzstand
//   STVLIST                      Messwerte je Platz  [Platz,W,an,vonSteuVE,Fehler] + Melder (Farbe) + Mode
//   STVCFG                       Liste je Platz      [Platz,"Name","IP",Nenn,Fake,abschaltbar,Profil,Typ,"Modell"]
//   STVSET p,fake,abs,ip,nenn,profil,name    Platz p (1..5) setzen und speichern
//   STVPROBE p                   Shelly auf Platz p nach Modell/Generation fragen (naechste Runde)
//   STVMODE 0|1|2                simulierte Abschaltung (s.o.)
//   STVSIM <W> [s] | STVSIM 0    Grenze simulieren (ruft EEBusCsSim) — Test ohne Energy Guard
//
// v010 (21.10.2026): keine Funktionsaenderung — neue Fassung zum Test der .pvs-Uebernahme beim Laden ueber die IDE.
// v009 (21.10.2026): Tasmota-Felder mit #-Pfad lesen (Status#Power, StatusSNS#ENERGY#Power) — v008 las "Power" ohne
//   Pfad, fand nichts in der verschachtelten Antwort: Relais nicht erkannt (Typ 8 statt 7), Leistung 0.
// v008 (21.10.2026): Tasmota-Geraete mit Energiemessung (Steckdosen, Leisten, Zaehler). Erkennen: antwortet ein
//   Platz nicht als Shelly, wird /cm?cmnd=Status gefragt; Relaiszahl aus "Power" ("1", "0000" ...), Messung aus
//   Status 10 (ENERGY). Typ 7 = Relais + Messung (schalten ueber Power0 = alle Relais, weil ein Messkreis die ganze
//   Leiste misst), 8 = nur Messung, 9 = Tasmota ohne ENERGY (nicht nutzbar). Antwortet Tasmota mit "WARNING"
//   (Web-Passwort gesetzt) oder leer (HTTP-API aus), gilt der Platz als nicht erreichbar.
// v007 (20.10.2026): alle gaengigen Shelly-Arten. Gen2+ wird beim Erfragen nach Komponente unterschieden:
//   Switch (schalten+messen), PM1 (PM Mini, nur messen), EM1 (Pro EM/EM Gen3, nur messen), EM (Pro 3EM, Summe,
//   nur messen). Gen1: Relais+Meter wie bisher, EM/3EM (SHEM*) ueber /emeter/0..2 (Summe, nur messen).
//   Reine Messgeraete werden nie geschaltet; beim Erkennen wird "abschaltbar" abgehakt. Antwortet ein als Switch
//   gefuehrtes Geraet mit "No handler", wird es neu erfragt. Antwortpuffer 600 -> 1200 (EM.GetStatus ist lang).
// v006 (20.10.2026): Nennleistung per tasmDefer statt tasmCmd, angestossen hoechstens einmal je Sekunde aus
//   EverySecond() (tasmDefer hat nur EINEN Warteplatz fuer alle Slots und verwirft weitere still — mehrere STVSET
//   kurz hintereinander duerfen ihn nicht ueberholen). STVSIM direkt per tasmDefer. TaskLoop wieder schlicht delay().
// v005 (19.10.2026): STVSET und STVSIM rufen KEIN tasmCmd mehr im Command auf. Der verschachtelte Befehl
//   (EEBusCsMax bzw. EEBusCsSim) ueberschrieb die Antwort: die Seite bekam "{}" statt {"STVSET":"ok"} und meldete
//   "nicht gespeichert", obwohl Liste und .pvs stimmten. Jetzt nur vormerken; TaskLoop erledigt es binnen 0,1 s.
// v004 (09.10.2026): Zustand per sensorGet statt tasmCmd("EEBusCs") — tasmCmd liefert die ANTWORT eines Befehls leer
//   (Tasmota loescht sie in XdrvRulesProcess, bevor TinyC sie abholt; gemessen: "tasmCmd -> 0 bytes"). Senden per
//   tasmCmd (EEBusCsPower/EEBusCsMax) funktioniert weiter. Braucht Treiber SteuVE v008 (EEBusCs in den Sensordaten).
// v003 (09.10.2026): Liste im Flash + STVSET/STVCFG/STVPROBE, Fake-Simulation, Wiedereinschalten mit
//   Nennleistung + Mindest-Auszeit + Reserve, Schalter abschaltbar, Melder mit LED-Ring.
// v002: Namen, STVLIST.  v001: Grundfunktion.
// ─────────────────────────────────────────────────────────────────────

// ===== GESPEICHERT (persist) — MUSS vor allen anderen Globals stehen, sonst wird die .pvs geloescht =====
persist int cVer;            // 0 = noch nie gespeichert -> Vorgaben in main()
persist int cIp[20];         // je Platz 4 Oktette (Platz k: cIp[k*4] .. cIp[k*4+3]); 1. Oktett 0 = frei
persist int cNenn[5];        // max. Nennleistung des tatsaechlichen Verbrauchers in W (0 = 3680)
persist int cFake[5];        // 1 = simuliert
persist int cAbs[5];         // 1 = darf abgeschaltet werden
persist int cProf[5];        // Testprofil 1..4
persist int cTyp[5];         // 0 unbekannt (wird erfragt), 1 Gen2+ Switch, 2 Gen1 Relais+Meter,
                             // 3 Gen2+ PM1, 4 Gen2+ EM1, 5 Gen2+ EM (3 Phasen), 6 Gen1 EM/3EM (3..6 nur messen),
                             // v008: 7 Tasmota Relais+Messung, 8 Tasmota nur Messung, 9 Tasmota ohne Messung
persist int cSimMode;        // simulierte Abschaltung 0/1/2
persist char cName[90];      // Namen der Plaetze, mit | getrennt

// ===== EINSTELLUNGEN ====================================================================
#define ANZ 5                // Plaetze gesamt
#define NV 4                 // davon Verbraucher (Platz 5 = Melder)
#define MELDER 4             // Index des Melders
#define ABFRAGE_S 10         // Sekunden zwischen zwei Abfragen
#define EIN_ABSTAND_S 60     // Sekunden zwischen zwei Wiedereinschaltungen
#define MIN_AUS_S 300        // waehrend einer Begrenzung mindestens so lange aus (gegen Pendeln)
#define RESERVE_W 200        // Wiedereinschalten nur mit so viel Luft unter der Grenze
#define NACHLAUF_S 600       // Protokoll so lange nach dem Ende einer Begrenzung weiterfuehren
#define NENN_VORGABE 3680    // 16 A x 230 V, wenn keine Nennleistung eingetragen ist
// =======================================================================================

int p[ANZ];          // zuletzt gemessene Leistung W
int an[ANZ];         // Schaltzustand: 1 an, 0 aus, -1 unbekannt
int vonUns[ANZ];     // 1 = von diesem Skript abgeschaltet
int ausSeit[ANZ];    // Uptime der Abschaltung
int fehler[ANZ];     // Fehlversuche in Folge (begrenzt auf 99)
int versucht[ANZ];   // in dieser Runde schon vergeblich zu schalten versucht
int simT[ANZ];       // Simulation: Sekunden im Programm
int simOn[ANZ];      // Simulation: 1 = eingeschaltet
int simTot[ANZ];     // Simulation: 1 = bleibt aus (STVMODE 2)
char name[ANZ][16];  // Anzeigename (hoechstens 15 Byte — ein Umlaut zaehlt 2)
char model[ANZ][24]; // erkanntes Modell (nur im Speicher; wird nach dem Start neu erfragt)

int summe = 0;
int unbek = 0;       // 1 = mindestens ein Verbraucher antwortet nicht (3 Fehlversuche in Folge): Summe unbekannt
int begrenzt = 0;
int grenze = 0;
int letztesEin = 0;
int letztesLog = 0;
int endeBegr = 0;
int letzteRunde = 0;
int probeReq = -1;   // Platz, der in der naechsten Runde erfragt wird (-1 = keiner)
int probeAll = 1;    // nach dem Start alle echten Plaetze einmal erfragen
int melderFarbe = -1;   // zuletzt gesetzte Farbe (-1 = noch keine)
int nennNeu = 0;        // v006: Nennleistung neu melden (vorgemerkt im Command, angestossen in EverySecond)
char zustand[16] = "-";
char resp[1200];
char url[320];

// ⚠️ Bewusst KEINE char[]-Parameter (TinyC: strlen/Index auf char[]-Parametern fehlerhaft) —
// die Adresse steht nach ipStr(k) in der globalen gip, Log-Zeilen gehen direkt an addLog.
char gip[16];

int belegt(int k) {
    return cIp[k * 4] > 0;
}

// v007: reine Messgeraete (PM1, EM1, EM, Gen1-EM) — werden nie geschaltet; v008: Tasmota ohne Relais / ohne Messung
int typNurMessen(int t) {
    if (t >= 3 && t <= 6) { return 1; }
    if (t == 8 || t == 9) { return 1; }
    return 0;
}

int nurMessen(int k) {
    if (cFake[k] == 1) { return 0; }
    return typNurMessen(cTyp[k]);
}

// v008: Tasmota fragen. Liefert 1, wenn es ein Tasmota ist (setzt dann cTyp und model).
int probeTasmota(int k) {
    char pw[12];
    char m2[16];
    int n;
    int rel;
    sprintf(url, "http://%s/cm?cmnd=Status", gip);
    n = httpGet(url, resp);
    if (n <= 0) { return 0; }
    if (strFind(resp, "WARNING") >= 0) { cTyp[k] = 0; strcpy(model[k], "Tasmota: Passwort?"); return 1; }
    if (strFind(resp, "\"Status\":{") < 0) { return 0; }
    rel = 0;
    if (jsonStr(resp, "Status#Power", pw) > 0) { rel = strlen(pw); }   // Pfad mit # (verschachtelt)
    sprintf(url, "http://%s/cm?cmnd=Status%%2010", gip);
    n = httpGet(url, resp);
    if (n <= 0 || strFind(resp, "\"ENERGY\"") < 0) {
        cTyp[k] = 9;
        strcpy(model[k], "Tasmota ohne Messung");
        return 1;
    }
    if (rel > 0) {
        cTyp[k] = 7;
        sprintf(m2, "%d Relais", rel);
        sprintf(model[k], "Tasmota %s", m2);
    } else {
        cTyp[k] = 8;
        strcpy(model[k], "Tasmota Messung");
    }
    return 1;
}

int nennEff(int k) {
    if (cNenn[k] > 0) { return cNenn[k]; }
    return NENN_VORGABE;
}

void ipStr(int k) {
    sprintf(gip, "%d.%d.%d.%d", cIp[k * 4], cIp[k * 4 + 1], cIp[k * 4 + 2], cIp[k * 4 + 3]);
}

// Simulierte Leistung nach Testprofil
int simLeistung(int k) {
    if (simOn[k] == 0 || simTot[k] == 1) { return 0; }
    int t = simT[k];
    int pr = cProf[k];
    if (pr == 1) {
        t = t % 3900;
        if (t < 900) { return 2100; }
        if (t < 3300) { if ((t / 60) % 2 == 0) { return 150; } return 300; }
        return 500;
    }
    if (pr == 2) {
        t = t % 4200;
        if (t < 3600) { if (t % 360 < 300) { return 2400; } return 300; }
        return 300;
    }
    if (pr == 3) {
        t = t % 5400;
        if (t < 1200) { return 2000; }
        if (t < 3000) { return 100; }
        if (t < 3600) { return 2000; }
        return 50;
    }
    if (pr == 4) {
        t = t % 2400;
        if (t < 1800) { return 3000; }
        return 0;
    }
    return 0;
}

// Shelly nach Modell und Generation fragen (/shelly). Setzt cTyp und model.
void probe(int k) {
    char g[8];
    char m[24];
    char m2[16];
    int n;
    int alt = cTyp[k];
    ipStr(k);
    sprintf(url, "http://%s/shelly", gip);
    n = httpGet(url, resp);
    if (n <= 0 || (strFind(resp, "\"gen\"") < 0 && strFind(resp, "\"type\"") < 0)) {   // v008: kein Shelly -> Tasmota?
        if (probeTasmota(k) == 0) {
            cTyp[k] = 0;
            if (n <= 0) { strcpy(model[k], "antwortet nicht"); } else { strcpy(model[k], "kein Shelly/Tasmota?"); }
        }
    } else if (jsonStr(resp, "gen", g) > 0) {
        if (jsonStr(resp, "app", m) <= 0) { jsonStr(resp, "model", m); }
        strSub(m2, m, 0, 14);
        sprintf(model[k], "%s Gen%s", m2, g);
        // v007: Komponente bestimmen — erst Switch, dann PM1, EM1, EM
        cTyp[k] = 0;
        sprintf(url, "http://%s/rpc/Switch.GetStatus?id=0", gip);
        n = httpGet(url, resp);
        if (n > 0 && strFind(resp, "\"output\"") >= 0) { cTyp[k] = 1; }
        if (cTyp[k] == 0) {
            sprintf(url, "http://%s/rpc/PM1.GetStatus?id=0", gip);
            n = httpGet(url, resp);
            if (n > 0 && strFind(resp, "\"apower\"") >= 0) { cTyp[k] = 3; }
        }
        if (cTyp[k] == 0) {
            sprintf(url, "http://%s/rpc/EM1.GetStatus?id=0", gip);
            n = httpGet(url, resp);
            if (n > 0 && strFind(resp, "\"act_power\"") >= 0) { cTyp[k] = 4; }
        }
        if (cTyp[k] == 0) {
            sprintf(url, "http://%s/rpc/EM.GetStatus?id=0", gip);
            n = httpGet(url, resp);
            if (n > 0 && strFind(resp, "\"total_act_power\"") >= 0) { cTyp[k] = 5; }
        }
        if (cTyp[k] == 0) { strcpy(model[k], "Typ unbekannt"); }
    } else if (jsonStr(resp, "type", m) > 0) {
        cTyp[k] = 2;
        if (strFind(m, "SHEM") == 0) { cTyp[k] = 6; }   // Gen1 EM / 3EM: nur messen
        strSub(m2, m, 0, 14);
        sprintf(model[k], "%s Gen1", m2);
    } else {
        cTyp[k] = 0;
        strcpy(model[k], "kein Shelly/Tasmota?");
    }
    if (typNurMessen(cTyp[k]) && k != MELDER) { cAbs[k] = 0; }   // v007/v008: Messgeraet -> nicht abschaltbar
    if (cTyp[k] != alt) { saveVars(); nennNeu = 1; }   // Flash nur bei Aenderung beschreiben
}

// Leistung eines Platzes lesen. Liefert W oder -1.
int lies(int i) {
    float f;
    int n;
    if (cFake[i] == 1) {
        an[i] = simOn[i];
        return simLeistung(i);
    }
    ipStr(i);
    if (cTyp[i] == 1) {
        sprintf(url, "http://%s/rpc/Switch.GetStatus?id=0", gip);
        n = httpGet(url, resp);
        if (n <= 0) { return -1; }
        if (strFind(resp, "\"output\"") < 0) { cTyp[i] = 0; probeReq = i; return -1; }   // v007: kein Switch -> neu erfragen
        f = jsonNum(resp, "apower");
        if (strFind(resp, "\"output\":true") >= 0) { an[i] = 1; } else { an[i] = 0; }
        return (int)(f + 0.5);
    }
    if (cTyp[i] >= 3 && cTyp[i] <= 5) {   // v007: Gen2+ reine Messgeraete
        if (cTyp[i] == 3) { sprintf(url, "http://%s/rpc/PM1.GetStatus?id=0", gip); }
        if (cTyp[i] == 4) { sprintf(url, "http://%s/rpc/EM1.GetStatus?id=0", gip); }
        if (cTyp[i] == 5) { sprintf(url, "http://%s/rpc/EM.GetStatus?id=0", gip); }
        n = httpGet(url, resp);
        if (n <= 0) { return -1; }
        if (cTyp[i] == 3) { f = jsonNum(resp, "apower"); }
        if (cTyp[i] == 4) { f = jsonNum(resp, "act_power"); }
        if (cTyp[i] == 5) { f = jsonNum(resp, "total_act_power"); }
        an[i] = 0;
        if (f > 2) { an[i] = 1; }   // "an" = es fliesst Leistung (Messgeraet hat keinen Schalter)
        return (int)(f + 0.5);
    }
    if (cTyp[i] == 6) {   // v007: Gen1 EM / 3EM — Summe der Kanaele
        int ch;
        int ok = 0;
        float sum = 0;
        for (ch = 0; ch < 3; ch++) {
            sprintf(url, "http://%s/emeter/%d", gip, ch);
            n = httpGet(url, resp);
            if (n > 0 && strFind(resp, "\"power\"") >= 0) { sum = sum + jsonNum(resp, "power"); ok = 1; }
        }
        if (ok == 0) { return -1; }
        an[i] = 0;
        if (sum > 2) { an[i] = 1; }
        return (int)(sum + 0.5);
    }
    if (cTyp[i] == 7 || cTyp[i] == 8) {   // v008: Tasmota — Leistung aus Status 10, Schaltzustand aus Power0
        char u2[48];
        sprintf(u2, "http://%s/cm?cmnd=Power0", gip);   // vor dem ersten httpGet bauen
        sprintf(url, "http://%s/cm?cmnd=Status%%2010", gip);
        n = httpGet(url, resp);
        if (n <= 0 || strFind(resp, "WARNING") >= 0) { return -1; }
        if (strFind(resp, "\"ENERGY\"") < 0) { cTyp[i] = 0; probeReq = i; return -1; }   // Messung weg -> neu erfragen
        f = jsonNum(resp, "StatusSNS#ENERGY#Power");   // Pfad mit # (verschachtelt)
        if (cTyp[i] == 7) {
            n = httpGet(u2, resp);
            if (n > 0) {
                if (strFind(resp, "\"ON\"") >= 0) { an[i] = 1; } else { an[i] = 0; }
            }
        } else {
            an[i] = 0;
            if (f > 2) { an[i] = 1; }
        }
        return (int)(f + 0.5);
    }
    if (cTyp[i] == 9) { return -1; }   // v008: Tasmota ohne Messung — nicht nutzbar
    if (cTyp[i] == 2) {
        char u2[48];
        sprintf(u2, "http://%s/meter/0", gip);   // vor dem ersten httpGet bauen
        sprintf(url, "http://%s/relay/0", gip);
        n = httpGet(url, resp);
        if (n > 0) {
            if (strFind(resp, "\"ison\":true") >= 0) { an[i] = 1; } else { an[i] = 0; }
        }
        n = httpGet(u2, resp);
        if (n <= 0) { return -1; }
        f = jsonNum(resp, "power");
        return (int)(f + 0.5);
    }
    probeReq = i;   // Typ unbekannt -> in der naechsten Runde erfragen
    return -1;
}

// Platz ein-/ausschalten. Liefert 1 bei Erfolg.
int schalte(int i, int ein) {
    int n = -1;
    if (cFake[i] == 1) {
        simOn[i] = ein;
        if (ein == 0 && cSimMode == 1) { simT[i] = 0; }
        if (ein == 0 && cSimMode == 2) { simTot[i] = 1; }
        an[i] = ein;
        return 1;
    }
    if (nurMessen(i)) { return 0; }   // v007: Messgeraet hat keinen Schalter
    ipStr(i);
    if (cTyp[i] == 1) {
        if (ein == 1) { sprintf(url, "http://%s/rpc/Switch.Set?id=0&on=true", gip); }
        else          { sprintf(url, "http://%s/rpc/Switch.Set?id=0&on=false", gip); }
        n = httpGet(url, resp);
    }
    if (cTyp[i] == 2) {
        if (ein == 1) { sprintf(url, "http://%s/relay/0?turn=on", gip); }
        else          { sprintf(url, "http://%s/relay/0?turn=off", gip); }
        n = httpGet(url, resp);
    }
    if (cTyp[i] == 7) {   // v008: Tasmota — alle Relais (der Messkreis misst die ganze Leiste)
        if (ein == 1) { sprintf(url, "http://%s/cm?cmnd=Power0%%20On", gip); }
        else          { sprintf(url, "http://%s/cm?cmnd=Power0%%20Off", gip); }
        n = httpGet(url, resp);
        if (n > 0 && strFind(resp, "POWER") < 0) { n = -1; }   // z. B. WARNING (Passwort) -> nicht geschaltet
    }
    if (n > 0) { an[i] = ein; return 1; }
    return 0;
}

// Melder: LED-Ring setzen (erprobt):
//   Plus Plug S (PLUGS_UI):  Farbe fuer "on" UND "off" von switch:0 setzen
//   Plug PM Gen3 (plugpm_ui): erst leds.mode = switch, dann Farbe fuer pm1:0 "on"
// RGB in Prozent 0..100. Farbe: 0 gruen frei, 1 gelb begrenzt, 2 rot Failsafe, 3 blau ohne Energy Guard.
void ringFarbe(int pm, int aus, int r, int g, int b) {
    char lg[96];
    if (pm == 1) {
        sprintf(url, "http://%s/rpc/plugpm_ui.SetConfig", gip);
        strcpy(lg, "?config=%7B%22leds%22%3A%7B%22colors%22%3A%7B%22pm1%3A0%22%3A%7B%22");
    } else {
        sprintf(url, "http://%s/rpc/PLUGS_UI.SetConfig", gip);
        strcpy(lg, "?config=%7B%22leds%22%3A%7B%22colors%22%3A%7B%22switch%3A0%22%3A%7B%22");
    }
    strcat(url, lg);
    if (aus == 1) { strcat(url, "off"); } else { strcat(url, "on"); }
    sprintf(lg, "%%22%%3A%%7B%%22rgb%%22%%3A%%5B%d%%2C%d%%2C%d", r, g, b);
    strcat(url, lg);
    strcpy(lg, "%5D%2C%22brightness%22%3A80%7D%7D%7D%7D%7D");
    strcat(url, lg);
}

void melder() {
    if (!belegt(MELDER)) { return; }
    int farbe = 0;
    if (strFind(zustand, "Failsafe") == 0) { farbe = 2; }
    else if (begrenzt == 1) { farbe = 1; }
    else if (strFind(zustand, "gesteuert") != 0) { farbe = 3; }
    if (farbe == melderFarbe) { return; }
    if (cFake[MELDER] == 1) { melderFarbe = farbe; return; }
    if (cTyp[MELDER] == 0 && strlen(model[MELDER]) == 0) { probeReq = MELDER; return; }   // Typ noch unbekannt
    if (cTyp[MELDER] != 1) { return; }   // LED-Ring nur bei Gen2 und neuer
    int pm = 0;
    int r = 0;
    int g = 100;
    int b = 0;
    if (strFind(model[MELDER], "PM") >= 0) { pm = 1; }      // Plug PM (Gen3)
    if (farbe == 1) { r = 100; g = 70; b = 0; }
    if (farbe == 2) { r = 100; g = 0; b = 0; }
    if (farbe == 3) { r = 0; g = 30; b = 100; }
    ipStr(MELDER);
    int ok = 0;
    if (pm == 1) {
        sprintf(url, "http://%s/rpc/plugpm_ui.SetConfig?config=%%7B%%22leds%%22%%3A%%7B%%22mode%%22%%3A%%22switch%%22%%7D%%7D", gip);
        httpGet(url, resp);
        ringFarbe(1, 0, r, g, b);
        if (httpGet(url, resp) > 0) { ok = 1; }
    } else {
        ringFarbe(0, 0, r, g, b);
        if (httpGet(url, resp) > 0) { ok = 1; }
        ringFarbe(0, 1, r, g, b);
        httpGet(url, resp);
    }
    if (ok == 1) {
        melderFarbe = farbe;
        fehler[MELDER] = 0;
    } else if (fehler[MELDER] < 99) {
        fehler[MELDER] = fehler[MELDER] + 1;
    }
}

void protokoll() {
    char z[120];
    char ts[24];
    char maske[NV + 1];
    int i;
    for (i = 0; i < NV; i++) {
        if (vonUns[i] == 1) { maske[i] = 'X'; } else { maske[i] = '.'; }
    }
    maske[NV] = 0;
    timeStamp(ts);
    sprintf(z, "%s;%s;%d;%d;%d;%s\n", ts, zustand, begrenzt, grenze, summe, maske);
    // nur ANHAENGEN (Modus 2), nie neu anlegen — ein Neuanlegen schneidet die Datei ab
    int h = fileOpen("/steuve_log.csv", 2);
    if (h >= 0) {
        fileWrite(h, z, strlen(z));
        fileClose(h);
    }
}

void nennMelden() {
    int i;
    int nsum = 0;
    char c[40];
    for (i = 0; i < NV; i++) {
        if (belegt(i)) { nsum = nsum + nennEff(i); }
    }
    sprintf(c, "EEBusCsMax %d", nsum);   // Nennleistung = Summe der belegten Verbraucher
    tasmDefer(c);   // v006: verzoegert ausfuehren — darf auch aus Callbacks gerufen werden
}

void runde() {
    int i;
    int s = 0;
    char c[64];
    int dt = tasm_uptime - letzteRunde;
    if (letzteRunde == 0 || dt < 0 || dt > 120) { dt = ABFRAGE_S; }
    letzteRunde = tasm_uptime;

    // Pruefauftraege (Modell/Generation)
    if (probeAll == 1) {
        probeAll = 0;
        for (i = 0; i < ANZ; i++) {
            if (belegt(i) && cFake[i] == 0) { probe(i); }
        }
    }
    if (probeReq >= 0) {
        int k = probeReq;
        probeReq = -1;
        if (belegt(k) && cFake[k] == 0) { probe(k); }
    }

    // Simulation weiterlaufen lassen (nur eingeschaltete Fake-Plaetze)
    for (i = 0; i < ANZ; i++) {
        if (cFake[i] == 1 && simOn[i] == 1 && simTot[i] == 0) { simT[i] = simT[i] + dt; }
    }

    // 1. lesen
    unbek = 0;
    for (i = 0; i < NV; i++) {
        if (!belegt(i)) { p[i] = 0; an[i] = -1; fehler[i] = 0; continue; }
        int w = lies(i);
        if (w < 0) {
            if (fehler[i] < 99) { fehler[i] = fehler[i] + 1; }
            if (fehler[i] == 3) { sprintf(c, "Prio %d antwortet nicht", i + 1); addLog("STV %s", c); }
            if (fehler[i] >= 3) { unbek = 1; }
            w = 0;
        } else {
            fehler[i] = 0;
        }
        p[i] = w;
        s = s + w;
    }
    summe = s;
    // 2. Summe an den Treiber
    if (unbek == 1) { strcpy(c, "EEBusCsPower unbekannt"); }   // Treiber ab SteuVE v026: valueState error
    else { sprintf(c, "EEBusCsPower %d", summe); }
    tasmCmd(c, resp);
    // 3. Zustand vom Treiber (Sensordaten, SteuVE v008). Zustand: 0 Anlauf, 1 gesteuert, 2 Failsafe, 3 autonom
    int warBegrenzt = begrenzt;
    float fb = sensorGet("EEBusCs#Begrenzt");
    float fg = sensorGet("EEBusCs#Grenze");
    float fz = sensorGet("EEBusCs#Zustand");
    begrenzt = 0;
    if ((int)fb == 1) { begrenzt = 1; }
    grenze = (int)fg;
    int zn = (int)fz;
    if (zn == 1) { strcpy(zustand, "gesteuert"); }
    else if (zn == 2) { strcpy(zustand, "Failsafe"); }
    else if (zn == 3) { strcpy(zustand, "autonom"); }
    else { strcpy(zustand, "Anlauf"); }
    if (warBegrenzt == 1 && begrenzt == 0) { endeBegr = tasm_uptime; addLog("STV Begrenzung beendet"); }
    if (warBegrenzt == 0 && begrenzt == 1) { sprintf(c, "Begrenzung auf %d W", grenze); addLog("STV %s", c); }

    // 4. begrenzt: abschalten, hoechste Prio-Zahl zuerst, bis Summe <= Grenze
    if (begrenzt == 1) {
        int sicher = 0;
        for (i = 0; i < NV; i++) { versucht[i] = 0; }
        while (summe > grenze && sicher < NV) {
            sicher = sicher + 1;
            int best = -1;
            for (i = NV - 1; i >= 0; i--) {
                if (!belegt(i) || cAbs[i] != 1 || nurMessen(i) || an[i] != 1 || p[i] <= 0 || versucht[i] == 1) { continue; }
                best = i;
                break;
            }
            if (best < 0) {
                sprintf(c, "Grenze %d W nicht erreichbar (Summe %d W, nichts mehr abschaltbar)", grenze, summe);
                addLog("STV %s", c);
                break;
            }
            if (schalte(best, 0) == 1) {
                vonUns[best] = 1;
                ausSeit[best] = tasm_uptime;
                summe = summe - p[best];
                sprintf(c, "aus: Prio %d %d W", best + 1, p[best]);
                addLog("STV %s", c);
            } else {
                versucht[best] = 1;   // laesst sich nicht schalten -> naechsten nehmen statt aufzugeben
                sprintf(c, "Prio %d laesst sich nicht abschalten", best + 1);
                addLog("STV %s", c);
            }
        }
    }

    // 5. wieder einschalten — gestaffelt, Prio 1 zuerst, nur was wir abgeschaltet haben
    if (tasm_uptime - letztesEin >= EIN_ABSTAND_S) {
        for (i = 0; i < NV; i++) {
            if (vonUns[i] != 1) { continue; }
            if (begrenzt == 1) {
                if (tasm_uptime - ausSeit[i] < MIN_AUS_S) { continue; }            // gegen Pendeln
                if (summe + nennEff(i) > grenze - RESERVE_W) { continue; }        // mit Volllast rechnen
            }
            if (schalte(i, 1) == 1) {
                vonUns[i] = 0;
                letztesEin = tasm_uptime;
                sprintf(c, "ein: Prio %d", i + 1);
                addLog("STV %s", c);
            }
            break;   // hoechstens einer je Abstand
        }
    }

    // 6. Protokoll: minuetlich waehrend der Begrenzung und NACHLAUF_S danach
    int nachlauf = endeBegr > 0 && (tasm_uptime - endeBegr) < NACHLAUF_S;
    if ((begrenzt == 1 || nachlauf) && (tasm_uptime - letztesLog >= 60)) {
        letztesLog = tasm_uptime;
        protokoll();
    }

    // 7. Melder
    melder();
}

// v006: hoechstens eine Nennleistungs-Meldung je Sekunde (tasmDefer hat nur einen Warteplatz)
void EverySecond() {
    if (nennNeu == 1) { nennNeu = 0; nennMelden(); }
}

void TaskLoop() {
    runde();
    delay(ABFRAGE_S * 1000);
}

void WebCall() {
    char b[160];
    char sm[16];
    if (unbek == 1) { strcpy(sm, "unbekannt"); } else { sprintf(sm, "%d W", summe); }
    if (begrenzt == 1) { sprintf(b, "{s}SteuVE{m}%s · Grenze %d W / Summe %s{e}", zustand, grenze, sm); }
    else { sprintf(b, "{s}SteuVE{m}%s · frei / Summe %s{e}", zustand, sm); }
    webSend(b);
    int i;
    for (i = 0; i < NV; i++) {
        if (!belegt(i)) { continue; }
        sprintf(b, "{s}Prio %d %s%s{m}%d W%s%s{e}", i + 1, name[i], cFake[i] == 1 ? " (Fake)" : "", p[i],
                an[i] == 0 ? " · aus" : "", vonUns[i] == 1 ? " (von SteuVE)" : "");
        webSend(b);
    }
}

// Namen aus den Plaetzen in cName zusammensetzen (leer -> "-", damit strToken die Stelle findet)
void namenSpeichern() {
    int k;
    strcpy(cName, "");
    for (k = 0; k < ANZ; k++) {
        if (strlen(name[k]) > 0) { strcat(cName, name[k]); } else { strcat(cName, "-"); }
        strcat(cName, "|");
    }
}

void namenLaden() {
    int k;
    char t[24];
    for (k = 0; k < ANZ; k++) {
        strToken(t, cName, '|', k + 1);
        if (strcmp(t, "-") == 0) { strcpy(t, ""); }
        strSub(name[k], t, 0, 15);
    }
}

void Command(char cmd[]) {
    char c[64];
    char a[128];
    char t[24];
    char z[100];
    int i;
    if (strFind(cmd, "STAT") == 0) {
        sprintf(resp, "{\"STV\":{\"Zustand\":\"%s\",\"Begrenzt\":%d,\"Grenze\":%d,\"Summe\":%d,\"Bekannt\":%d}}", zustand, begrenzt, grenze, summe, 1 - unbek);
        responseCmnd(resp);
    } else if (strFind(cmd, "LIST") == 0) {
        strcpy(resp, "{\"STVLIST\":[");
        for (i = 0; i < ANZ; i++) {
            if (i > 0) { strcat(resp, ","); }
            sprintf(z, "[%d,%d,%d,%d,%d]", i, p[i], an[i], vonUns[i], fehler[i]);
            strcat(resp, z);
        }
        sprintf(z, "],\"Melder\":%d,\"Mode\":%d}", melderFarbe, cSimMode);
        strcat(resp, z);
        responseCmnd(resp);
    } else if (strFind(cmd, "CFG") == 0) {
        sprintf(resp, "{\"STVCFG\":{\"Mode\":%d,\"P\":[", cSimMode);
        for (i = 0; i < ANZ; i++) {
            // Adresse direkt aus den Oktetten — NICHT ipStr/gip: Command laeuft auch waehrend eines httpGet der Runde
            sprintf(z, "[%d,\"%s\",\"%d.%d.%d.%d\",%d,%d,%d,%d,%d,\"%s\"]", i, name[i], cIp[i * 4], cIp[i * 4 + 1], cIp[i * 4 + 2], cIp[i * 4 + 3],
                    cNenn[i], cFake[i], cAbs[i], cProf[i], cTyp[i], model[i]);
            if (strlen(resp) + strlen(z) > 500) { break; }   // Antwort hoechstens 512 Zeichen
            if (i > 0) { strcat(resp, ","); }
            strcat(resp, z);
        }
        strcat(resp, "]}}");
        responseCmnd(resp);
    } else if (strFind(cmd, "SET") == 0) {
        // STVSET p,fake,abs,ip,nenn,profil,name
        strSub(a, cmd, 4, 0);
        strToken(t, a, ',', 1);
        int k = strToInt(t) - 1;
        if (k < 0 || k >= ANZ) { responseCmnd("Platz 1..5 angeben"); return; }
        if (vonUns[k] == 1) { responseCmnd("Platz ist gerade von SteuVE abgeschaltet - erst nach der Rueckkehr aendern"); return; }
        int alt0 = cIp[k * 4];
        int alt1 = cIp[k * 4 + 1];
        int alt2 = cIp[k * 4 + 2];
        int alt3 = cIp[k * 4 + 3];
        int altFake = cFake[k];
        int altProf = cProf[k];
        strToken(t, a, ',', 2);
        cFake[k] = 0;
        if (strToInt(t) > 0) { cFake[k] = 1; }
        strToken(t, a, ',', 3);
        cAbs[k] = 0;
        if (strToInt(t) > 0) { cAbs[k] = 1; }
        strToken(t, a, ',', 4);
        char o[6];
        int j;
        for (j = 0; j < 4; j++) {
            strToken(o, t, '.', j + 1);
            cIp[k * 4 + j] = strToInt(o);
        }
        strToken(t, a, ',', 5);
        cNenn[k] = strToInt(t);
        strToken(t, a, ',', 6);
        cProf[k] = strToInt(t);
        strToken(t, a, ',', 7);
        strSub(name[k], t, 0, 15);
        namenSpeichern();
        cVer = 1;
        int ipNeu = 0;
        if (cIp[k * 4] != alt0 || cIp[k * 4 + 1] != alt1 || cIp[k * 4 + 2] != alt2 || cIp[k * 4 + 3] != alt3) { ipNeu = 1; }
        if (ipNeu == 1 || cFake[k] != altFake) {   // anderes Geraet -> Typ neu erfragen, Messwerte verwerfen
            cTyp[k] = 0;
            strcpy(model[k], "");
            p[k] = 0; an[k] = -1; fehler[k] = 0;
            if (k == MELDER) { melderFarbe = -1; }
            if (belegt(k) && cFake[k] == 0) { probeAll = 1; }
        }
        if (cFake[k] != altFake || cProf[k] != altProf) { simT[k] = 0; simOn[k] = 1; simTot[k] = 0; }
        saveVars();
        nennNeu = 1;   // v006: EverySecond meldet die aktuelle Summe (kein tasmCmd im Command, s. v005)
        sprintf(c, "Platz %d gespeichert", k + 1);
        addLog("STV %s", c);
        responseCmnd("{\"STVSET\":\"ok\"}");
    } else if (strFind(cmd, "PROBE") == 0) {
        strSub(a, cmd, 6, 0);
        int k = strToInt(a) - 1;
        if (k < 0 || k >= ANZ) { responseCmnd("Platz 1..5 angeben"); return; }
        probeReq = k;
        responseCmnd("{\"STVPROBE\":\"naechste Runde\"}");
    } else if (strFind(cmd, "MODE") == 0) {
        strSub(a, cmd, 5, 0);
        int m = strToInt(a);
        if (m >= 0 && m <= 2) { cSimMode = m; saveVars(); }
        for (i = 0; i < ANZ; i++) { simTot[i] = 0; }
        sprintf(c, "{\"STVMODE\":%d}", cSimMode);
        responseCmnd(c);
    } else if (strFind(cmd, "SIM") == 0) {
        strSub(a, cmd, 4, 0);
        sprintf(c, "EEBusCsSim %s", a);
        tasmDefer(c);   // v006: verzoegert, nicht im Command ausfuehren — Ergebnis steht in EEBusCs bzw. auf der Seite
        responseCmnd("{\"STVSIM\":\"gesendet\"}");
    } else {
        responseCmnd("STVSTAT | STVLIST | STVCFG | STVSET p,fake,abs,ip,nenn,profil,name | STVPROBE p | STVMODE 0|1|2 | STVSIM <W> [s]");
    }
}

int main() {
    int i;
    if (cVer == 0) {
        // Vorgaben: alle Plaetze frei (IP 0), alle abschaltbar, Profile passend zu den Beispielnamen
        for (i = 0; i < 20; i++) { cIp[i] = 0; }
        for (i = 0; i < ANZ; i++) { cNenn[i] = 0; cFake[i] = 0; cAbs[i] = 1; cTyp[i] = 0; }
        cProf[0] = 3; cProf[1] = 1; cProf[2] = 2; cProf[3] = 4; cProf[4] = 0;
        cAbs[MELDER] = 0;
        cSimMode = 0;
        strcpy(cName, "Geschirrspüler|Waschmaschine|Trockner|Heizstab|Melder|");
    }
    namenLaden();
    for (i = 0; i < ANZ; i++) {
        p[i] = 0; an[i] = -1; vonUns[i] = 0; ausSeit[i] = 0; fehler[i] = 0;
        simT[i] = 0; simOn[i] = 1; simTot[i] = 0;
        strcpy(model[i], "");
    }
    nennMelden();
    addCommand("STV");
    addLog("STV: SteuVE-Verbraucher v010 gestartet");
    return 0;
}