Skip to content
  • Home
  • Aktuell
  • Tags
  • 0 Ungelesen 0
  • Kategorien
  • Unreplied
  • Beliebt
  • GitHub
  • Docu
  • Hilfe
Skins
  • Light
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Standard: (Kein Skin)
  • Kein Skin
Einklappen
ioBroker Logo

Community Forum

donate donate
  1. ioBroker Community Home
  2. Deutsch
  3. Skripten / Logik
  4. JavaScript
  5. Wer findet den Fehler im Skript (ZisternenNachbefüllung)

NEWS

  • UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?
    apollon77A
    apollon77
    48
    3
    8.9k

  • Monatsrückblick – September 2025
    BluefoxB
    Bluefox
    13
    1
    2.3k

  • Neues Video "KI im Smart Home" - ioBroker plus n8n
    BluefoxB
    Bluefox
    16
    1
    3.5k

Wer findet den Fehler im Skript (ZisternenNachbefüllung)

Geplant Angeheftet Gesperrt Verschoben JavaScript
11 Beiträge 6 Kommentatoren 697 Aufrufe 2 Watching
  • Älteste zuerst
  • Neuste zuerst
  • Meiste Stimmen
Antworten
  • In einem neuen Thema antworten
Anmelden zum Antworten
Dieses Thema wurde gelöscht. Nur Nutzer mit entsprechenden Rechten können es sehen.
  • K keineAhnungvonProgrmieren

    Hallo zusammen,
    ich habe nach mehreren Stunden mit ChatGPT folgendes Skript erstellt. Leider funktioniert es noch nicht wie gewünscht.
    Anforderungen:
    wenn Füllstand länger wie 1min kleiner 5% dann schalte Shelly auf true für mindestens 45sec.
    Aktualiesiere die berechnung alle 15sec.
    Zusätzlich soll der shelly falls er extern auf true gestellt wurde alle 4 Zyklen auf false gestellt werden.

    alle funktioniert scheinbar aber falls der shelly extern auf true gestellt wird, wird er nicht automatisch auf false gestellt.

    Habt ihr eine Idee wo da was falsch programiert ist?

    einfach mit Copypaste rausskopiert:

    // Konfiguration
    const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
    const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
    const threshold = 5; // Schwellenwert auf 5% gesetzt
    const checkInterval = 15000; // 15 Sekunden
    const activateDuration = 45000; // Standard: 45 Sekunden
    const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird

    let shellyActive = false;
    let cycleCount = 0;

    // Funktion zum periodischen Auslesen des Tankfüllstands
    function readTankLevel() {
    // Tankfüllstand auslesen
    const tankLevel = getState(tankLevelId);
    if (tankLevel) {
    const tankLevelValue = parseFloat(tankLevel.val);
    console.log('Tank Level:', tankLevelValue);

        if (tankLevelValue < threshold) {
            // Schalte den Shelly Plug S ein und setze den Timer
            if (!shellyActive) {
                shellyActive = true;
                setState(shellyPlugId, true);
                console.log('Shelly Plug S aktiviert');
                setTimeout(() => {
                    // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                    shellyActive = false;
                    setState(shellyPlugId, false);
                    console.log('Shelly Plug S deaktiviert');
                }, activateDuration);
            }
            cycleCount++;
            if (cycleCount >= maxCyclesBeforeShutdown) {
                // Deaktiviere den Shelly Plug S nach der maximalen Anzahl von Zyklen
                shellyActive = false;
                setState(shellyPlugId, false);
                console.log('Shelly Plug S deaktiviert nach', maxCyclesBeforeShutdown, 'Zyklen');
                cycleCount = 0;
            }
        } else {
            // Wenn der Füllstand den Schwellenwert überschreitet, setze den Zählzyklus zurück
            cycleCount = 0;
        }
    }
    

    }

    // Periodisch den Tankfüllstand auslesen
    setInterval(() => {
    console.log('--- Neuer Zyklus ---');
    readTankLevel();
    }, checkInterval);

    DJMarc75D Offline
    DJMarc75D Offline
    DJMarc75
    schrieb am zuletzt editiert von
    #2

    @keineahnungvonprogrmieren sagte in Wer findet den Fehler im Skript (ZisternenNachbefüllung):

    Habt ihr eine Idee wo da was falsch programiert ist?

    Pack mal bitte das ganze Skript in Codetags - dann kann vll geholfen werden :)

    Lehrling seit 1975 !!!
    Beitrag geholfen ? dann gerne ein upvote rechts unten im Beitrag klicken ;)
    https://forum.iobroker.net/topic/51555/hinweise-f%C3%BCr-gute-forenbeitr%C3%A4ge

    1 Antwort Letzte Antwort
    0
    • K keineAhnungvonProgrmieren

      Hallo zusammen,
      ich habe nach mehreren Stunden mit ChatGPT folgendes Skript erstellt. Leider funktioniert es noch nicht wie gewünscht.
      Anforderungen:
      wenn Füllstand länger wie 1min kleiner 5% dann schalte Shelly auf true für mindestens 45sec.
      Aktualiesiere die berechnung alle 15sec.
      Zusätzlich soll der shelly falls er extern auf true gestellt wurde alle 4 Zyklen auf false gestellt werden.

      alle funktioniert scheinbar aber falls der shelly extern auf true gestellt wird, wird er nicht automatisch auf false gestellt.

      Habt ihr eine Idee wo da was falsch programiert ist?

      einfach mit Copypaste rausskopiert:

      // Konfiguration
      const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
      const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
      const threshold = 5; // Schwellenwert auf 5% gesetzt
      const checkInterval = 15000; // 15 Sekunden
      const activateDuration = 45000; // Standard: 45 Sekunden
      const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird

      let shellyActive = false;
      let cycleCount = 0;

      // Funktion zum periodischen Auslesen des Tankfüllstands
      function readTankLevel() {
      // Tankfüllstand auslesen
      const tankLevel = getState(tankLevelId);
      if (tankLevel) {
      const tankLevelValue = parseFloat(tankLevel.val);
      console.log('Tank Level:', tankLevelValue);

          if (tankLevelValue < threshold) {
              // Schalte den Shelly Plug S ein und setze den Timer
              if (!shellyActive) {
                  shellyActive = true;
                  setState(shellyPlugId, true);
                  console.log('Shelly Plug S aktiviert');
                  setTimeout(() => {
                      // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                      shellyActive = false;
                      setState(shellyPlugId, false);
                      console.log('Shelly Plug S deaktiviert');
                  }, activateDuration);
              }
              cycleCount++;
              if (cycleCount >= maxCyclesBeforeShutdown) {
                  // Deaktiviere den Shelly Plug S nach der maximalen Anzahl von Zyklen
                  shellyActive = false;
                  setState(shellyPlugId, false);
                  console.log('Shelly Plug S deaktiviert nach', maxCyclesBeforeShutdown, 'Zyklen');
                  cycleCount = 0;
              }
          } else {
              // Wenn der Füllstand den Schwellenwert überschreitet, setze den Zählzyklus zurück
              cycleCount = 0;
          }
      }
      

      }

      // Periodisch den Tankfüllstand auslesen
      setInterval(() => {
      console.log('--- Neuer Zyklus ---');
      readTankLevel();
      }, checkInterval);

      Ro75R Offline
      Ro75R Offline
      Ro75
      schrieb am zuletzt editiert von Ro75
      #3

      @keineahnungvonprogrmieren sagte in Wer findet den Fehler im Skript (ZisternenNachbefüllung):

      // Tankfüllstand auslesen
      const tankLevel = getState(tankLevelId);

      Versuche mal so:

       var tankLevel = getState(tankLevelId).val;
      

      und

      if (tankLevel) {
      const tankLevelValue = parseFloat(tankLevel.val);

      if (tankLevel) {
      var tankLevelValue = parseFloat(tankLevel);
      

      Habe nur mal kurz überflogen...
      Ro75.

      SERVER = Beelink U59 16GB DDR4 RAM 512GB SSD, FB 7490, FritzDect 200+301+440, ConBee II, Zigbee Aqara Sensoren + NOUS A1Z, NOUS A1T, Philips Hue ** ioBroker, REDIS, influxdb2, Grafana, PiHole, Plex-Mediaserver, paperless-ngx (Docker), MariaDB + phpmyadmin *** VIS-Runtime = Intel NUC 8GB RAM 128GB SSD + 24" Touchscreen

      1 Antwort Letzte Antwort
      0
      • HomoranH Nicht stören
        HomoranH Nicht stören
        Homoran
        Global Moderator Administrators
        schrieb am zuletzt editiert von
        #4

        Wo wird denn hier im showroom ein nützliches Projekt vorgestellt?

        ich schieb das mal nach javascript.

        kein Support per PN! - Fragen im Forum stellen - es gibt fast nichts, was nicht auch für andere interessant ist.

        Benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat.

        der Installationsfixer: curl -fsL https://iobroker.net/fix.sh | bash -

        1 Antwort Letzte Antwort
        0
        • K keineAhnungvonProgrmieren

          Hallo zusammen,
          ich habe nach mehreren Stunden mit ChatGPT folgendes Skript erstellt. Leider funktioniert es noch nicht wie gewünscht.
          Anforderungen:
          wenn Füllstand länger wie 1min kleiner 5% dann schalte Shelly auf true für mindestens 45sec.
          Aktualiesiere die berechnung alle 15sec.
          Zusätzlich soll der shelly falls er extern auf true gestellt wurde alle 4 Zyklen auf false gestellt werden.

          alle funktioniert scheinbar aber falls der shelly extern auf true gestellt wird, wird er nicht automatisch auf false gestellt.

          Habt ihr eine Idee wo da was falsch programiert ist?

          einfach mit Copypaste rausskopiert:

          // Konfiguration
          const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
          const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
          const threshold = 5; // Schwellenwert auf 5% gesetzt
          const checkInterval = 15000; // 15 Sekunden
          const activateDuration = 45000; // Standard: 45 Sekunden
          const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird

          let shellyActive = false;
          let cycleCount = 0;

          // Funktion zum periodischen Auslesen des Tankfüllstands
          function readTankLevel() {
          // Tankfüllstand auslesen
          const tankLevel = getState(tankLevelId);
          if (tankLevel) {
          const tankLevelValue = parseFloat(tankLevel.val);
          console.log('Tank Level:', tankLevelValue);

              if (tankLevelValue < threshold) {
                  // Schalte den Shelly Plug S ein und setze den Timer
                  if (!shellyActive) {
                      shellyActive = true;
                      setState(shellyPlugId, true);
                      console.log('Shelly Plug S aktiviert');
                      setTimeout(() => {
                          // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                          shellyActive = false;
                          setState(shellyPlugId, false);
                          console.log('Shelly Plug S deaktiviert');
                      }, activateDuration);
                  }
                  cycleCount++;
                  if (cycleCount >= maxCyclesBeforeShutdown) {
                      // Deaktiviere den Shelly Plug S nach der maximalen Anzahl von Zyklen
                      shellyActive = false;
                      setState(shellyPlugId, false);
                      console.log('Shelly Plug S deaktiviert nach', maxCyclesBeforeShutdown, 'Zyklen');
                      cycleCount = 0;
                  }
              } else {
                  // Wenn der Füllstand den Schwellenwert überschreitet, setze den Zählzyklus zurück
                  cycleCount = 0;
              }
          }
          

          }

          // Periodisch den Tankfüllstand auslesen
          setInterval(() => {
          console.log('--- Neuer Zyklus ---');
          readTankLevel();
          }, checkInterval);

          T Nicht stören
          T Nicht stören
          ticaki
          schrieb am zuletzt editiert von
          #5

          @keineahnungvonprogrmieren
          Pack das mal alles in code tags

          Weather-Warnings Espresense NSPanel-Lovelace-ui Tagesschau

          Spenden

          K 1 Antwort Letzte Antwort
          0
          • T ticaki

            @keineahnungvonprogrmieren
            Pack das mal alles in code tags

            K Offline
            K Offline
            keineAhnungvonProgrmieren
            schrieb am zuletzt editiert von
            #6

            @ticaki ; @Ro75
            Habe mal versucht die änderungen einzubauen, ist das so gemeint?

            Leider funktioniert es noch nicht so wie gedacht.
            Habe den shelly aus testgründen in der Instanz auf true gestellt, gehe davon aus das das skript Ihn dann auf false stellt.

            // Konfiguration
            const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
            const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
            const threshold = 5; // Schwellenwert auf 5% gesetzt
            const checkInterval = 15000; // 15 Sekunden
            const activateDuration = 45000; // Standard: 45 Sekunden
            const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird
            
            let shellyActive = false;
            let cycleCount = 0;
            
            // Funktion zum periodischen Auslesen des Tankfüllstands
            function readTankLevel() {
                // Tankfüllstand auslesen
                 const tankLevel = getState(tankLevelId).val; 
                
            
            if (tankLevel) {
            
            const tankLevelValue = parseFloat(tankLevel);
                    console.log('Tank Level:', tankLevelValue);
            
                    if (tankLevelValue < threshold) {
                        // Schalte den Shelly Plug S ein und setze den Timer
                        if (!shellyActive) {
                            shellyActive = true;
                            setState(shellyPlugId, true);
                            console.log('Shelly Plug S aktiviert');
                            setTimeout(() => {
                                // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                                shellyActive = false;
                                setState(shellyPlugId, false);
                                console.log('Shelly Plug S deaktiviert');
                            }, activateDuration);
                        }
                        cycleCount++;
                        if (cycleCount >= maxCyclesBeforeShutdown) {
                            // Deaktiviere den Shelly Plug S nach der maximalen Anzahl von Zyklen
                            shellyActive = false;
                            setState(shellyPlugId, false);
                            console.log('Shelly Plug S deaktiviert nach', maxCyclesBeforeShutdown, 'Zyklen');
                            cycleCount = 0;
                        }
                    } else {
                        // Wenn der Füllstand den Schwellenwert überschreitet, setze den Zählzyklus zurück
                        cycleCount = 0;
                    }
                }
            }
            
            // Periodisch den Tankfüllstand auslesen
            setInterval(() => {
                console.log('--- Neuer Zyklus ---');
                readTankLevel();
            }, checkInterval);
            
            
            K T Ro75R 3 Antworten Letzte Antwort
            0
            • K keineAhnungvonProgrmieren

              @ticaki ; @Ro75
              Habe mal versucht die änderungen einzubauen, ist das so gemeint?

              Leider funktioniert es noch nicht so wie gedacht.
              Habe den shelly aus testgründen in der Instanz auf true gestellt, gehe davon aus das das skript Ihn dann auf false stellt.

              // Konfiguration
              const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
              const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
              const threshold = 5; // Schwellenwert auf 5% gesetzt
              const checkInterval = 15000; // 15 Sekunden
              const activateDuration = 45000; // Standard: 45 Sekunden
              const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird
              
              let shellyActive = false;
              let cycleCount = 0;
              
              // Funktion zum periodischen Auslesen des Tankfüllstands
              function readTankLevel() {
                  // Tankfüllstand auslesen
                   const tankLevel = getState(tankLevelId).val; 
                  
              
              if (tankLevel) {
              
              const tankLevelValue = parseFloat(tankLevel);
                      console.log('Tank Level:', tankLevelValue);
              
                      if (tankLevelValue < threshold) {
                          // Schalte den Shelly Plug S ein und setze den Timer
                          if (!shellyActive) {
                              shellyActive = true;
                              setState(shellyPlugId, true);
                              console.log('Shelly Plug S aktiviert');
                              setTimeout(() => {
                                  // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                                  shellyActive = false;
                                  setState(shellyPlugId, false);
                                  console.log('Shelly Plug S deaktiviert');
                              }, activateDuration);
                          }
                          cycleCount++;
                          if (cycleCount >= maxCyclesBeforeShutdown) {
                              // Deaktiviere den Shelly Plug S nach der maximalen Anzahl von Zyklen
                              shellyActive = false;
                              setState(shellyPlugId, false);
                              console.log('Shelly Plug S deaktiviert nach', maxCyclesBeforeShutdown, 'Zyklen');
                              cycleCount = 0;
                          }
                      } else {
                          // Wenn der Füllstand den Schwellenwert überschreitet, setze den Zählzyklus zurück
                          cycleCount = 0;
                      }
                  }
              }
              
              // Periodisch den Tankfüllstand auslesen
              setInterval(() => {
                  console.log('--- Neuer Zyklus ---');
                  readTankLevel();
              }, checkInterval);
              
              
              K Offline
              K Offline
              keineAhnungvonProgrmieren
              schrieb am zuletzt editiert von
              #7

              @keineahnungvonprogrmieren
              Sorry natürlich in objekten ;-)

              1 Antwort Letzte Antwort
              0
              • K keineAhnungvonProgrmieren

                @ticaki ; @Ro75
                Habe mal versucht die änderungen einzubauen, ist das so gemeint?

                Leider funktioniert es noch nicht so wie gedacht.
                Habe den shelly aus testgründen in der Instanz auf true gestellt, gehe davon aus das das skript Ihn dann auf false stellt.

                // Konfiguration
                const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
                const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
                const threshold = 5; // Schwellenwert auf 5% gesetzt
                const checkInterval = 15000; // 15 Sekunden
                const activateDuration = 45000; // Standard: 45 Sekunden
                const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird
                
                let shellyActive = false;
                let cycleCount = 0;
                
                // Funktion zum periodischen Auslesen des Tankfüllstands
                function readTankLevel() {
                    // Tankfüllstand auslesen
                     const tankLevel = getState(tankLevelId).val; 
                    
                
                if (tankLevel) {
                
                const tankLevelValue = parseFloat(tankLevel);
                        console.log('Tank Level:', tankLevelValue);
                
                        if (tankLevelValue < threshold) {
                            // Schalte den Shelly Plug S ein und setze den Timer
                            if (!shellyActive) {
                                shellyActive = true;
                                setState(shellyPlugId, true);
                                console.log('Shelly Plug S aktiviert');
                                setTimeout(() => {
                                    // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                                    shellyActive = false;
                                    setState(shellyPlugId, false);
                                    console.log('Shelly Plug S deaktiviert');
                                }, activateDuration);
                            }
                            cycleCount++;
                            if (cycleCount >= maxCyclesBeforeShutdown) {
                                // Deaktiviere den Shelly Plug S nach der maximalen Anzahl von Zyklen
                                shellyActive = false;
                                setState(shellyPlugId, false);
                                console.log('Shelly Plug S deaktiviert nach', maxCyclesBeforeShutdown, 'Zyklen');
                                cycleCount = 0;
                            }
                        } else {
                            // Wenn der Füllstand den Schwellenwert überschreitet, setze den Zählzyklus zurück
                            cycleCount = 0;
                        }
                    }
                }
                
                // Periodisch den Tankfüllstand auslesen
                setInterval(() => {
                    console.log('--- Neuer Zyklus ---');
                    readTankLevel();
                }, checkInterval);
                
                
                T Nicht stören
                T Nicht stören
                ticaki
                schrieb am zuletzt editiert von ticaki
                #8

                Falsch läuft das du alle 15 Sekunden den Füllstand prüfst und wenn true schaltest du den shelly an und dann prüfst du 15 Sekunden später auf den Füllstand und schaltest den Shelly auf True und dann kommst drauf an wer zu erst malt. Jetzt kommt dein Timeout zurück und schaltet den Shelly ab und dann prüfst du den Füllstand und schaltest den Shelly auf true :)

                Zeit des umschließenden Intervals auf 1 Minute setzen.

                Weather-Warnings Espresense NSPanel-Lovelace-ui Tagesschau

                Spenden

                1 Antwort Letzte Antwort
                0
                • K keineAhnungvonProgrmieren

                  @ticaki ; @Ro75
                  Habe mal versucht die änderungen einzubauen, ist das so gemeint?

                  Leider funktioniert es noch nicht so wie gedacht.
                  Habe den shelly aus testgründen in der Instanz auf true gestellt, gehe davon aus das das skript Ihn dann auf false stellt.

                  // Konfiguration
                  const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
                  const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
                  const threshold = 5; // Schwellenwert auf 5% gesetzt
                  const checkInterval = 15000; // 15 Sekunden
                  const activateDuration = 45000; // Standard: 45 Sekunden
                  const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird
                  
                  let shellyActive = false;
                  let cycleCount = 0;
                  
                  // Funktion zum periodischen Auslesen des Tankfüllstands
                  function readTankLevel() {
                      // Tankfüllstand auslesen
                       const tankLevel = getState(tankLevelId).val; 
                      
                  
                  if (tankLevel) {
                  
                  const tankLevelValue = parseFloat(tankLevel);
                          console.log('Tank Level:', tankLevelValue);
                  
                          if (tankLevelValue < threshold) {
                              // Schalte den Shelly Plug S ein und setze den Timer
                              if (!shellyActive) {
                                  shellyActive = true;
                                  setState(shellyPlugId, true);
                                  console.log('Shelly Plug S aktiviert');
                                  setTimeout(() => {
                                      // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                                      shellyActive = false;
                                      setState(shellyPlugId, false);
                                      console.log('Shelly Plug S deaktiviert');
                                  }, activateDuration);
                              }
                              cycleCount++;
                              if (cycleCount >= maxCyclesBeforeShutdown) {
                                  // Deaktiviere den Shelly Plug S nach der maximalen Anzahl von Zyklen
                                  shellyActive = false;
                                  setState(shellyPlugId, false);
                                  console.log('Shelly Plug S deaktiviert nach', maxCyclesBeforeShutdown, 'Zyklen');
                                  cycleCount = 0;
                              }
                          } else {
                              // Wenn der Füllstand den Schwellenwert überschreitet, setze den Zählzyklus zurück
                              cycleCount = 0;
                          }
                      }
                  }
                  
                  // Periodisch den Tankfüllstand auslesen
                  setInterval(() => {
                      console.log('--- Neuer Zyklus ---');
                      readTankLevel();
                  }, checkInterval);
                  
                  
                  Ro75R Offline
                  Ro75R Offline
                  Ro75
                  schrieb am zuletzt editiert von
                  #9

                  @keineahnungvonprogrmieren

                  // Konfiguration
                  const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
                  const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
                  const threshold = 5; // Schwellenwert auf 5% gesetzt
                  const activateDuration = 45000; // Standard: 45 Sekunden
                  const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird
                   
                  let shellyActive = false;
                  let cycleCount = 0;
                   
                  // Funktion zum periodischen Auslesen des Tankfüllstands
                  function readTankLevel() {
                  if (tankLevel) {
                   
                  var tankLevelValue = parseFloat(tankLevel);
                          console.log('Tank Level:', tankLevelValue);
                   
                          if (tankLevelValue < threshold) {
                              // Schalte den Shelly Plug S ein und setze den Timer
                              if (!shellyActive) {
                                  shellyActive = true;
                                  setState(shellyPlugId, true);
                                  console.log('Shelly Plug S aktiviert');
                                  setTimeout(() => {
                                      // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                                      shellyActive = false;
                                      setState(shellyPlugId, false);
                                      console.log('Shelly Plug S deaktiviert');
                                  }, activateDuration);
                              }
                              cycleCount++;
                              if (cycleCount >= maxCyclesBeforeShutdown) {
                                  // Deaktiviere den Shelly Plug S nach der maximalen Anzahl von Zyklen
                                  shellyActive = false;
                                  setState(shellyPlugId, false);
                                  console.log('Shelly Plug S deaktiviert nach', maxCyclesBeforeShutdown, 'Zyklen');
                                  cycleCount = 0;
                              }
                          } else {
                              // Wenn der Füllstand den Schwellenwert überschreitet, setze den Zählzyklus zurück
                              cycleCount = 0;
                          }
                      }
                  }
                   
                  on(tankLevelId, function(dp) {
                      // Tankfüllstand auslesen
                      var tankLevel = dp.state.val; 
                  
                      console.log('--- Neuer Zyklus ---');
                      readTankLevel();
                  });
                  

                  SERVER = Beelink U59 16GB DDR4 RAM 512GB SSD, FB 7490, FritzDect 200+301+440, ConBee II, Zigbee Aqara Sensoren + NOUS A1Z, NOUS A1T, Philips Hue ** ioBroker, REDIS, influxdb2, Grafana, PiHole, Plex-Mediaserver, paperless-ngx (Docker), MariaDB + phpmyadmin *** VIS-Runtime = Intel NUC 8GB RAM 128GB SSD + 24" Touchscreen

                  1 Antwort Letzte Antwort
                  0
                  • K keineAhnungvonProgrmieren

                    Hallo zusammen,
                    ich habe nach mehreren Stunden mit ChatGPT folgendes Skript erstellt. Leider funktioniert es noch nicht wie gewünscht.
                    Anforderungen:
                    wenn Füllstand länger wie 1min kleiner 5% dann schalte Shelly auf true für mindestens 45sec.
                    Aktualiesiere die berechnung alle 15sec.
                    Zusätzlich soll der shelly falls er extern auf true gestellt wurde alle 4 Zyklen auf false gestellt werden.

                    alle funktioniert scheinbar aber falls der shelly extern auf true gestellt wird, wird er nicht automatisch auf false gestellt.

                    Habt ihr eine Idee wo da was falsch programiert ist?

                    einfach mit Copypaste rausskopiert:

                    // Konfiguration
                    const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
                    const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
                    const threshold = 5; // Schwellenwert auf 5% gesetzt
                    const checkInterval = 15000; // 15 Sekunden
                    const activateDuration = 45000; // Standard: 45 Sekunden
                    const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird

                    let shellyActive = false;
                    let cycleCount = 0;

                    // Funktion zum periodischen Auslesen des Tankfüllstands
                    function readTankLevel() {
                    // Tankfüllstand auslesen
                    const tankLevel = getState(tankLevelId);
                    if (tankLevel) {
                    const tankLevelValue = parseFloat(tankLevel.val);
                    console.log('Tank Level:', tankLevelValue);

                        if (tankLevelValue < threshold) {
                            // Schalte den Shelly Plug S ein und setze den Timer
                            if (!shellyActive) {
                                shellyActive = true;
                                setState(shellyPlugId, true);
                                console.log('Shelly Plug S aktiviert');
                                setTimeout(() => {
                                    // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                                    shellyActive = false;
                                    setState(shellyPlugId, false);
                                    console.log('Shelly Plug S deaktiviert');
                                }, activateDuration);
                            }
                            cycleCount++;
                            if (cycleCount >= maxCyclesBeforeShutdown) {
                                // Deaktiviere den Shelly Plug S nach der maximalen Anzahl von Zyklen
                                shellyActive = false;
                                setState(shellyPlugId, false);
                                console.log('Shelly Plug S deaktiviert nach', maxCyclesBeforeShutdown, 'Zyklen');
                                cycleCount = 0;
                            }
                        } else {
                            // Wenn der Füllstand den Schwellenwert überschreitet, setze den Zählzyklus zurück
                            cycleCount = 0;
                        }
                    }
                    

                    }

                    // Periodisch den Tankfüllstand auslesen
                    setInterval(() => {
                    console.log('--- Neuer Zyklus ---');
                    readTankLevel();
                    }, checkInterval);

                    paul53P Offline
                    paul53P Offline
                    paul53
                    schrieb am zuletzt editiert von paul53
                    #10

                    @keineahnungvonprogrmieren sagte: soll der shelly falls er extern auf true gestellt wurde alle 4 Zyklen auf false gestellt werden.

                    Vorschlag mit Shedule und Trigger auf den Shelly:

                    // Konfiguration
                    const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
                    const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
                    const threshold = 5; // Schwellenwert auf 5% gesetzt
                    const checkInterval = 15000; // 15 Sekunden
                    const activateDuration = 45000; // Standard: 45 Sekunden
                    const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird
                     
                    let shellyActive = getState(shellyPlugId).val;
                    var timer = null;
                     
                    // Funktion zum periodischen Auslesen des Tankfüllstands
                    function readTankLevel() {
                        // Tankfüllstand auslesen
                        const tankLevel = parseFloat(getState(tankLevelId).val); 
                        if (tankLevel) {
                            console.log('Tank Level:', tankLevel);
                            if (tankLevel < threshold) {
                                // Schalte den Shelly Plug S ein und setze den Timer
                                if (!shellyActive) {
                                    setState(shellyPlugId, true);
                                    console.log('Shelly Plug S aktiviert');
                                } 
                            } else if(shellyActive && !timer) {
                                timer = setTimeout(() => {
                                    // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                                    setState(shellyPlugId, false);
                                    console.log('Shelly Plug S deaktiviert');
                                    timer = null;
                                }, activateDuration);
                            }
                        }
                    }
                     
                    // Periodisch den Tankfüllstand auslesen
                    schedule('*/15 * * * * *', function() {
                        console.log('--- Neuer Zyklus ---');
                        readTankLevel();
                    });
                    
                    on(shellyPlugId, function(dp) {
                        shellyActive = dp.state.val;
                        if(shellyActive && dp.state.c != scriptName) {
                            setTimeout(function() {
                                setState(shellyPlugId, false);
                            }, maxCyclesBeforeShutdown * checkInterval);
                        }
                    });
                    

                    @keineahnungvonprogrmieren sagte in Wer findet den Fehler im Skript (ZisternenNachbefüllung):

                    kleiner 5% dann schalte Shelly auf true für mindestens 45sec.

                    Bitte verzichtet auf Chat-Nachrichten, denn die Handhabung ist grauenhaft !
                    Produktiv: RPi 2 mit S.USV, HM-MOD-RPI und SLC-USB-Stick mit root fs

                    K 1 Antwort Letzte Antwort
                    0
                    • paul53P paul53

                      @keineahnungvonprogrmieren sagte: soll der shelly falls er extern auf true gestellt wurde alle 4 Zyklen auf false gestellt werden.

                      Vorschlag mit Shedule und Trigger auf den Shelly:

                      // Konfiguration
                      const tankLevelId = '0_userdata.0.Füllstand_Hauptzisterne'; // Füllstand Hauptzisterne
                      const shellyPlugId = 'shelly.3.shellyplusplugs#d4d4daf36728#1.Relay0.Switch'; // Schalter
                      const threshold = 5; // Schwellenwert auf 5% gesetzt
                      const checkInterval = 15000; // 15 Sekunden
                      const activateDuration = 45000; // Standard: 45 Sekunden
                      const maxCyclesBeforeShutdown = 4; // Max. Anzahl der Zyklen, bevor der Shelly Plug deaktiviert wird
                       
                      let shellyActive = getState(shellyPlugId).val;
                      var timer = null;
                       
                      // Funktion zum periodischen Auslesen des Tankfüllstands
                      function readTankLevel() {
                          // Tankfüllstand auslesen
                          const tankLevel = parseFloat(getState(tankLevelId).val); 
                          if (tankLevel) {
                              console.log('Tank Level:', tankLevel);
                              if (tankLevel < threshold) {
                                  // Schalte den Shelly Plug S ein und setze den Timer
                                  if (!shellyActive) {
                                      setState(shellyPlugId, true);
                                      console.log('Shelly Plug S aktiviert');
                                  } 
                              } else if(shellyActive && !timer) {
                                  timer = setTimeout(() => {
                                      // Deaktiviere den Shelly Plug S nach Ablauf der Zeit
                                      setState(shellyPlugId, false);
                                      console.log('Shelly Plug S deaktiviert');
                                      timer = null;
                                  }, activateDuration);
                              }
                          }
                      }
                       
                      // Periodisch den Tankfüllstand auslesen
                      schedule('*/15 * * * * *', function() {
                          console.log('--- Neuer Zyklus ---');
                          readTankLevel();
                      });
                      
                      on(shellyPlugId, function(dp) {
                          shellyActive = dp.state.val;
                          if(shellyActive && dp.state.c != scriptName) {
                              setTimeout(function() {
                                  setState(shellyPlugId, false);
                              }, maxCyclesBeforeShutdown * checkInterval);
                          }
                      });
                      

                      @keineahnungvonprogrmieren sagte in Wer findet den Fehler im Skript (ZisternenNachbefüllung):

                      kleiner 5% dann schalte Shelly auf true für mindestens 45sec.

                      K Offline
                      K Offline
                      keineAhnungvonProgrmieren
                      schrieb am zuletzt editiert von
                      #11

                      @paul53

                      Mit dem skript funktioniert es . Vielen Dank für die Hilfe.

                      1 Antwort Letzte Antwort
                      0
                      Antworten
                      • In einem neuen Thema antworten
                      Anmelden zum Antworten
                      • Älteste zuerst
                      • Neuste zuerst
                      • Meiste Stimmen


                      Support us

                      ioBroker
                      Community Adapters
                      Donate

                      822

                      Online

                      32.4k

                      Benutzer

                      81.6k

                      Themen

                      1.3m

                      Beiträge
                      Community
                      Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen | Einwilligungseinstellungen
                      ioBroker Community 2014-2025
                      logo
                      • Anmelden

                      • Du hast noch kein Konto? Registrieren

                      • Anmelden oder registrieren, um zu suchen
                      • Erster Beitrag
                        Letzter Beitrag
                      0
                      • Home
                      • Aktuell
                      • Tags
                      • Ungelesen 0
                      • Kategorien
                      • Unreplied
                      • Beliebt
                      • GitHub
                      • Docu
                      • Hilfe