Jahresrückblick 2025 – unser neuer Blogbeitrag ist online! ✨

[Kapitaen31]

@Homoran sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

@kapitaen31
dann mach doch bitte für @oliverio auch noch einen Export der Javascript Ansicht (ohne die letzte kilometerlange kryptische Zeile)

Hier kommt der die JavaScript Ansicht:

var MAX_Wert, MAX_erreichbar, MAX_aufdimmen_aktiv, MAX_aufdimmen, MAX_Text, MAX_Zyklus_beendet, MAX_Farbwert, MAX_ein_aus, MaxZeitplan, MAX_aus, MAX_ein, MAX_Helligkeit, Max_abends_aus, Wartezeit;

// Hue Lampe mit angegebenem Wert langsam einschalten.
async function Max_dimmen(MAX_Wert, MAX_erreichbar, MAX_aufdimmen_aktiv, MAX_aufdimmen, MAX_Text, MAX_Zyklus_beendet, MAX_Farbwert, MAX_ein_aus) {
  if (MAX_ein_aus == 'ein') {
    // Max wird  aufgeblendet (einschalten)
    if (getState('alias.0.OG.Flur.Licht.HelligkeitHueMax').val == 0) {
      setState('alias.0.OG.Flur.Licht.HelligkeitHueMax' /* Helligkeit Hue Max */, 5);
      console.warn('Max eingeschaltet! ');
    }
    setState('alias.0.OG.Flur.Licht.FarbTemperaturHueMax' /* Farb Temp Hue Max */, MAX_Farbwert);
    setState('javascript.0.Datenpunkte.Flur.Licht.Abdimmen_aktiv' /* Aufdimmen aktiv */, true, true);
    MAX_ein = setInterval(async () => {
      if (getState('alias.0.OG.Flur.Licht.HelligkeitHueMax').val < MAX_Wert && getState('alias.0.OG.Flur.Licht.Erreichbar Hue Max').val == MAX_erreichbar) {
        setState('alias.0.OG.Flur.Licht.HelligkeitHueMax' /* Helligkeit Hue Max */, (getState('alias.0.OG.Flur.Licht.HelligkeitHueMax').val + 5));
        console.log((String(MAX_Text) + String(getState('alias.0.OG.Flur.Licht.HelligkeitHueMax').val)));
      } else {
        (() => { if (MAX_ein) { clearInterval(MAX_ein); MAX_ein = null; }})();
        setState('javascript.0.Datenpunkte.Flur.Licht.Abdimmen_aktiv' /* Aufdimmen aktiv */, MAX_aufdimmen_aktiv, true);
        Wartezeit = setTimeout(async () => {
          Wartezeit = null;
          console.log((String(MAX_Zyklus_beendet) + String(getState('alias.0.OG.Flur.Licht.HelligkeitHueMax').val)));
        }, 3000);
      }
    }, 30000);
  } else if (MAX_ein_aus == 'aus') {
    // Max wird  abgeblendet (ausgeschalten)
    if (getState('javascript.0.Datenpunkte.Flur.Licht.Abdimmen_aktiv').val) {
      (() => { if (MAX_ein) { clearInterval(MAX_ein); MAX_ein = null; }})();
      (() => { if (MAX_aus) { clearInterval(MAX_aus); MAX_aus = null; }})();
      setState('javascript.0.Datenpunkte.Flur.Licht.Abdimmen_aktiv' /* Aufdimmen aktiv */, MAX_aufdimmen_aktiv, true);
    }
    MAX_aus = setInterval(async () => {
      if (MAX_Wert == 0) {
        if (getState('alias.0.OG.Flur.Licht.HelligkeitHueMax').val > 6 && getState('alias.0.OG.Flur.Licht.Erreichbar Hue Max').val == 1) {
          MAX_Helligkeit = true;
        } else {
          MAX_Helligkeit = false;
        }
      } else {
        if (getState('alias.0.OG.Flur.Licht.HelligkeitHueMax').val > MAX_Wert && getState('alias.0.OG.Flur.Licht.Erreichbar Hue Max').val == 1) {
          MAX_Helligkeit = true;
        } else {
          MAX_Helligkeit = false;
        }
      }
      if (MAX_Helligkeit) {
        setState('alias.0.OG.Flur.Licht.HelligkeitHueMax' /* Helligkeit Hue Max */, (getState('alias.0.OG.Flur.Licht.HelligkeitHueMax').val - 5));
        console.log((String(MAX_Text) + String(getState('alias.0.OG.Flur.Licht.HelligkeitHueMax').val)));
      } else {
        (() => { if (MAX_aus) { clearInterval(MAX_aus); MAX_aus = null; }})();
        setState('alias.0.OG.Flur.Licht.EingeschaltetHueMax' /* Ein Hue Max */, false);
        console.error(MAX_Zyklus_beendet);
      }
    }, 30000);
  }
}


// Hue Max automatisch morgens langsam einschalten
on({ id: [].concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_Wochentag']).concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_Monat']).concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_Datum']).concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_Std']).concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_Min']), change: 'ne' }, async (obj) => {
  (() => { if (MaxZeitplan) { clearSchedule(MaxZeitplan); MaxZeitplan = null; }})();
  MaxZeitplan = schedule(getState('javascript.0.Datenpunkte.Flur.Licht.CRON_Min').val.toString().trim() + ' ' + getState('javascript.0.Datenpunkte.Flur.Licht.CRON_Std').val.toString().trim() + ' ' + getState('javascript.0.Datenpunkte.Flur.Licht.CRON_Datum').val.toString().trim() + ' ' + getState('javascript.0.Datenpunkte.Flur.Licht.CRON_Monat').val.toString().trim() + ' ' + getState('javascript.0.Datenpunkte.Flur.Licht.CRON_Wochentag').val.toString().trim(), async () => {
    console.warn('Neuer Zeitplan wurde für morgens einschalten angelegt.   ');
    if (compareTime(getAstroDate('dawn', undefined, 18), null, '<', null)) {
      console.warn(([(new Date().getTime()),'  ;   ',getAstroDate('dawn', undefined, 18)].join('')));
      (() => { if (MAX_aus) { clearInterval(MAX_aus); MAX_aus = null; }})();
      (() => { if (MAX_ein) { clearInterval(MAX_ein); MAX_ein = null; }})();
      await Max_dimmen(30, true, false, true, 'Max morgens einschalten +5. Wert:', 'Max Einschalt Zyklus morgens beendet. Wert: ', 2730, 'ein');
    }
  });
});
// Hue Max automatisch abends langsam einschalten
schedule({ astro: 'sunset', shift: 0 }, async () => {
  console.warn('Sonnenuntergang.  ');
  if (compareTime('21:36', 'null', '<')) {
    (() => { if (MAX_ein) { clearInterval(MAX_ein); MAX_ein = null; }})();
    (() => { if (MAX_aus) { clearInterval(MAX_aus); MAX_aus = null; }})();
    await Max_dimmen(100, 1, false, true, 'Max abends einschalten +5. Wert:', 'Max Einschalt Zyklus abends beendet. Wert: ', 2730, 'ein');
  }
});
// Hue Max automatisch abends langsam ausschalten
on({ id: [].concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_datum_abends']).concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_min_abends']).concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_monat_abends']).concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_std_abends']).concat(['javascript.0.Datenpunkte.Flur.Licht.CRON_wochentag_abends']), change: 'ne' }, async (obj) => {
  console.warn('Zeitplan MAX abends ausschalten wurde neu angelegt: ');
  (() => { if (Max_abends_aus) { clearSchedule(Max_abends_aus); Max_abends_aus = null; }})();
  Max_abends_aus = schedule(getState('javascript.0.Datenpunkte.Flur.Licht.CRON_min_abends').val.toString().trim() + ' ' + getState('javascript.0.Datenpunkte.Flur.Licht.CRON_std_abends').val.toString().trim() + ' ' + getState('javascript.0.Datenpunkte.Flur.Licht.CRON_datum_abends').val.toString().trim() + ' ' + getState('javascript.0.Datenpunkte.Flur.Licht.CRON_monat_abends').val.toString().trim() + ' ' + getState('javascript.0.Datenpunkte.Flur.Licht.CRON_wochentag_abends').val.toString().trim(), async () => {
    console.warn('Zeitplan MAX abends ausschalten gestartet: ');
    (() => { if (MAX_aus) { clearInterval(MAX_aus); MAX_aus = null; }})();
    (() => { if (MAX_ein) { clearInterval(MAX_ein); MAX_ein = null; }})();
    await Max_dimmen(0, 1, false, false, 'Max abends ausschalten -5. Wert:  ', 'Zyklus MAX ausschalten abends beendet!  Wert:  ', 2730, 'aus');
  });
});
// Hue Max automatisch morgens langsam ausschalten
schedule({ astro: 'dawn', shift: 20 }, async () => {
  console.warn('Sonnenaufgang 20min später.');
  (() => { if (MAX_aus) { clearInterval(MAX_aus); MAX_aus = null; }})();
  (() => { if (MAX_ein) { clearInterval(MAX_ein); MAX_ein = null; }})();
  await Max_dimmen(0, 1, false, false, 'Max morgens ausschalten -5. Wert:  ', 'Zyklus MAX ausschalten morgens beendet!  Wert:  ', 2730, 'aus');
});

[Kapitaen31]

@Meister-Mopper sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

Ich hatte das Problem, dass bei gleicher Konstellation plötzlich der Lüfter permanent max lief.
Bei mir hat es geholfen, argononed zu deinstallieren und neu zu konfigurieren.
Offenbar wurde es bei der Umstellung von bookworm auf trixie nicht sauber mitgenommen.

Jetzt läuft es wieder geschmeidig.

Ich hatte vorhin nochmals die Konfig neu gestartet. Jetzt erhalte ich auch eine Ausgabe:

PI@PIArgon:~ $ sudo systemctl status argononed
● argononed.service - Argon One Fan and Button Service
     Loaded: loaded (/lib/systemd/system/argononed.service; enabled; preset: enabled)
     Active: active (running) since Fri 2026-01-30 20:18:59 CET; 8min ago
   Main PID: 864 (python3)
      Tasks: 3 (limit: 3913)
        CPU: 106ms
     CGroup: /system.slice/argononed.service
             └─864 /usr/bin/python3 /etc/argon/argononed.py SERVICE

Jan 30 20:18:59 PIArgon systemd[1]: Started argononed.service - Argon One Fan and Button Service.

Ich hatte den PI auch nochmal neu gestartet.

[OliverIO]

@Kapitaen31 sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

läuft bei dir auf dem raspi auch ein browser mit?
ansonsten ist das beschriebene problem wahrscheinlich nicht relevant, sollte aber auch behoben werden.
also 1) mit "vermüllen" ist gemeint, das da ein memory leak ist. d.h. da wird immer wieder speicher reserviert, der erst du neustart oder im browser mit neuladen behoben werden kann. solange genügend speicher da ist, kein problem, evtl hast du da auch noch nie was gemerkt, sollte aber behoben werden. weiß0 nicht wie safe da blockly ist.

ich habe das skript mal bei gemini reingeworfen (chatgpt geht gerade nicht)

---

Das sieht nach einem klassischen Blockly-Export für den ioBroker JavaScript-Adapter aus. Das Skript ist funktional, hat aber ein paar „Stolperfallen“, die im Alltag zu Problemen führen können (besonders beim Dimmen und den Zeitplänen).

Hier sind die kritischen Punkte, die ich gefunden habe:

1. Die "Erreichbarkeit"-Prüfung (MAX_erreichbar)

In der Funktion Max_dimmen fragst du den Status Erreichbar Hue Max ab.

• Das Problem: Wenn die Lampe über den Wandschalter stromlos gemacht wurde, ist sie "nicht erreichbar". Das Intervall läuft dann aber ewig weiter, weil die Bedingung getState(...).val == MAX_erreichbar nie erfüllt wird, aber auch kein else greift, das das Intervall stoppt.
• Folge: Das Skript "vermüllt" den Speicher mit laufenden Intervallen im Hintergrund.

2. Fehlende Initialisierung beim Neustart

Die Variable MaxZeitplan und Max_abends_aus werden erst gesetzt, wenn sich einer der CRON-Datenpunkte ändert (change: 'ne').

• Das Problem: Wenn du das Skript oder den ioBroker neu startest, sind diese Zeitpläne nicht aktiv, bis du die Werte in den Datenpunkten einmal manuell änderst.
• Lösung: Du solltest die schedule-Logik am Ende des Skripts einmal ohne Trigger aufrufen, damit sie beim Start sofort registriert wird.

3. Logik-Fehler beim "Abdimmen_aktiv"

Im else if (MAX_ein_aus == 'aus')-Teil setzt du:
setState('javascript.0.Datenpunkte.Flur.Licht.Abdimmen_aktiv', MAX_aufdimmen_aktiv, true);

• Das Problem: Du übergibst hier die Variable MAX_aufdimmen_aktiv. In deinem morgendlichen Ausschalt-Trigger ist dieser Wert aber auf false gesetzt. Das ist zwar technisch nicht falsch, aber die Variable heißt im Datenpunkt "Abdimmen_aktiv", was verwirrend sein kann, wenn sie beim Ausschalten auf false geht, obwohl der Prozess noch läuft.

4. Die compareTime bei Sonnenuntergang

if (compareTime('21:36', 'null', '<'))

• Das Problem: Das bedeutet: "Führe das Dimmen nur aus, wenn es vor 21:36 Uhr ist". Da der Sonnenuntergang im Sommer aber auch mal nach 21:36 Uhr sein kann, würde die Lampe an manchen Tagen im Jahr einfach gar nicht angehen. Prüfe, ob das so gewollt ist.

5. Intervall-Dauer vs. Schrittweite

Du dimmst alle 30 Sekunden um 5 Einheiten.

• Um von 0 auf 100 zu kommen, braucht das Skript 20 Schritte.
• (10 Minuten).
• Gefahr: Wenn während dieser 10 Minuten jemand manuell das Licht schaltet oder ein anderer Trigger feuert, kommen sich die Intervalle in die Quere, falls MAX_ein / MAX_aus nicht sauber gelöscht werden.

---

Zusammenfassung & Empfehlung

Fehlerquelle	Auswirkung	Lösung
Erreichbarkeit	Endlosschleife im Hintergrund	Ein else { clearInterval... } hinzufügen, falls Lampe offline.
Startverhalten	Zeitpläne nach Neustart inaktiv	Trigger-Logik einmal beim Skriptstart ausführen.
Variablen-Mix	MAX_erreichbar wird mal als true (Boolean) und mal als 1 (Zahl) übergeben.	JavaScript ist da tolerant, aber sauberer wäre es, immer den gleichen Typ zu nutzen.

Ein kleiner Tipp für ioBroker:
Anstatt Intervalle mit setInterval zu bauen, nutzen viele für Hue-Lampen das native transition (Übergangszeit) Kommando. Man kann beim setState einer Hue-Lampe oft ein JSON mitgeben: setState('id', {val: 100, ack: false, transition: 600}). Das würde die Lampe von alleine über 10 Minuten dimmen, ohne dass das Skript alle 30 Sekunden funken muss.

Soll ich dir zeigen, wie du den Teil für den automatischen Start nach einem Neustart ergänzt?

[OliverIO]

@Kapitaen31

zum vergleichmal noch chatgpt 5.2
sag mal welche ausgabe du besser findest bzw was dir mehr geholfen hat.

---

Ja – da sind ein paar echte „Blockly-Export“-Klassiker drin, die dir in ioBroker früher oder später Probleme machen (oder dafür sorgen, dass es nicht so läuft wie gedacht). Ich gehe die auffälligsten Punkte durch und sage jeweils warum das problematisch ist und wie du’s robust bekommst.

---

1) Parameter-Chaos vs. globale Variablen (und dadurch Logikfehler)

Max_dimmen() hat diese Signatur:

async function Max_dimmen(MAX_Wert, MAX_erreichbar, MAX_aufdimmen_aktiv, MAX_aufdimmen, MAX_Text, MAX_Zyklus_beendet, MAX_Farbwert, MAX_ein_aus)

Du rufst sie z.B. morgens so auf:

await Max_dimmen(30, true, false, true, ..., 2730, 'ein');

Aber im Code vergleichst du später:

getState('alias.0.OG.Flur.Licht.Erreichbar Hue Max').val == MAX_erreichbar

Und im Aufruf gibst du einmal true, einmal 1 (abends: Max_dimmen(100, 1, ...)).

➡️ Wenn der State ...Erreichbar Hue Max bei dir ein Zahl-Boolean ist (0/1), dann ist der Vergleich mit true zwar mit == oft „zufällig“ wahr (weil true == 1), aber das ist fragil. Wenn der State mal "true" oder true liefert, oder du auf === umstellst, knallt’s.

Robust fix: Normalisieren statt „magischen“ Typen:

const reachable = !!getState('alias.0.OG.Flur.Licht.Erreichbar Hue Max').val;
if (reachable === !!MAX_erreichbar) { ... }

Oder konsequent immer 1/0 verwenden.

---

2) MAX_aufdimmen wird nie verwendet

Du übergibst MAX_aufdimmen, aber im Code taucht die Variable nirgendwo sinnvoll auf (sie wird nicht gelesen). Das ist kein Crash, aber ein Hinweis: Blockly hat dir Paramater reingezogen, die du gar nicht brauchst.

➡️ Ergebnis: schwer wartbar, und du glaubst evtl. „das beeinflusst was“, tut es aber nicht.

---

3) Falsche/inkonsistente Nutzung von compareTime()

Du hast mehrere Varianten:

a) Morgens:

if (compareTime(getAstroDate('dawn', undefined, 18), null, '<', null)) {

Das sieht aus wie Blockly-„Compare Time“ in der 4-Argument-Variante. Kann funktionieren, ist aber seltsam (null/null).

b) Abends:

if (compareTime('21:36', 'null', '<')) {

Hier ist 'null' ein String, nicht null.

➡️ Das ist sehr wahrscheinlich ein Fehler. Je nach Implementierung von compareTime ist 'null' ein ungültiger Zeitpunkt und die Funktion liefert dann immer false oder verhält sich unerwartet.

Vermutlich wolltest du: „wenn aktuelle Zeit < 21:36“ oder „wenn 21:36 < aktuelle Zeit“. Dafür ist die typische Blockly-Semantik:

• compareTime('21:36', null, '<') → vergleicht '21:36' mit jetzt
• oder compareTime(null, '21:36', '<') je nach Variante

Konkreter Verdacht: Dein Abend-Einschalten läuft evtl. nie, weil der Vergleich falsch ist.

---

4) Du setzt „EingeschaltetHueMax“ nur beim Ausschalten – aber nicht beim Einschalten

Beim Dimmen „ein“ setzt du:

• Helligkeit ggf. auf 5
• Farbtemperatur
• Abdimm-aktiv true
• und erhöhst Helligkeit

Beim Dimmen „aus“ machst du am Ende:

setState('alias.0.OG.Flur.Licht.EingeschaltetHueMax', false);

➡️ Aber beim Einschalten setzt du EingeschaltetHueMax nicht auf true. Wenn andere Logik oder Visualisierung davon abhängt, ist das inkonsistent.

---

5) Race-Conditions / parallele Intervalle: nicht konsequent gestoppt

Du stoppst Intervalle zwar oft, aber nicht überall:

• Beim Start von Max_dimmen('ein') stoppst du nicht automatisch ein evtl. laufendes MAX_ein oder MAX_aus (nur in den Schedules machst du das davor).
• Im aus-Zweig stoppst du nur dann sofort, wenn Abdimmen_aktiv true ist:

if (getState('...Abdimmen_aktiv').val) {
  clearInterval(MAX_ein); clearInterval(MAX_aus);
}

➡️ Wenn Abdimmen_aktiv aus irgendeinem Grund false ist, können alte Intervalle weiterlaufen und du startest zusätzlich MAX_aus. Dann schreiben zwei Timer gegeneinander.

Robust fix: Immer am Anfang von Max_dimmen() beide Intervalle killen, unabhängig vom Flag.

---

6) setInterval(async () => { ... }) – async im Interval ohne Nutzen

Du nutzt async in den Interval-Callbacks, aber du await-est da drin praktisch nichts (außer in setTimeout, was auch ohne async geht).

➡️ Kein direkter Fehler, aber: falls du später await einbaust, kann es passieren, dass ein neuer Interval-Tick startet, bevor der alte fertig ist (Überlappung). Besser: kein async im setInterval oder einen „Lock“ setzen.

---

7) Schwellenwerte beim Ausschalten: mögliche Endlosschleife / nie ganz aus

Im Ausblend-Zweig:

if (MAX_Wert == 0) {
  if (helligkeit > 6) MAX_Helligkeit = true; else false;
}
...
if (MAX_Helligkeit) helligkeit -= 5
else stop + ausgeschaltet=false

➡️ Du dimmst runter bis <= 6, dann stoppst du und setzt EingeschaltetHueMax=false. Aber du setzt die Helligkeit nicht auf 0. D.h. sie kann bei 6 stehen bleiben.

• Wenn dein Gerät bei 6 noch sichtbar leuchtet: bleibt an.
• Wenn du später „ein“ startest, hast du nicht „aus=0“ als Ausgangslage.

Wenn du wirklich „aus“ willst, setz beim Ende explizit auf 0.

---

8) Doppelbelegung / uneindeutige Zustände: „Abdimmen_aktiv“

Du setzt:

• beim Einschalten: Abdimmen_aktiv erst auf true, später auf MAX_aufdimmen_aktiv (bei dir meist false)
• beim Ausschalten: setzt du es auf MAX_aufdimmen_aktiv

➡️ Der Name passt nicht: du nutzt es als „läuft gerade ein Dimmer-Zyklus“ (lock), aber setzt es am Ende auf einen Parameterwert, der in deinen Aufrufen immer false ist. Das ist okay, aber dann brauchst du keinen Parameter dafür.

---

9) Cron-Strings aus States: Gefahr von „kaputtem Cron“ ohne Validierung

Du baust Cron so:

min + ' ' + std + ' ' + datum + ' ' + monat + ' ' + wochentag

Wenn einer der States leer ist oder * falsch gesetzt wird, erzeugst du einen ungültigen Cron und schedule() kann still scheitern oder Exceptions werfen.

➡️ Blockly macht das gern, aber produktiv solltest du mindestens loggen, welcher Cron konkret gesetzt wurde und ob schedule() eine ID zurückgab.

---

10) Kleinigkeiten, aber echte Wartungsbremsen

• Sehr viele globale Variablen, die eigentlich nur Timer-Handles sind (MAX_ein, MAX_aus, Wartezeit).
• MAX_Wert == 0 vs === – mit .val aus ioBroker kann auch string kommen. Dann ist == wieder „zufällig“ korrekt.

---

Was ich konkret als „Minimal-Fix“ empfehlen würde (ohne alles umzubauen)

1. Am Anfang von Max_dimmen immer alles stoppen:

• clearInterval(MAX_ein), clearInterval(MAX_aus), optional clearTimeout(Wartezeit)

2. Erreichbar immer booleanisieren

• const reachable = !!getState(...).val;
• und MAX_erreichbar ebenfalls !!MAX_erreichbar

3. compareTime('21:36', 'null', '<') korrigieren

• sehr wahrscheinlich muss 'null' → null (ohne Quotes) oder die Argumente anders.

4. Beim Ausschalt-Ende Helligkeit auf 0 setzen

• setState(...Helligkeit..., 0);

5. Optional: EingeschaltetHueMax beim Einschalten auf true.

---

Wenn du willst, kann ich dir als nächsten Schritt eine bereinigte Version 1:1 auf Basis deines Codes posten (gleiches Verhalten, aber mit den oben genannten Fixes, weniger Parametern, sauberem Timer-Handling). Ich würde dafür nur kurz wissen:

• Liefert alias.0.OG.Flur.Licht.Erreichbar Hue Max bei dir 0/1 oder true/false?
• Soll „aus“ wirklich auf 0 gehen oder bewusst bei 6 stoppen?

[Homoran]

@oliverio

@Kapitaen31 sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

*** DISPLAY-SERVER SETUP ***
Display-Server: false
Unit display-manager.service could not be found.
Display-Manager:
Desktop:
Session: tty

@OliverIO sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

Erreichbar immer booleanisieren

das dürfte sein was ich gesehen hatte

[Kapitaen31]

@OliverIO sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

@Kapitaen31

zum vergleichmal noch chatgpt 5.2
sag mal welche ausgabe du besser findest bzw was dir mehr geholfen hat.

Vielen Dank, das Du das bei den beiden KIs reingeworfen hast.
Beides ist sehr wertvoll. ich denke, ich werde die Tipps von ChatGPT umsetzen....
Das schaffe ich nur heute nicht mehr.
Vielleicht schreibe ich das auch komplett in JavaScript neu... Das hatte ich schon länger auf dem Plan.

[Kapitaen31]

@OliverIO sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

@Kapitaen31 sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

läuft bei dir auf dem raspi auch ein browser mit?
ansonsten ist das beschriebene problem wahrscheinlich nicht relevant, sollte aber auch behoben werden.

Nein, der PI läuft als reine SSH Maschine.
Ich habe noch den Adapter VIS installiert und benutze es auch.

[Kapitaen31]

sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

@Kapitaen31

Vielleicht schreibe ich das auch komplett in JavaScript neu... Das hatte ich schon länger auf dem Plan.

So, ich habe heute das Script erneuert. Rein in JavaScript geschrieben (mit Hilfe von ChatGPT). Ich denke, das ist jetzt wesentlich besser. Mein altes Blookly stammte auch aus meiner Anfangszeit vom iobroker (vor ca. 4 Jahren). Da habe ich halt anders programmiert (Chaos).

Spoiler

/*************************************************

• Hue_Max – Flurbeleuchtung OG mit VIS Wochenplan
• Automatisch: 7 Tage x 4 Felder x 2 Pläne = 56 States
• Kein Warnlog beim ersten Start
• V1.0 04.02.2026
  *************************************************/

/***********************

• ROOT-KONFIGURATION *
  ***********************/

// Basis für Eigene Daten
const ROOT = '0_userdata.0.EigeneDaten.hue.flurOG.max';

// Alias-Basis (physisches Gerät)
// Später wenn Alias geändert ist: const ALIAS = 'alias.0.hue.flurOG.max';
const ALIAS = 'alias.0.OG.Flur.Licht';
/****** Bei zweiter Lampe */
// const ROOT = '0_userdata.0.EigeneDaten.hue.flurOG.spot';
// const ALIAS = 'alias.0.hue.flurOG.spot';

const DP = {
on: ${ALIAS}.EingeschaltetHueMax, // später on
reachable: ${ALIAS}.ErreichbarHueMax, // später reachable
brightness: ${ALIAS}.HelligkeitHueMax, //später brightness
ct: ${ALIAS}.FarbTemperaturHueMax,// später colorTemp

vacation:   `${ROOT}.control.vacation`,
manualPlan: `${ROOT}.control.manual`

};

const PLAN = {
workday: {
morningOn: "05:00",
eveningOff: "21:45",
morningBrightness: 30,
eveningBrightness: 100
},
vacation: {
morningOn: "06:30",
eveningOff: "22:00",
morningBrightness: 30,
eveningBrightness: 100
},
colorTemp: 2730
};

let DP_STATUS = ${ROOT}.status.mode;

let COLOR_TEMP = 2730;
let DIM_STEP = 2; // Prozent pro Intervall
let DIM_INTERVAL = 7000; // ms Intervall

let dimTimer = null;
let mySchedules = []; // Scheduler-Registry
let isAutoDimming = false;
let isAutoSwitching = false;

/*********************************************************

• Initialisierung 0_userdata Defaults
  *********************************************************/
  const WEEKDAYS = ['mon','tue','wed','thu','fri','sat','sun'];
  const STATE_DEFS = [
  { name: 'onMorning', type: 'string', role: 'value', def: '05:00' },
  { name: 'offEvening', type: 'string', role: 'value', def: '21:45' },
  { name: 'brightnessMorning', type: 'number', role: 'level.dimmer', def: 30 },
  { name: 'brightnessEvening', type: 'number', role: 'level.dimmer', def: 100 }
  ];

function ensureWeekdayStates(planName) {
WEEKDAYS.forEach(day => {
const base = ${ROOT}.schedule.${planName}.${day};

    STATE_DEFS.forEach(def => {
        const id = `${base}.${def.name}`;

        if (!existsState(id)) {
            ensureState(id, def);
        } else {
            const state = getState(id);
            if (state.val === null || state.val === undefined) {
                setState(id, def.def);
                log(`State initialisiert: ${id} = ${def.def}`, 'info');
            }
        }
    });
});

}

function ensureStateWithDefault(id, common, def) {
if (!existsState(id)) {
ensureState(id, {
...common,
def: def
});
} else {
const state = getState(id);
if (state.val === null || state.val === undefined) {
setState(id, def);
log(State initialisiert: ${id} = ${def}, 'info');
}
}
}

/* ========= Hilfsfunktionen ========= */

function astroStringToDate(timeStr) {
if (!timeStr) return null;
const parts = timeStr.split(':').map(Number);
const d = new Date();
d.setHours(parts[0], parts[1], parts[2] || 0, 0);
return d;
}

function timeToDate(timeStr) {
const [h, m] = timeStr.split(':').map(Number);
const d = new Date();
d.setHours(h, m, 0, 0);
return d;
}

function scheduleIfFuture(date, callback) {
if (date instanceof Date && date.getTime() > Date.now()) {
const s = schedule(date, callback);
if (s) mySchedules.push(s);
}
}

function getDayPlan(planName, day) {
const base = ${ROOT}.schedule.${planName}.${day};

const plan = {
    morningOn: getState(`${base}.onMorning`)?.val,
    eveningOff: getState(`${base}.offEvening`)?.val,
    morningBrightness: getState(`${base}.brightnessMorning`)?.val,
    eveningBrightness: getState(`${base}.brightnessEvening`)?.val
};

if (Object.values(plan).some(v => v === undefined || v === null)) {
    log(`Hue_Max: Unvollständiger Tagesplan für ${planName}/${day}`, 'warn');
}

return plan;

}

/* ========= SCHEDULER VERWALTUNG ========= */

function clearMySchedules() {
mySchedules.forEach(s => clearSchedule(s));
mySchedules = [];
}

/* ========= DIMMEN ========= */

function dimTo(target, callback) {
if (dimTimer) clearInterval(dimTimer);

dimTimer = setInterval(() => {
    const current = getState(DP.brightness).val;

    if (current === target) {
        clearInterval(dimTimer);
        dimTimer = null;
        if (callback) callback();
        return;
    }

    const next =
        current < target
            ? Math.min(current + DIM_STEP, target)
            : Math.max(current - DIM_STEP, target);

    setState(DP.brightness, next);
}, DIM_INTERVAL);

}

function switchOn(brightness) {
if (!getState(DP.reachable).val) return;

setState(DP.ct, PLAN.colorTemp);
setState(DP.brightness, 1);
setTimeout(() => {
    setState(DP.on, true, true);
    dimTo(brightness);
}, 300);

}

function switchOff() {
dimTo(0, () => setState(DP.on, false));
}

/* ========= TAGES-SCHEDULER ========= */
function setStatusAuto() {
if (existsState(DP_STATUS)) {
setState(DP_STATUS, 0, true);
}
}

function scheduleDay() {
clearMySchedules();

const now = new Date();
const WEEKDAYS = ['sun','mon','tue','wed','thu','fri','sat'];
const day = WEEKDAYS[new Date().getDay()];


const planName = getState(DP.vacation)?.val ? 'vacation' : 'workday';
const plan = getDayPlan(planName, day);

const sunrise = astroStringToDate(getState('javascript.0.variables.astro.sunrise')?.val);
const sunset  = astroStringToDate(getState('javascript.0.variables.astro.sunset')?.val);

const morningOn = timeToDate(plan.morningOn);
const eveningOff = timeToDate(plan.eveningOff);

// MORGEN EIN (nur vor Sonnenaufgang)
if (sunrise && morningOn < sunrise) {
    scheduleIfFuture(timeToDate(plan.morningOn), () => {
    if (timeToDate(plan.morningOn) < sunrise) {
        switchOn(plan.morningBrightness);
        }
    });
}

// MORGEN AUS
scheduleIfFuture(sunrise, () => {
    if (getState(DP.on).val) switchOff();
});

// ABEND EIN
scheduleIfFuture(sunset, () => {
    switchOn(plan.eveningBrightness);
});

// ABEND AUS
scheduleIfFuture(timeToDate(plan.eveningOff), () => {
    if (getState(DP.on).val) switchOff();
});

setStatusAuto();
log(`Hue_Max: Tages-Scheduler für ${planName}, ${day} neu aufgebaut`, 'info');
log(`Hue_Max: Morgen EIN um ${plan.morningOn}, Abend AUS um ${plan.eveningOff}`, 'info');

}

/* ========= INITIALISIERUNG ========= */

// 1. Alle States für beide Pläne anlegen
ensureWeekdayStates('workday');
ensureWeekdayStates('vacation');
ensureStateWithDefault(
DP.vacation,
{ type:'boolean', role:'state' },
false
);

ensureStateWithDefault(
DP.manualPlan,
{ type:'boolean', role:'state' },
false
);

ensureStateWithDefault(
DP_STATUS,
{
type: 'number',
role: 'value',
states: { 0:'auto', 1:'manual', 2:'unreachable' }
},
0
);

// 3. Danach Scheduler starten
setTimeout(() => { scheduleDay(); }, 1000);

// 4. Tägliche Neuplanung um 00:01 Uhr
schedule('1 0 * * *', scheduleDay);

[Kapitaen31]

@Homoran sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

@Kapitaen31 sagte in ioBroker auf PI4 stürzt immer mal wieder ab:

Allerdings sind die Kerne trotz dem gut belastet.

finde erst mal raus warum.

Ich hatte mir noch die LOGs angeschaut von vor dem letzten Absturz.

journalctl --no-pager -o short-iso \
  --since "2026-01-30 16:30" \
  --until "2026-01-30 17:30" > /tmp/journal_err.log

Dabei kam diese Ausgabe raus.

journal2026 01 30 1630 1730.log

in dem LOG ist nichts auffähliges zu sehen. Jedenfalls für mich. Um 17:03 hören die LOGs auf und erst nach dem Neustart um ca. 17:21 werden sie fortgesetzt.

[Kapitaen31]

Ich habe nochmals mein System gecheckt. Vor allem war mein Swap Speicher sehr klein.

Mit diesem Befehl habe ich die Logs ausgeben lassen

journalctl -u influxdb --since "2026-02-02 18:10" --until "2026-02-02 18:15"

In diesem Zeitraum waren meine Fehler von der influxdb2 zu suchen.

Dort wurde mir immer wieder dieser Fehler angezeigt.

2026-02-02 18:13:14.137 warn Error on writePoint("{"value":0,"time":"2026-02-02T17:13:12.917Z","from":"system.adapter.influxdb.0","q":0,"ack":true}): Error: connect ECONNREFUSED 192.168.178.36:8086 / "connect ECONNREFUSED 192.168.178.36:8086""

Das Log ein wenig gekürzt sieht so aus:

Spoiler

journalctl -u influxdb --since "2026-02-02 18:10" --until "2026-02-02 18:15"
Feb 02 18:13:12 PIArgon systemd[1]: influxdb.service: Main process exited, code>
Feb 02 18:13:12 PIArgon systemd[1]: influxdb.service: Failed with result 'signal'>
Feb 02 18:13:12 PIArgon systemd[1]: influxdb.service: Consumed 1h 7min 29.878s >
Feb 02 18:13:12 PIArgon systemd[1]: influxdb.service: Scheduled restart job, re>
Feb 02 18:13:12 PIArgon systemd[1]: Stopped influxdb.service - InfluxDB is an o>
Feb 02 18:13:12 PIArgon systemd[1]: influxdb.service: Consumed 1h 7min 29.878s >
Feb 02 18:13:13 PIArgon systemd[1]: Starting influxdb.service - InfluxDB is an >
Feb 02 18:13:14 PIArgon influxd-systemd-start.sh[230437]: time="2026-02-02T18:1>
Feb 02 18:13:14 PIArgon influxd-systemd-start.sh[230436]: time="2026-02-02T18:1>
Feb 02 18:13:14 PIArgon influxd-systemd-start.sh[230437]: Command "print-config>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230462]: time="2026-02-02T18:1>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230462]: Command "print-config>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230474]: time="2026-02-02T18:1>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230474]: Command "print-config>
Feb 02 18:13:15 PIArgon influxd-systemd-start.sh[230429]: InfluxDB API at http:>
Feb 02 18:13:16 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:16 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:16 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:16 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:16 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:16 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:16 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1>
Feb 02 18:13:16 PIArgon influxd-systemd-start.sh[230436]: ts=2026-02-02T17:13:1> lines 1-30

Ich habe dann noch nach einem out of Memory Fehler gesucht. Weil wahrscheinlich der Speicher voll war und der Dienst (influxDB) immer wieder beendet wurde.
Mit diesem Befehl habe ich es weiter eingegrenzt:

dmesg | grep -i oom

Mir wurde immer wieder ein out of memory angezeigt.

Feb 01 18:11:19 PIArgon kernel: Out of memory: Killed process 779 (influxd) total-vm:3412376kB, anon-rss:579712kB, file-rss:84kB, shmem-rss:0kB, UID:999 pgtables:3192kB oom_score_adj:0

Gesamtes Log:

Spoiler

Feb 01 18:11:18 PIArgon kernel: io.mqtt.0 invoked oom-killer: gfp_mask=0x140cca(GFP_HIGHUSER_MOVABLE|__GFP_COMP), order=0, oom_score_adj=0
Feb 01 18:11:18 PIArgon kernel: oom_kill_process+0x140/0x368
Feb 01 18:11:19 PIArgon kernel: [ pid ] uid tgid total_vm rss rss_anon rss_file rss_shmem pgtables_bytes swapents oom_score_adj name
Feb 01 18:11:19 PIArgon kernel: oom-kill:constraint=CONSTRAINT_NONE,nodemask=(null),cpuset=/,mems_allowed=0,global_oom,task_memcg=/,task=influxd,pid=779,uid=999
Feb 01 18:11:19 PIArgon kernel: Out of memory: Killed process 779 (influxd) total-vm:3412376kB, anon-rss:579712kB, file-rss:84kB, shmem-rss:0kB, UID:999 pgtables:3192kB oom_score_adj:0
Feb 01 18:41:18 PIArgon kernel: node invoked oom-killer: gfp_mask=0x140cca(GFP_HIGHUSER_MOVABLE|__GFP_COMP), order=0, oom_score_adj=0
Feb 01 18:41:18 PIArgon kernel: oom_kill_process+0x140/0x368
Feb 01 18:41:18 PIArgon kernel: [ pid ] uid tgid total_vm rss rss_anon rss_file rss_shmem pgtables_bytes swapents oom_score_adj name
Feb 01 18:41:18 PIArgon kernel: oom-kill:constraint=CONSTRAINT_NONE,nodemask=(null),cpuset=/,mems_allowed=0,global_oom,task_memcg=/,task=influxd,pid=105374,uid=999
Feb 01 18:41:18 PIArgon kernel: Out of memory: Killed process 105374 (influxd) total-vm:3408172kB, anon-rss:704452kB, file-rss:116kB, shmem-rss:0kB, UID:999 pgtables:2888kB oom_score_adj:0
Feb 02 18:13:12 PIArgon kernel: grafana invoked oom-killer: gfp_mask=0x140cca(GFP_HIGHUSER_MOVABLE|__GFP_COMP), order=0, oom_score_adj=0
Feb 02 18:13:12 PIArgon kernel: oom_kill_process+0x140/0x368
Feb 02 18:13:12 PIArgon kernel: [ pid ] uid tgid total_vm rss rss_anon rss_file rss_shmem pgtables_bytes swapents oom_score_adj name
Feb 02 18:13:13 PIArgon kernel: oom-kill:constraint=CONSTRAINT_NONE,nodemask=(null),cpuset=/,mems_allowed=0,global_oom,task_memcg=/,task=influxd,pid=199663,uid=999
Feb 02 18:13:13 PIArgon kernel: Out of memory: Killed process 199663 (influxd) total-vm:3454828kB, anon-rss:657772kB, file-rss:0kB, shmem-rss:0kB, UID:999 pgtables:3008kB oom_score_adj:0

Deshalb habe ich den swap Speicher erhöht. Mit diesem Befehl habe ich dies geändert:

sudo dphys-swapfile swapoff
sudo nano /etc/dphys-swapfile

In dem swap-File habe ich den Speicher auf 1024 gesetzt.

CONF_SWAPSIZE=1024

Danach habe ich folgende Befehle ausgeführt, um den Swap zu aktivieren :

sudo dphys-swapfile setup
sudo dphys-swapfile swapon

Mit

swapon --show

kann der Speicher angezeigt werden.
Der sieht jetzt so aus:

PI@PIArgon:/opt/iobroker/log $ swapon --show
NAME      TYPE  SIZE USED PRIO
/var/swap file 1024M 530M   -2

Das waren bis jetzt meine Änderungen. Und bisher ist das System nicht wieder abgestürzt.

Gestern habe ich das System auf Trixie hochgezogen. mal sehen wie es sich jetzt noch verhält.
Aber ich denke, das ich es gelöst bekommen habe.

[OliverIO]

@Kapitaen31

Swap erhöhen ist aber auch nur eine hilfskrücke um den Absturz zu verhindern. Für die Performance ist es katastrophal.
Insbesondere Datenbanken arbeiten stark mit RAM. Wenn dein Datenbestand größer wird und du das System noch weiter ausbauen willst, wirst du neue Hardware benötigen.