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. Ökofen Pelletronic Touch auslesen

NEWS

  • Neuer Blogbeitrag: Monatsrückblick - Dezember 2025 🎄
    BluefoxB
    Bluefox
    11
    1
    531

  • Weihnachtsangebot 2025! 🎄
    BluefoxB
    Bluefox
    24
    1
    1.7k

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

Ökofen Pelletronic Touch auslesen

Geplant Angeheftet Gesperrt Verschoben Skripten / Logik
56 Beiträge 7 Kommentatoren 21.6k Aufrufe 5 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.
  • L looxer01

    @oliwit82
    oha, das ist schon etwas her.
    Ich nutze meinen Betriebsstundenzähler und ermittle damit die Delta und der setzt auch immer bei Tagesumbruch die Zeiten zurück.
    Das script habe ich wohl irgendwann dann mal dediziert für die Oekofen Zeitenberechnung extrahiert. Allerdings nutze ich das gar nicht.

    Wenn es aber funktioniert ist es ja gut.
    Ich habe ein zusätzliches Script, das die Verbrauchsrechnung vornimmt. Also auch Forecast und augenblicklicher Bestand etc.
    Ich bin nicht sicher, ob das genau mit deinem Script passt. Könnte aber gut sein.

    Pelletverbrauchsrechnung.txt

    vG Looxer

    O Offline
    O Offline
    OliWit82
    schrieb am zuletzt editiert von
    #35

    @looxer01

    Hallo Danke.

    Ich teste das mal.
    Berichte dir dann.

    Danke

    Gruß
    Oliver

    1 Antwort Letzte Antwort
    0
    • L looxer01

      @oliwit82
      oha, das ist schon etwas her.
      Ich nutze meinen Betriebsstundenzähler und ermittle damit die Delta und der setzt auch immer bei Tagesumbruch die Zeiten zurück.
      Das script habe ich wohl irgendwann dann mal dediziert für die Oekofen Zeitenberechnung extrahiert. Allerdings nutze ich das gar nicht.

      Wenn es aber funktioniert ist es ja gut.
      Ich habe ein zusätzliches Script, das die Verbrauchsrechnung vornimmt. Also auch Forecast und augenblicklicher Bestand etc.
      Ich bin nicht sicher, ob das genau mit deinem Script passt. Könnte aber gut sein.

      Pelletverbrauchsrechnung.txt

      vG Looxer

      O Offline
      O Offline
      OliWit82
      schrieb am zuletzt editiert von
      #36

      @looxer01

      Hallo. So wollte mich ja noch mal melden.
      Das Script scheint bei mir nicht zu laufen da ich keine ccu nutze.

      Für den BSZ greifst du den direkten Strom am Motor ab, richtig?

      Wie viel Pellets brauchst du aktuell am Tag.
      Dann hab ich schon mal einen Ansatzpunkt ob meine Berechnung ansatzweise passt.

      So kann man dich über FB oder email erreichen?

      Danke und liebe Grüße aus Heinsberg

      L 1 Antwort Letzte Antwort
      0
      • O OliWit82

        @looxer01

        Hallo. So wollte mich ja noch mal melden.
        Das Script scheint bei mir nicht zu laufen da ich keine ccu nutze.

        Für den BSZ greifst du den direkten Strom am Motor ab, richtig?

        Wie viel Pellets brauchst du aktuell am Tag.
        Dann hab ich schon mal einen Ansatzpunkt ob meine Berechnung ansatzweise passt.

        So kann man dich über FB oder email erreichen?

        Danke und liebe Grüße aus Heinsberg

        L Offline
        L Offline
        looxer01
        schrieb am zuletzt editiert von looxer01
        #37

        @oliwit82
        Hi,

        @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

        Für den BSZ greifst du den direkten Strom am Motor ab, richtig

        ich mache das zweifach mit dem BSZ.

        1. Messung der Laufzeit der Schnecke über eine HM Schnittstelle (Strom an/aus Zeiten)
        2. Über Modbus und der Laufzeit "Saugen".

        zum Punkt 2.
        hier nutze ich eine Rg mit aus auf Erfahrung basierenden Annahmen (z.B. KG/ Minute Saugleistung, Nachlaufzeit, Vorlaufzeit etc)
        Hab den Code mal hier eingefügt

        //-----------------------------------------------------------------------------------------------------
        // Routine Oekofen // Oekofen von Saugen zu pelletverbrauch
        //    Funktion zur Verbrauchsert ermittlung  Pelletverbrauch Oekofen
        //    Vorgabewerte sind anzupassen
        //    function - die individualfunktion
        //    nummer die aktuelle bearbeitete Gruppe
        //    runtime = Wert zur weiteren Verarbeitung z.B. Millisekunden
        //-----------------------------------------------------------------------------------------------------
        function individual(funktion,nummer,runtime)  {
        
        log("funktion individual aufgerufen","info");
        
           if(funktion === "OEKOFEN") {
        
               // Werte zum Einstellen--------------------------------------------------------
               var vorgpause = 6;                                                              // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen
               var vorgintervall = 54;                                                         // laenge eines einzelnen Intervalls
               var vorgvorlauf = 32;                                                           // Saugzeit bevor die Schnecke läuft (Vakuum bilden)
               var vorgnachlauf = 15;                                                          // Laufzeit des Saugers nach stopp der schnecke
               var vorgverbrauch = 8;                                                        // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft
               //----------------------------------------------------------------------------
               log("funktion Oekofen aufgerufen - Runtime ist "+runtime,"info");       
               
               // Allgemeine Variablen
               var anzlaeufe = 0;
               var anzpausen = 0;
               var totpausen = 0;
               var restlaufzeit = 0;
               var net1runtime;
               var verbrauch;
               var schneckenzeit;
               
               runtime = runtime / 1000;                                                           // Laufzeit in Sekunden
               
               // Berechne Anzahl Läufe und Pausen
               net1runtime = runtime - vorgvorlauf - vorgnachlauf;
               anzlaeufe = Math.floor(net1runtime / vorgintervall);
               anzpausen = anzlaeufe-1;
               
               //theoretische Restlaufzeit berechnen
               restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
               
               //Korrektur anzahl laeufe und pausen falls notwendig
               if (restlaufzeit + vorgpause < 0 )                                                  //Grenzfall wenn die Restzeit kleiner als null ist, dann muss anzahl läufe angepasst werden
                 {  anzlaeufe =anzlaeufe - 1;
                    anzpausen = anzpausen - 1;
                    restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                 }
                 
               // Verbrauch berechnen 
               // schneckenzeit = runtime - vorgvorlauf - vorgnachlauf  - (anzpausen * vorgpause);    // alte Routine bis Dezember mit Intervallen reine Schneckenlaufzeit berechnen
        
               schneckenzeit = runtime - vorgvorlauf - vorgnachlauf;                                    // im Dezember neue Steuerung es gibt keine Intervalle mehr
               verbrauch = schneckenzeit * vorgverbrauch/60 ; // Pelletverbrauch berechnen
        
               if(verbrauch < 0) {                                                                 //Wenn die Zeit zu kurz ist können Minuswerte herauskommen
                   verbrauch = 0;
               }
               return verbrauch;
           
           } // endif Oekofen
        
        

        Nach dem ich schon seit Jahren 1 und 2 vergleiche kann ich sagen, dass beides gut funktioniert

        @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

        Wie viel Pellets brauchst du aktuell am Tag

        das ist denke ich nicht vergleichbar mit deiner Situation, da mein Haus weit entfernt von Standard ist.
        Heisst ich brauche über den Durchschnitt. aber aus dem Coding oben kannst du meine Annahmen übernehmen und für
        dich selbst anwenden

        vG Looxer

        O 1 Antwort Letzte Antwort
        0
        • L looxer01

          @oliwit82
          Hi,

          @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

          Für den BSZ greifst du den direkten Strom am Motor ab, richtig

          ich mache das zweifach mit dem BSZ.

          1. Messung der Laufzeit der Schnecke über eine HM Schnittstelle (Strom an/aus Zeiten)
          2. Über Modbus und der Laufzeit "Saugen".

          zum Punkt 2.
          hier nutze ich eine Rg mit aus auf Erfahrung basierenden Annahmen (z.B. KG/ Minute Saugleistung, Nachlaufzeit, Vorlaufzeit etc)
          Hab den Code mal hier eingefügt

          //-----------------------------------------------------------------------------------------------------
          // Routine Oekofen // Oekofen von Saugen zu pelletverbrauch
          //    Funktion zur Verbrauchsert ermittlung  Pelletverbrauch Oekofen
          //    Vorgabewerte sind anzupassen
          //    function - die individualfunktion
          //    nummer die aktuelle bearbeitete Gruppe
          //    runtime = Wert zur weiteren Verarbeitung z.B. Millisekunden
          //-----------------------------------------------------------------------------------------------------
          function individual(funktion,nummer,runtime)  {
          
          log("funktion individual aufgerufen","info");
          
             if(funktion === "OEKOFEN") {
          
                 // Werte zum Einstellen--------------------------------------------------------
                 var vorgpause = 6;                                                              // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen
                 var vorgintervall = 54;                                                         // laenge eines einzelnen Intervalls
                 var vorgvorlauf = 32;                                                           // Saugzeit bevor die Schnecke läuft (Vakuum bilden)
                 var vorgnachlauf = 15;                                                          // Laufzeit des Saugers nach stopp der schnecke
                 var vorgverbrauch = 8;                                                        // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft
                 //----------------------------------------------------------------------------
                 log("funktion Oekofen aufgerufen - Runtime ist "+runtime,"info");       
                 
                 // Allgemeine Variablen
                 var anzlaeufe = 0;
                 var anzpausen = 0;
                 var totpausen = 0;
                 var restlaufzeit = 0;
                 var net1runtime;
                 var verbrauch;
                 var schneckenzeit;
                 
                 runtime = runtime / 1000;                                                           // Laufzeit in Sekunden
                 
                 // Berechne Anzahl Läufe und Pausen
                 net1runtime = runtime - vorgvorlauf - vorgnachlauf;
                 anzlaeufe = Math.floor(net1runtime / vorgintervall);
                 anzpausen = anzlaeufe-1;
                 
                 //theoretische Restlaufzeit berechnen
                 restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                 
                 //Korrektur anzahl laeufe und pausen falls notwendig
                 if (restlaufzeit + vorgpause < 0 )                                                  //Grenzfall wenn die Restzeit kleiner als null ist, dann muss anzahl läufe angepasst werden
                   {  anzlaeufe =anzlaeufe - 1;
                      anzpausen = anzpausen - 1;
                      restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                   }
                   
                 // Verbrauch berechnen 
                 // schneckenzeit = runtime - vorgvorlauf - vorgnachlauf  - (anzpausen * vorgpause);    // alte Routine bis Dezember mit Intervallen reine Schneckenlaufzeit berechnen
          
                 schneckenzeit = runtime - vorgvorlauf - vorgnachlauf;                                    // im Dezember neue Steuerung es gibt keine Intervalle mehr
                 verbrauch = schneckenzeit * vorgverbrauch/60 ; // Pelletverbrauch berechnen
          
                 if(verbrauch < 0) {                                                                 //Wenn die Zeit zu kurz ist können Minuswerte herauskommen
                     verbrauch = 0;
                 }
                 return verbrauch;
             
             } // endif Oekofen
          
          

          Nach dem ich schon seit Jahren 1 und 2 vergleiche kann ich sagen, dass beides gut funktioniert

          @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

          Wie viel Pellets brauchst du aktuell am Tag

          das ist denke ich nicht vergleichbar mit deiner Situation, da mein Haus weit entfernt von Standard ist.
          Heisst ich brauche über den Durchschnitt. aber aus dem Coding oben kannst du meine Annahmen übernehmen und für
          dich selbst anwenden

          vG Looxer

          O Offline
          O Offline
          OliWit82
          schrieb am zuletzt editiert von
          #38

          @looxer01

          Hallo Vielen Dank.

          Also du gehst davon aus das die Schnecke ca. 8kg in der Minute fördert?!?

          Der komplette Saugvorgang dauert bei mir ca 4 Minuten. Das script sagt mir ich hätte dann ca 11kg Pellets verbraucht. Irgendwas passt da aber nicht.

          LG Oliver

          L 1 Antwort Letzte Antwort
          0
          • O OliWit82

            @looxer01

            Hallo Vielen Dank.

            Also du gehst davon aus das die Schnecke ca. 8kg in der Minute fördert?!?

            Der komplette Saugvorgang dauert bei mir ca 4 Minuten. Das script sagt mir ich hätte dann ca 11kg Pellets verbraucht. Irgendwas passt da aber nicht.

            LG Oliver

            L Offline
            L Offline
            looxer01
            schrieb am zuletzt editiert von
            #39

            @oliwit82
            Hi,

            @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

            Also du gehst davon aus das die Schnecke ca. 8kg in der Minute fördert?!?

            das ist bei mir so. Hängt natülich von der verbauten Schnecke ab. Aber so in dem Dreh bewegt sich das

            @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

            Der komplette Saugvorgang dauert bei mir ca 4 Minuten. Das script sagt mir ich hätte dann ca 11kg Pellets verbraucht. Irgendwas passt da aber nicht.

            hängt von deien Einstellungen ab. Mit den voreingestellten Einstellungen dürfte die Rg in etwa so aussehen
            4 Min = 240 Sek
            minus vorlauf = 240 - 32 = 208
            Minus Nachlauf = 208 - 15 = 193

            3 Intervalle = 54 *3 = 162 = 18 Sekuden pause = 193 - 18 175

            Nettolaufzeit = 175 sekunden also ca 24 kg.

            11 KG wäre also falsch.

            Die Routine funktioniert bei mir, allerdings habe ich das Intervallsaugen nicht mehr aktiviert.
            War aber mal aktiviert und da machten die errechneten Werte ebenfalls Sinn.

            Ich kann jetzt schwer sagen wo das Problem liegt. Wie sind denn deine Einstellwerte ?

            vG Looxer

            L 1 Antwort Letzte Antwort
            0
            • L looxer01

              @oliwit82
              Hi,

              @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

              Also du gehst davon aus das die Schnecke ca. 8kg in der Minute fördert?!?

              das ist bei mir so. Hängt natülich von der verbauten Schnecke ab. Aber so in dem Dreh bewegt sich das

              @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

              Der komplette Saugvorgang dauert bei mir ca 4 Minuten. Das script sagt mir ich hätte dann ca 11kg Pellets verbraucht. Irgendwas passt da aber nicht.

              hängt von deien Einstellungen ab. Mit den voreingestellten Einstellungen dürfte die Rg in etwa so aussehen
              4 Min = 240 Sek
              minus vorlauf = 240 - 32 = 208
              Minus Nachlauf = 208 - 15 = 193

              3 Intervalle = 54 *3 = 162 = 18 Sekuden pause = 193 - 18 175

              Nettolaufzeit = 175 sekunden also ca 24 kg.

              11 KG wäre also falsch.

              Die Routine funktioniert bei mir, allerdings habe ich das Intervallsaugen nicht mehr aktiviert.
              War aber mal aktiviert und da machten die errechneten Werte ebenfalls Sinn.

              Ich kann jetzt schwer sagen wo das Problem liegt. Wie sind denn deine Einstellwerte ?

              vG Looxer

              L Offline
              L Offline
              looxer01
              schrieb am zuletzt editiert von
              #40

              Hi,

              Ich habe die Routine genommen und mit 240 sekunden laufen lassen. Ergebnis ist 25 kg.
              Läuft also. Das Script mit der Routine ist beigefügt.

              vG Looxer

              var Verbr = individual("OEKOFEN",240000)
              log ("Pelletverbrauch ist "+ Verbr,"info")
              
              
              //-----------------------------------------------------------------------------------------------------
              
              // Routine Oekofen // Oekofen von Saugen zu pelletverbrauch
              //    Funktion zur Verbrauchsert ermittlung  Pelletverbrauch Oekofen
              //    Vorgabewerte sind anzupassen
              //    function - die individualfunktion
              //    nummer die aktuelle bearbeitete Gruppe
              //    runtime = Wert zur weiteren Verarbeitung z.B. Millisekunden
              //-----------------------------------------------------------------------------------------------------
              
              function individual(funktion,runtime)  {
              
              log("funktion individual aufgerufen","info");
              
                  if(funktion === "OEKOFEN") {
              
                      // Werte zum Einstellen--------------------------------------------------------
                     var vorgpause = 6;                                                              // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen
                     var vorgintervall = 54;                                                         // laenge eines einzelnen Intervalls
                     var vorgvorlauf = 32;                                                           // Saugzeit bevor die Schnecke läuft (Vakuum bilden)
                     var vorgnachlauf = 15;                                                          // Laufzeit des Saugers nach stopp der schnecke
                     var vorgverbrauch = 8;                                                        // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft
                     //----------------------------------------------------------------------------
                     log("funktion Oekofen aufgerufen - Runtime ist "+runtime,"info");       
                  
                     // Allgemeine Variablen
                     var anzlaeufe = 0;
                     var anzpausen = 0;
                     var restlaufzeit = 0;
                     var net1runtime;
                     var verbrauch;
                     var schneckenzeit;
              
                            runtime = runtime / 1000;                                                           // Laufzeit in Sekunden
              
                     
                     // Berechne Anzahl Läufe und Pausen
                     net1runtime = runtime - vorgvorlauf - vorgnachlauf;
                     anzlaeufe = Math.floor(net1runtime / vorgintervall);
                     anzpausen = anzlaeufe-1;
              
                            //theoretische Restlaufzeit berechnen
                     restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                     
                     //Korrektur anzahl laeufe und pausen falls notwendig
                     if (restlaufzeit + vorgpause < 0 )                                                  //Grenzfall wenn die Restzeit kleiner als null ist, dann muss anzahl läufe angepasst werden
                       {  anzlaeufe =anzlaeufe - 1;
                          anzpausen = anzpausen - 1;
                          restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
              
                       }
                     
                     // Verbrauch berechnen 
                     // schneckenzeit = runtime - vorgvorlauf - vorgnachlauf  - (anzpausen * vorgpause);    // alte Routine bis Dezember mit Intervallen reine Schneckenlaufzeit berechnen
                     schneckenzeit = runtime - vorgvorlauf - vorgnachlauf;                                    // im Dezember neue Steuerung es gibt keine Intervalle mehr
                     verbrauch = schneckenzeit * vorgverbrauch/60 ; // Pelletverbrauch berechnen
              
              log("runtime "+ runtime)
              
                      if(verbrauch < 0) {                                                                 //Wenn die Zeit zu kurz ist können Minuswerte herauskommen
                         verbrauch = 0;
                     }
                     return verbrauch;
                 
                 } // endif Oekofen
              
              }
              
               
              

              O 1 Antwort Letzte Antwort
              0
              • L looxer01

                Hi,

                Ich habe die Routine genommen und mit 240 sekunden laufen lassen. Ergebnis ist 25 kg.
                Läuft also. Das Script mit der Routine ist beigefügt.

                vG Looxer

                var Verbr = individual("OEKOFEN",240000)
                log ("Pelletverbrauch ist "+ Verbr,"info")
                
                
                //-----------------------------------------------------------------------------------------------------
                
                // Routine Oekofen // Oekofen von Saugen zu pelletverbrauch
                //    Funktion zur Verbrauchsert ermittlung  Pelletverbrauch Oekofen
                //    Vorgabewerte sind anzupassen
                //    function - die individualfunktion
                //    nummer die aktuelle bearbeitete Gruppe
                //    runtime = Wert zur weiteren Verarbeitung z.B. Millisekunden
                //-----------------------------------------------------------------------------------------------------
                
                function individual(funktion,runtime)  {
                
                log("funktion individual aufgerufen","info");
                
                    if(funktion === "OEKOFEN") {
                
                        // Werte zum Einstellen--------------------------------------------------------
                       var vorgpause = 6;                                                              // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen
                       var vorgintervall = 54;                                                         // laenge eines einzelnen Intervalls
                       var vorgvorlauf = 32;                                                           // Saugzeit bevor die Schnecke läuft (Vakuum bilden)
                       var vorgnachlauf = 15;                                                          // Laufzeit des Saugers nach stopp der schnecke
                       var vorgverbrauch = 8;                                                        // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft
                       //----------------------------------------------------------------------------
                       log("funktion Oekofen aufgerufen - Runtime ist "+runtime,"info");       
                    
                       // Allgemeine Variablen
                       var anzlaeufe = 0;
                       var anzpausen = 0;
                       var restlaufzeit = 0;
                       var net1runtime;
                       var verbrauch;
                       var schneckenzeit;
                
                              runtime = runtime / 1000;                                                           // Laufzeit in Sekunden
                
                       
                       // Berechne Anzahl Läufe und Pausen
                       net1runtime = runtime - vorgvorlauf - vorgnachlauf;
                       anzlaeufe = Math.floor(net1runtime / vorgintervall);
                       anzpausen = anzlaeufe-1;
                
                              //theoretische Restlaufzeit berechnen
                       restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                       
                       //Korrektur anzahl laeufe und pausen falls notwendig
                       if (restlaufzeit + vorgpause < 0 )                                                  //Grenzfall wenn die Restzeit kleiner als null ist, dann muss anzahl läufe angepasst werden
                         {  anzlaeufe =anzlaeufe - 1;
                            anzpausen = anzpausen - 1;
                            restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                
                         }
                       
                       // Verbrauch berechnen 
                       // schneckenzeit = runtime - vorgvorlauf - vorgnachlauf  - (anzpausen * vorgpause);    // alte Routine bis Dezember mit Intervallen reine Schneckenlaufzeit berechnen
                       schneckenzeit = runtime - vorgvorlauf - vorgnachlauf;                                    // im Dezember neue Steuerung es gibt keine Intervalle mehr
                       verbrauch = schneckenzeit * vorgverbrauch/60 ; // Pelletverbrauch berechnen
                
                log("runtime "+ runtime)
                
                        if(verbrauch < 0) {                                                                 //Wenn die Zeit zu kurz ist können Minuswerte herauskommen
                           verbrauch = 0;
                       }
                       return verbrauch;
                   
                   } // endif Oekofen
                
                }
                
                 
                

                O Offline
                O Offline
                OliWit82
                schrieb am zuletzt editiert von OliWit82
                #41

                @looxer01

                Guten Morgen Looxer01

                vielen Dank.

                Ich stehe grad etwas auf dem Schlauch und weiss nicht was ich machen muss, bzw. wo ich das an der richtigen Stelle einfügen soll.

                Hab dir mal mein aktuelles Script angehangen. Vielleicht wärst du so nett und könntest mir das bitte ändern, Vielen Dank

                // Script erzeugt ein Log zur weiteren Verarbeitung in Excel.
                
                // Okeofen Status wird geschrieben mit Status und Status Anfangszeit und Status Endezeit (laufzeit je Status)
                
                // Pelletverbrauch wird berechnet
                
                 
                
                createState('Heizung.Pellematic.Berechnung.lastStatus', "  ") ; // letzter Status 
                
                createState('Heizung.Pellematic.Berechnung.lastStatusTime', "        ") ; // Zeit, die beim letzten Status gespeichert wurde
                
                createState('Heizung.Pellematic.Berechnung.lastStatusDate',"        ") ; // Datum, das beim letzten Status gespeichert wurde
                
                createState('Heizung.Pellematic.Berechnung.lastSec',0) ; // time in seconds, das beim letzten Status gespeichert wurde
                
                createState('Heizung.Pellematic.Berechnung.lastSec',0) ; // time in seconds, das beim letzten Status gespeichert wurde
                
                createState('Heizung.Pellematic.Berechnung.CumStatStart',0) ; // Kumulierte Zeit - Status Start
                
                createState('Heizung.Pellematic.Berechnung.CumStatZuend',0) ; // Kumulierte Zeit - Status Zuendung
                
                createState('Heizung.Pellematic.Berechnung.CumStatSoftstart',0) ; // Kumulierte Zeit - Status Softstart
                
                createState('Heizung.Pellematic.Berechnung.CumStatLeistung',0) ; // Kumulierte Zeit - Status Leistungsbrand
                
                createState('Heizung.Pellematic.Berechnung.CumStatNachlauf',0) ; // Kumulierte Zeit - Status Nachlauf
                
                createState('Heizung.Pellematic.Berechnung.CumStatSaugen',0) ; // Kumulierte Zeit - Status Saugen
                
                createState('Heizung.Pellematic.Berechnung.CumStatIdle',0) ; // Kumulierte Zeit - Status Idle
                
                createState('Heizung.Pellematic.Berechnung.KumStart',"00:00:00:00") ; // Kumulierte Zeit Zeitformat dd:hh:hh:ss
                
                createState('Heizung.Pellematic.Berechnung.KumZuend',"00:00:00:00") ; // Kumulierte Zeit Zeitformat dd:hh:hh:ss
                
                createState('Heizung.Pellematic.Berechnung.KumSoftstart',"00:00:00:00") ; // Kumulierte Zeit Zeitformat dd:hh:hh:ss
                
                createState('Heizung.Pellematic.Berechnung.KumLeistungsbrand',"00:00:00:00") ; // Kumulierte Zeit Zeitformat dd:hh:hh:ss
                
                createState('Heizung.Pellematic.Berechnung.KumNachlauf',"00:00:00:00") ; // Kumulierte Zeit Zeitformat dd:hh:hh:ss
                
                createState('Heizung.Pellematic.Berechnung.KumSaugen',"00:00:00:00") ; // Kumulierte Zeit Zeitformat dd:hh:hh:ss
                
                createState('Heizung.Pellematic.Berechnung.KumIdle',"00:00:00:00") ; // Kumulierte Zeit Zeitformat dd:hh:hh:ss
                
                createState('Heizung.Pellematic.Berechnung.KumEnergy', 0) ; //kumuliert den Energieverbrauch - hier in kg pellet
                
                createState('Heizung.Pellematic.Berechnung.lastEnergy',0) ; //letzter Energieverbrauch - hier in kg pellet
                
                createState('Heizung.Pellematic.Berechnung.RestEnergy',0) ; //Restenergie im Speicher / Pelletbunker
                
                createState('Heizung.Pellematic.Berechnung.Saugen.Sekunde', 0)
                
                createState('Heizung.Pellematic.Berechnung.Saugen.Minute', 0)
                
                createState('Heizung.Pellematic.Berechnung.Saugen.Stunde',0)
                
                createState('Heizung.Pellematic.Berechnung.Saugen.Gesamt',0)
                
                createState('Heizung.Pellematic.Berechnung.Saugen.Gestern',0)
                
                 
                
                var fs = require('fs');                           // enable write
                
                 
                
                // EVENT: Status der Oekofen Anlage hat sich gändert
                
                // Logik: Lese letzte Zeit und errechne different - schreibe aktuelle Zeit in letzte Zeit und erzeuge einen Eintrag in der CSV Datei
                
                on({id: "javascript.0.Heizung.Pellematic.Ofen.Statuszahl", valNe: 1000 }, function(obj)      // Event:  wenn Status gewechselt
                
                {
                
                 
                
                var currStat = getState("javascript.0.Heizung.Pellematic.Ofen.Statuszahl").val;    // Lese aktuellen Status
                
                var lastStat = getState("javascript.0.Heizung.Pellematic.Berechnung.lastStatus").val;           // Lese letzten Status
                
                var lastDate = getState("javascript.0.Heizung.Pellematic.Berechnung.lastStatusDate").val;      // Lese letztes  Status Datum
                
                var lastTime = getState("javascript.0.Heizung.Pellematic.Berechnung.lastStatusTime").val;      // Lese letzte Status Zeit
                
                var lastSec  = getState("javascript.0.Heizung.Pellematic.Berechnung.lastSec").val;      // Lese letzte Status Zeit in Sekunden
                
                var cumStart  = getState("javascript.0.Heizung.Pellematic.Berechnung.CumStatStart").val;      // Lese letzte cum Status Start
                
                var cumZuend  = getState("javascript.0.Heizung.Pellematic.Berechnung.CumStatZuend").val;      // Lese letzte cum Status Zuendung
                
                var cumSoft  = getState("javascript.0.Heizung.Pellematic.Berechnung.CumStatSoftstart").val;      // Lese letzte cum Status Softstart
                
                var cumLeist  = getState("javascript.0.Heizung.Pellematic.Berechnung.CumStatLeistung").val;      // Lese letzte cum Status Leistugnsbrand
                
                var cumNach  = getState("javascript.0.Heizung.Pellematic.Berechnung.CumStatNachlauf").val;      // Lese letzte cum Status Nachlauf
                
                var cumSaug  = getState("javascript.0.Heizung.Pellematic.Berechnung.CumStatSaugen").val;      // Lese letzte cum Status Saugen
                
                var cumIdle  = getState("javascript.0.Heizung.Pellematic.Berechnung.CumStatIdle").val;      // Lese letzte cum Status Idle
                
                var cumEnergy  = getState("javascript.0.Heizung.Pellematic.Berechnung.KumEnergy").val;      // Lese letzte cum Status Idle
                
                var RestSpeicher  = getState("javascript.0.Heizung.Pellematic.Berechnung.RestEnergy").val;      // Lese letzte cum Status Idle
                
                 
                
                // Energieverbrauch - Pelletverbrauch in KG für den Saugvorgang
                
                var energieverbr = 0;
                
                var schnecke = 0; // Netto Schneckenlaufzeit
                
                 
                
                // Zerlege Datum und Zeit in Variable
                
                var now =    new Date(); // store current date and time
                
                var year =   now.getFullYear();
                
                var month =  addZero(now.getMonth()+1);
                
                var day =    addZero(now.getDate());
                
                var Thour =  addZero(now.getHours());
                
                var Tmin =   addZero(now.getMinutes());
                
                var Tsec =   addZero(now.getSeconds());
                
                var currSec =   now.getTime(); // millisekunden seit 01.01.1970
                
                var currDate = day + '.' + month + '.' + year;
                
                var currTime = Thour + ':' + Tmin + ':' + Tsec;
                
                var string = "not defined";
                
                var FormTime = "00:00:00:00"; // formatierte Betriebszeit
                
                 
                
                // Zeitdifferenz in millisekunden 
                
                var timeconsumed = currSec - lastSec;  // Zeitdifferenz in Millisekunden
                
                 
                
                //ordne klarText für current  Status zu
                
                 
                
                var statusCurrText = "not defined";
                
                 if (currStat == "1") {
                
                        statusCurrText = "Start";
                
                    }
                
                 if (currStat == "2") {
                
                        statusCurrText = "Zuendung";
                
                    }
                
                 if (currStat == "3") {
                
                        statusCurrText = "SoftStart";
                
                    }
                
                 if (currStat == "4") {
                
                        statusCurrText = "Leistungsbrand";
                
                    }
                
                 if (currStat == "5") {
                
                        statusCurrText = "Nachlauf";
                
                    }
                
                 if (currStat == "7") {
                
                        statusCurrText = "Saugen";
                
                    }
                
                 if (currStat == "99") {
                
                        statusCurrText = "Idle";
                
                    }
                
                 
                
                // assign text to status for last  Status und berechne kumulierte Werte je Status in Millisekunden
                
                var statusLastText = "not defined";
                
                 if (lastStat == "1") {
                
                        statusLastText = "Start";
                
                        cumStart = cumStart + timeconsumed;
                
                    }
                
                 if (lastStat == "2") {
                
                        statusLastText = "Zuendung";
                
                        cumZuend = cumZuend + timeconsumed;
                
                    }
                
                 if (lastStat == "3") {
                
                        statusLastText = "SoftStart";
                
                        cumSoft = cumSoft + timeconsumed;
                
                    }
                
                 if (lastStat == "4") {
                
                        statusLastText = "Leistungsbrand";
                
                        cumLeist = cumLeist + timeconsumed;
                
                    }
                
                 if (lastStat == "5") {
                
                        statusLastText = "Nachlauf";
                
                        cumNach = cumNach + timeconsumed;
                
                    }
                
                 if (lastStat == "7") {
                
                        statusLastText = "Saugen";
                
                        cumSaug = cumSaug + timeconsumed;   // kumulierte Saugzeit
                
                        var uebergabe = new Array(timeconsumed, energieverbr, schnecke);
                
                        EnergieRg(uebergabe); // Berechne Energieverbrauch
                
                        energieverbr =  uebergabe[1]; // berechneter Energieverbrauch
                
                        schnecke =  uebergabe[2];     // Berechnete Schneckenzeit
                
                        cumEnergy =  cumEnergy + energieverbr; // kumulierter Energieverbrauch
                
                        RestSpeicher = RestSpeicher - energieverbr;        // Restmenge im Vorratslager 
                
                    }
                
                 if (lastStat == "99") {
                
                        statusLastText = "Idle";
                
                        cumIdle = cumIdle + timeconsumed;
                
                    }    
                
                 
                
                // Berechne Zeitformat von millisekunden in dd:hh:mm:ss
                
                FormTime = TimeCalc(FormTime,timeconsumed);
                
                 
                
                // Umwandlung von javascript float in 2 decimals mit Komma für die Logausgabe lesbar in Excel
                
                energieverbr = TauschePunktKomma(energieverbr.toFixed(2));
                
                schnecke = TauschePunktKomma(schnecke.toFixed(2));
                
                 
                
                // erzeuge Excel String
                
                    string = "H" +";" + lastStat + ";" + statusLastText + ";" +  lastDate + ";"  + lastTime + ";" + currStat + ";"  + statusCurrText + ";" + currDate + ";" + currTime + ";" + timeconsumed +";" + FormTime + ";" + energieverbr + ";" + schnecke + "\n";
                
                 
                
                    // merke (schreibe) current Status Datum und Zeit in Last
                
                    setState("javascript.0.Heizung.Pellematic.Berechnung.lastStatus",currStat);
                
                    setState("javascript.0.Heizung.Pellematic.Berechnung.lastStatusDate",currDate);
                
                    setState("javascript.0.Heizung.Pellematic.Berechnung.lastStatusTime",currTime);
                
                    setState("javascript.0.Heizung.Pellematic.Berechnung.lastSec",currSec);
                
                    // merke (schreibe) kumulierte Werte in millisekunden
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.CumStatStart",cumStart);   
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.CumStatZuend",cumZuend);   
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.CumStatSoftstart",cumSoft);   
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.CumStatLeistung",cumLeist);   
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.CumStatNachlauf",cumNach);   
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.CumStatSaugen",cumSaug);   
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.CumStatIdle",cumIdle);   
                
                    // merke (schreibe) Energieverbrauch   
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.KumEnergy",cumEnergy);  
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.lastEnergy",energieverbr);   
                
                     setState("javascript.0.Heizung.Pellematic.Berechnung.RestEnergy",RestSpeicher);   
                
                 
                
                // merke (schreibe) kumulierte Werte in format dd:hh:mm:ss
                
                timeconsumed  = cumStart;      //  letzter cum Status Start
                
                FormTime = TimeCalc(FormTime,timeconsumed); // Berechne Zeitformat von millisekunden in dd:hh:mm:ss
                
                setState("javascript.0.Heizung.Pellematic.Berechnung.KumStart",FormTime);  // Schreibe Zeitformat in variable
                
                 
                
                timeconsumed  = cumZuend;      //  letzter cum Status Zuendung
                
                FormTime = TimeCalc(FormTime,timeconsumed); // Berechne Zeitformat von millisekunden in dd:hh:mm:ss
                
                setState("javascript.0.Heizung.Pellematic.Berechnung.KumZuend",FormTime);  
                
                 
                
                timeconsumed  = cumSoft;      //  letzter cum Status softstart
                
                FormTime = TimeCalc(FormTime,timeconsumed); // Berechne Zeitformat von millisekunden in dd:hh:mm:ss
                
                setState("javascript.0.Heizung.Pellematic.Berechnung.KumSoftstart",FormTime);  
                
                 
                
                timeconsumed  = cumLeist;      //  letzter cum Status Leistungsbrand
                
                FormTime = TimeCalc(FormTime,timeconsumed); // Berechne Zeitformat von millisekunden in dd:hh:mm:ss
                
                setState("javascript.0.Heizung.Pellematic.Berechnung.KumLeistungsbrand",FormTime);  
                
                 
                
                timeconsumed  = cumNach;      //  letzter cum Status Nachlauf
                
                FormTime = TimeCalc(FormTime,timeconsumed); // Berechne Zeitformat von millisekunden in dd:hh:mm:ss
                
                setState("javascript.0.Heizung.Pellematic.Berechnung.KumNachlauf",FormTime);  
                
                 
                
                timeconsumed  = cumSaug;      //  letzter cum Status Saugen
                
                FormTime = TimeCalc(FormTime,timeconsumed); // Berechne Zeitformat von millisekunden in dd:hh:mm:ss
                
                setState("javascript.0.Heizung.Pellematic.Berechnung.KumSaugen",FormTime);  
                
                 
                
                timeconsumed  = cumIdle;      //  letzter cum Status Saugen
                
                FormTime = TimeCalc(FormTime,timeconsumed); // Berechne Zeitformat von millisekunden in dd:hh:mm:ss
                
                setState("javascript.0.Heizung.Pellematic.Berechnung.KumIdle",FormTime);  
                 
                
                // erzeuge Logeintrag
                
                log("EVENT Heizung2 Status geaendert - jetzt :" + currStat  + " " + statusCurrText + " " + "Laufzeit :" + FormTime, "info"); 
                
                 
                
                });
                
                 
                
                // Funktion zur Erzeugung von führenden Nullen für das Datum Format
                
                function addZero(i) {
                
                    if (i < 10) {
                
                        i = "0" + i;
                
                    }
                
                    return i;
                
                }
                
                 
                
                function TimeCalc(time,diff) {
                
                // Millisekunden umrechnen in Tag Stunden Minuten Sekunden
                
                // var diff = timeconsumed;
                
                var tag = addZero(Math.floor(diff / (1000*60*60*24)));
                
                diff = diff % (1000*60*60*24);
                
                var std = addZero(Math.floor(diff / (1000*60*60)));
                
                diff = diff % (1000*60*60);
                
                var min =  addZero(Math.floor(diff / (1000*60)));
                
                diff = diff % (1000*60);
                
                var sec = addZero(Math.floor(diff / 1000));
                
                time =  tag + ":" + std + ":" + min + ":" + sec; // jetzt dd:hh:mm:ss zusammensetzen
                
                return time;
                
                 
                
                }
                
                 
                
                function EnergieRg(uebergabe) 
                
                {
                
                //    Funktion zur Verbrauchsert ermittlung - hier Pelletverbrauch
                
                //    Vorgabewerte sind anzupassen
                
                var vorgpause = 6; // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen
                
                var vorgintervall = 55; // laenge eines einzelnen Intervalls
                
                var vorgvorlauf = 32;  // Saugzeit bevor die Schnecke läuft (Vakuum bilden)
                
                var vorgnachlauf = 16; // Laufzeit des Saugers nach stopp der schnecke
                
                var vorgverbrauch = 10;  // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft
                
                var runtime = uebergabe[0];  
                
                var verbrauch = uebergabe[1];
                
                var schneckenzeit = uebergabe[2];
                
                 
                
                // Allgemeine Variablen
                
                var anzlaeufe = 0;
                
                var anzpausen = 0;
                
                var totpausen = 0;
                
                var restlaufzeit = 0;
                
                 
                
                runtime = runtime / 1000; // Laufzeit in Sekunden
                
                 
                
                // Berechne Anzahl Läufe und Pausen
                
                var net1runtime = runtime - vorgvorlauf - vorgnachlauf;
                
                anzlaeufe = Math.floor(net1runtime / vorgintervall);
                
                anzpausen = anzlaeufe-1;
                
                 
                
                //theoretische Restlaufzeit berechnen
                
                restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                
                 
                
                //Korrektur anzahl laeufe und pausen falls notwendig
                
                if (restlaufzeit + vorgpause < 0 )  //Grenzfall wenn die Restzeit kleiner als null ist, dann muss anzahl läufe angepasst werden
                
                  {  anzlaeufe =anzlaeufe - 1;
                
                     anzpausen = anzpausen - 1;
                
                     restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                
                  }
                
                 
                
                // Verbrauch berechnen 
                
                schneckenzeit = runtime - vorgvorlauf - vorgnachlauf  - (anzpausen * vorgpause); // reine Schneckenlaufzeit berechnen
                
                verbrauch = schneckenzeit * vorgverbrauch/60 ; // Pelletverbrauch berechnen
                
                 
                
                // erzeuge Logeintrag
                
                log("Energieverbrauchsrechnung Intervall :" + vorgintervall, "info"); 
                
                log("Energieverbrauchsrechnung Pause :" + vorgpause, "info"); 
                
                log("Energieverbrauchsrechnung Vorlauf :" + vorgvorlauf, "info"); 
                
                log("Energieverbrauchsrechnung Nachlauf:" + vorgnachlauf, "info"); 
                
                log("Energieverbrauchsrechnung KG/MIN:" + vorgverbrauch, "info"); 
                
                log("Energieverbrauchsrechnung gesamte runtime:" + runtime, "info"); 
                
                log("Energieverbrauchsrechnung Runtime minus Vor-Nachlaufzeit:" + net1runtime, "info"); 
                
                log("Energieverbrauchsrechnung Anzahl Laeufe:" + anzlaeufe, "info"); 
                
                log("Energieverbrauchsrechnung Anzahl Pausen:" + anzpausen, "info"); 
                
                log("Energieverbrauchsrechnung Schneckenzeit:" + schneckenzeit, "info"); 
                
                log("Energieverbrauchsrechnung restlaufzeit:" + restlaufzeit, "info"); 
                
                log("Energieverbrauchsrechnung Verbrauch berechnet:" + verbrauch, "info"); 
                
                 
                
                uebergabe[1] = verbrauch;
                
                uebergabe[2] = schneckenzeit;
                
                return (uebergabe);
                
                }
                
                 
                
                // Funktion zur Umwandlung in Zahlen mit Komma statt Punkt (excel)
                
                function TauschePunktKomma(x) {
                
                var TextAusgabe  = x.toString();
                
                TextAusgabe  = TextAusgabe .replace(".",",");
                
                return TextAusgabe ;
                
                }
                
                 
                
                

                Wichtig für mich sind die 2 Funktionen

                // Okeofen Status wird geschrieben mit Status und Status Anfangszeit und Status Endezeit (laufzeit je Status)

                // Pelletverbrauch wird berechnet

                Gruss Oliver

                1 Antwort Letzte Antwort
                0
                • L Offline
                  L Offline
                  looxer01
                  schrieb am zuletzt editiert von
                  #42

                  @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

                  Hi,
                  bei der Verbrauchsrechnung hast du beim return das coding " return (uebergabe)"
                  versuche es mit "return uebergabe" -- also ohne klammer

                  Wenn du die timeconsume übergibst dann muss dass in Millisekunden sein. Ich bekomme bei deinen Variablen
                  und bei 4 Minuten Laufzeit der Schnecke einen verbrauch von 30 KG.

                  vG Looxer

                  O 1 Antwort Letzte Antwort
                  0
                  • L looxer01

                    @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

                    Hi,
                    bei der Verbrauchsrechnung hast du beim return das coding " return (uebergabe)"
                    versuche es mit "return uebergabe" -- also ohne klammer

                    Wenn du die timeconsume übergibst dann muss dass in Millisekunden sein. Ich bekomme bei deinen Variablen
                    und bei 4 Minuten Laufzeit der Schnecke einen verbrauch von 30 KG.

                    vG Looxer

                    O Offline
                    O Offline
                    OliWit82
                    schrieb am zuletzt editiert von
                    #43

                    @looxer01 said in Ökofen Pelletronic Touch auslesen:

                    return

                    Hallo
                    danke ich teste

                    VG

                    O 1 Antwort Letzte Antwort
                    0
                    • O OliWit82

                      @looxer01 said in Ökofen Pelletronic Touch auslesen:

                      return

                      Hallo
                      danke ich teste

                      VG

                      O Offline
                      O Offline
                      OliWit82
                      schrieb am zuletzt editiert von
                      #44

                      @looxer01

                      Wieder nur 9 kg

                      Die Anlage lief 3:32 min

                      Hast du noch eine Idee?

                      VG

                      L 1 Antwort Letzte Antwort
                      0
                      • O OliWit82

                        @looxer01

                        Wieder nur 9 kg

                        Die Anlage lief 3:32 min

                        Hast du noch eine Idee?

                        VG

                        L Offline
                        L Offline
                        looxer01
                        schrieb am zuletzt editiert von
                        #45

                        @oliwit82
                        Hi,
                        hast du mal nachgesehen was du an die Rechenroutine übergibst.
                        in uebergabe[0] sollte in diesem Fall ja 21200 Millisekunden (3:32) übergeben werden.
                        Die Routine kannst du ja isoliert vom Rest testen. (bei 212000 millisekunen erhalte ich 26 kg)

                        siehe hier:

                        var timeconsumed = 212000
                        var energieverbr = 0
                        var schnecke = 0
                        
                        var uebergabe = new Array(timeconsumed, energieverbr, schnecke);
                        EnergieRg(uebergabe); // Berechne Energieverbrauch
                        
                        function EnergieRg(uebergabe)
                        {
                        
                        
                        //    Funktion zur Verbrauchsert ermittlung - hier Pelletverbrauch
                        //    Vorgabewerte sind anzupassen
                        var vorgpause = 6; // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen
                        var vorgintervall = 55; // laenge eines einzelnen Intervalls
                        var vorgvorlauf = 32;  // Saugzeit bevor die Schnecke läuft (Vakuum bilden)
                        var vorgnachlauf = 16; // Laufzeit des Saugers nach stopp der schnecke
                        var vorgverbrauch = 10;  // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft
                        var runtime = uebergabe[0];  
                        var verbrauch = uebergabe[1];
                        var schneckenzeit = uebergabe[2];
                        // Allgemeine Variablen
                        var anzlaeufe = 0;
                        var anzpausen = 0;
                        var totpausen = 0;
                        var restlaufzeit = 0;
                        runtime = runtime / 1000; // Laufzeit in Sekunden
                        // Berechne Anzahl Läufe und Pausen
                        var net1runtime = runtime - vorgvorlauf - vorgnachlauf;
                        anzlaeufe = Math.floor(net1runtime / vorgintervall);
                        anzpausen = anzlaeufe-1;
                        //theoretische Restlaufzeit berechnen
                        restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                        //Korrektur anzahl laeufe und pausen falls notwendig
                        if (restlaufzeit + vorgpause < 0 )  //Grenzfall wenn die Restzeit kleiner als null ist, dann muss anzahl läufe angepasst werden
                         {  anzlaeufe =anzlaeufe - 1;
                            anzpausen = anzpausen - 1;
                            restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                         }
                        // Verbrauch berechnen 
                        schneckenzeit = runtime - vorgvorlauf - vorgnachlauf  - (anzpausen * vorgpause); // reine Schneckenlaufzeit berechnen
                        verbrauch = schneckenzeit * vorgverbrauch/60 ; // Pelletverbrauch berechnen
                        
                        // erzeuge Logeintrag
                        log("Energieverbrauchsrechnung Intervall :" + vorgintervall, "info"); 
                        log("Energieverbrauchsrechnung Pause :" + vorgpause, "info"); 
                        log("Energieverbrauchsrechnung Vorlauf :" + vorgvorlauf, "info"); 
                        log("Energieverbrauchsrechnung Nachlauf:" + vorgnachlauf, "info"); 
                        log("Energieverbrauchsrechnung KG/MIN:" + vorgverbrauch, "info"); 
                        log("Energieverbrauchsrechnung gesamte runtime:" + runtime, "info"); 
                        log("Energieverbrauchsrechnung Runtime minus Vor-Nachlaufzeit:" + net1runtime, "info"); 
                        log("Energieverbrauchsrechnung Anzahl Laeufe:" + anzlaeufe, "info"); 
                        log("Energieverbrauchsrechnung Anzahl Pausen:" + anzpausen, "info"); 
                        log("Energieverbrauchsrechnung Schneckenzeit:" + schneckenzeit, "info"); 
                        log("Energieverbrauchsrechnung restlaufzeit:" + restlaufzeit, "info"); 
                        log("Energieverbrauchsrechnung Verbrauch berechnet:" + verbrauch, "info"); 
                        
                        
                        uebergabe[1] = verbrauch
                        uebergabe[2] = schnecke
                        
                        return uebergabe
                        
                        }
                        

                        O 1 Antwort Letzte Antwort
                        0
                        • L looxer01

                          @oliwit82
                          Hi,
                          hast du mal nachgesehen was du an die Rechenroutine übergibst.
                          in uebergabe[0] sollte in diesem Fall ja 21200 Millisekunden (3:32) übergeben werden.
                          Die Routine kannst du ja isoliert vom Rest testen. (bei 212000 millisekunen erhalte ich 26 kg)

                          siehe hier:

                          var timeconsumed = 212000
                          var energieverbr = 0
                          var schnecke = 0
                          
                          var uebergabe = new Array(timeconsumed, energieverbr, schnecke);
                          EnergieRg(uebergabe); // Berechne Energieverbrauch
                          
                          function EnergieRg(uebergabe)
                          {
                          
                          
                          //    Funktion zur Verbrauchsert ermittlung - hier Pelletverbrauch
                          //    Vorgabewerte sind anzupassen
                          var vorgpause = 6; // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen
                          var vorgintervall = 55; // laenge eines einzelnen Intervalls
                          var vorgvorlauf = 32;  // Saugzeit bevor die Schnecke läuft (Vakuum bilden)
                          var vorgnachlauf = 16; // Laufzeit des Saugers nach stopp der schnecke
                          var vorgverbrauch = 10;  // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft
                          var runtime = uebergabe[0];  
                          var verbrauch = uebergabe[1];
                          var schneckenzeit = uebergabe[2];
                          // Allgemeine Variablen
                          var anzlaeufe = 0;
                          var anzpausen = 0;
                          var totpausen = 0;
                          var restlaufzeit = 0;
                          runtime = runtime / 1000; // Laufzeit in Sekunden
                          // Berechne Anzahl Läufe und Pausen
                          var net1runtime = runtime - vorgvorlauf - vorgnachlauf;
                          anzlaeufe = Math.floor(net1runtime / vorgintervall);
                          anzpausen = anzlaeufe-1;
                          //theoretische Restlaufzeit berechnen
                          restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                          //Korrektur anzahl laeufe und pausen falls notwendig
                          if (restlaufzeit + vorgpause < 0 )  //Grenzfall wenn die Restzeit kleiner als null ist, dann muss anzahl läufe angepasst werden
                           {  anzlaeufe =anzlaeufe - 1;
                              anzpausen = anzpausen - 1;
                              restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) +  vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); 
                           }
                          // Verbrauch berechnen 
                          schneckenzeit = runtime - vorgvorlauf - vorgnachlauf  - (anzpausen * vorgpause); // reine Schneckenlaufzeit berechnen
                          verbrauch = schneckenzeit * vorgverbrauch/60 ; // Pelletverbrauch berechnen
                          
                          // erzeuge Logeintrag
                          log("Energieverbrauchsrechnung Intervall :" + vorgintervall, "info"); 
                          log("Energieverbrauchsrechnung Pause :" + vorgpause, "info"); 
                          log("Energieverbrauchsrechnung Vorlauf :" + vorgvorlauf, "info"); 
                          log("Energieverbrauchsrechnung Nachlauf:" + vorgnachlauf, "info"); 
                          log("Energieverbrauchsrechnung KG/MIN:" + vorgverbrauch, "info"); 
                          log("Energieverbrauchsrechnung gesamte runtime:" + runtime, "info"); 
                          log("Energieverbrauchsrechnung Runtime minus Vor-Nachlaufzeit:" + net1runtime, "info"); 
                          log("Energieverbrauchsrechnung Anzahl Laeufe:" + anzlaeufe, "info"); 
                          log("Energieverbrauchsrechnung Anzahl Pausen:" + anzpausen, "info"); 
                          log("Energieverbrauchsrechnung Schneckenzeit:" + schneckenzeit, "info"); 
                          log("Energieverbrauchsrechnung restlaufzeit:" + restlaufzeit, "info"); 
                          log("Energieverbrauchsrechnung Verbrauch berechnet:" + verbrauch, "info"); 
                          
                          
                          uebergabe[1] = verbrauch
                          uebergabe[2] = schnecke
                          
                          return uebergabe
                          
                          }
                          

                          O Offline
                          O Offline
                          OliWit82
                          schrieb am zuletzt editiert von
                          #46

                          @looxer01

                          Danke.

                          Wenn ich heute Abend aus Duisburg zurück bin schau ich mal rein.

                          Sieht man das nicht an dem Script was ich 3 Post weiter oben geschrieben habe.

                          VG

                          L 1 Antwort Letzte Antwort
                          0
                          • O OliWit82

                            @looxer01

                            Danke.

                            Wenn ich heute Abend aus Duisburg zurück bin schau ich mal rein.

                            Sieht man das nicht an dem Script was ich 3 Post weiter oben geschrieben habe.

                            VG

                            L Offline
                            L Offline
                            looxer01
                            schrieb am zuletzt editiert von
                            #47

                            @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

                            Sieht man das nicht an dem Script was ich 3 Post weiter oben geschrieben habe.

                            dazu muesstest du schon auch das log mit senden.
                            Ist halt eine etwas theoretische Uebung ohne quelldaten.

                            O 1 Antwort Letzte Antwort
                            0
                            • L looxer01

                              @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

                              Sieht man das nicht an dem Script was ich 3 Post weiter oben geschrieben habe.

                              dazu muesstest du schon auch das log mit senden.
                              Ist halt eine etwas theoretische Uebung ohne quelldaten.

                              O Offline
                              O Offline
                              OliWit82
                              schrieb am zuletzt editiert von
                              #48

                              @looxer01

                              Heizung.txt

                              Hier das was im Log steht, vielleicht kannst du damit was anfangen.
                              Danke

                              Gruss Oliver

                              L 1 Antwort Letzte Antwort
                              0
                              • O OliWit82

                                @looxer01

                                Heizung.txt

                                Hier das was im Log steht, vielleicht kannst du damit was anfangen.
                                Danke

                                Gruss Oliver

                                L Offline
                                L Offline
                                looxer01
                                schrieb am zuletzt editiert von looxer01
                                #49

                                @oliwit82
                                Hi,

                                nach dem Log hat die Funktion 59936 Millisekunden gesamte Laufzeit erhalten.
                                Die Routine hat damit einen Verbrauch von 2.989 kg errechnet und zurückgegeben.
                                Ich habe mir die Berechnungen nochmals angesehen und es gab ein Problem bei der Pausenberechnung
                                es hätten eigentlich nur 1.989 kg sein sollen. Habe ich korrigiert. (Routine habe ich dann etwas optimiert)

                                Hast du einen anderen Wert erwartet ?

                                Hast du denn überhaupt Intervallsaugen bei deiner Anlage eingeschaltet ?
                                Das heisst nach deinen Einstellungen, dass du nach einer Saugzeit von 55 Sekunden eine 6 sekunden Pause hast und dann geht es weiter mit 55 sekunden Saugen und so weiter

                                vG Looxer

                                var timeconsumed = 59936 //59936
                                var energieverbr = 0
                                var schnecke = 0
                                
                                
                                var uebergabe = new Array(timeconsumed, energieverbr, schnecke);
                                EnergieRg(uebergabe); // Berechne Energieverbrauch
                                
                                
                                //    Funktion zur Verbrauchsert ermittlung - hier Pelletverbrauch
                                //    Vorgabewerte sind anzupassen
                                //.................................................................
                                function EnergieRg(uebergabe) {
                                var vorgpause = 6; // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen
                                var vorgintervall = 55; // laenge eines einzelnen Intervalls
                                var vorgvorlauf = 32;  // Saugzeit bevor die Schnecke läuft (Vakuum bilden)
                                var vorgnachlauf = 16; // Laufzeit des Saugers nach stopp der schnecke
                                var vorgverbrauch = 10;  // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft
                                var runtime = uebergabe[0] / 1000;  
                                var verbrauch = uebergabe[1];
                                var schneckenzeit = uebergabe[2];
                                // Allgemeine Variablen
                                var anzlaeufe = 0;
                                var anzpausen = 0;
                                // Berechne Anzahl Läufe und Pausen
                                var net1runtime = runtime - vorgvorlauf - vorgnachlauf;
                                if (net1runtime < 0 ) {net1runtime = 0};
                                if ( net1runtime / vorgintervall >= 1) { 
                                   anzlaeufe = Math.floor(net1runtime / vorgintervall) + 1; 
                                   anzpausen = anzlaeufe - 1 ;
                                   log( " matthfloor "+Math.floor(net1runtime / vorgintervall) ) 
                                }
                                // Verbrauch berechnen 
                                if( runtime > vorgvorlauf + vorgnachlauf) {         
                                   schneckenzeit = runtime - vorgvorlauf - vorgnachlauf  - ( (anzpausen) * vorgpause); // reine Schneckenlaufzeit berechnen
                                   verbrauch = schneckenzeit * vorgverbrauch/60 ;                                      // Pelletverbrauch berechnen
                                   } else {                                                                             // die runtime ist kleiner als die vorund nachlaufzeit - darf nicht sein
                                   schneckenzeit = 0
                                   verbrauch = 0; 
                                   }
                                // erzeuge Logeintrag
                                log("Energieverbrauchsrechnung Intervall :" + vorgintervall, "info"); 
                                log("Energieverbrauchsrechnung Pause :" + vorgpause, "info"); 
                                log("Energieverbrauchsrechnung Vorlauf :" + vorgvorlauf, "info"); 
                                log("Energieverbrauchsrechnung Nachlauf:" + vorgnachlauf, "info"); 
                                log("Energieverbrauchsrechnung KG/MIN:" + vorgverbrauch, "info"); 
                                log("Energieverbrauchsrechnung gesamte runtime:" + runtime, "info"); 
                                log("Energieverbrauchsrechnung Runtime minus Vor-Nachlaufzeit:" + net1runtime, "info"); 
                                log("Energieverbrauchsrechnung Anzahl Laeufe:" + anzlaeufe, "info"); 
                                log("Energieverbrauchsrechnung Anzahl Pausen:" + anzpausen, "info"); 
                                log("Energieverbrauchsrechnung Schneckenzeit:" + schneckenzeit, "info"); 
                                log("Energieverbrauchsrechnung Verbrauch berechnet:" + verbrauch, "info"); 
                                
                                uebergabe[1] = verbrauch
                                uebergabe[2] = schneckenzeit
                                
                                return uebergabe
                                
                                }
                                

                                O 1 Antwort Letzte Antwort
                                0
                                • L looxer01

                                  @oliwit82
                                  Hi,

                                  nach dem Log hat die Funktion 59936 Millisekunden gesamte Laufzeit erhalten.
                                  Die Routine hat damit einen Verbrauch von 2.989 kg errechnet und zurückgegeben.
                                  Ich habe mir die Berechnungen nochmals angesehen und es gab ein Problem bei der Pausenberechnung
                                  es hätten eigentlich nur 1.989 kg sein sollen. Habe ich korrigiert. (Routine habe ich dann etwas optimiert)

                                  Hast du einen anderen Wert erwartet ?

                                  Hast du denn überhaupt Intervallsaugen bei deiner Anlage eingeschaltet ?
                                  Das heisst nach deinen Einstellungen, dass du nach einer Saugzeit von 55 Sekunden eine 6 sekunden Pause hast und dann geht es weiter mit 55 sekunden Saugen und so weiter

                                  vG Looxer

                                  var timeconsumed = 59936 //59936
                                  var energieverbr = 0
                                  var schnecke = 0
                                  
                                  
                                  var uebergabe = new Array(timeconsumed, energieverbr, schnecke);
                                  EnergieRg(uebergabe); // Berechne Energieverbrauch
                                  
                                  
                                  //    Funktion zur Verbrauchsert ermittlung - hier Pelletverbrauch
                                  //    Vorgabewerte sind anzupassen
                                  //.................................................................
                                  function EnergieRg(uebergabe) {
                                  var vorgpause = 6; // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen
                                  var vorgintervall = 55; // laenge eines einzelnen Intervalls
                                  var vorgvorlauf = 32;  // Saugzeit bevor die Schnecke läuft (Vakuum bilden)
                                  var vorgnachlauf = 16; // Laufzeit des Saugers nach stopp der schnecke
                                  var vorgverbrauch = 10;  // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft
                                  var runtime = uebergabe[0] / 1000;  
                                  var verbrauch = uebergabe[1];
                                  var schneckenzeit = uebergabe[2];
                                  // Allgemeine Variablen
                                  var anzlaeufe = 0;
                                  var anzpausen = 0;
                                  // Berechne Anzahl Läufe und Pausen
                                  var net1runtime = runtime - vorgvorlauf - vorgnachlauf;
                                  if (net1runtime < 0 ) {net1runtime = 0};
                                  if ( net1runtime / vorgintervall >= 1) { 
                                     anzlaeufe = Math.floor(net1runtime / vorgintervall) + 1; 
                                     anzpausen = anzlaeufe - 1 ;
                                     log( " matthfloor "+Math.floor(net1runtime / vorgintervall) ) 
                                  }
                                  // Verbrauch berechnen 
                                  if( runtime > vorgvorlauf + vorgnachlauf) {         
                                     schneckenzeit = runtime - vorgvorlauf - vorgnachlauf  - ( (anzpausen) * vorgpause); // reine Schneckenlaufzeit berechnen
                                     verbrauch = schneckenzeit * vorgverbrauch/60 ;                                      // Pelletverbrauch berechnen
                                     } else {                                                                             // die runtime ist kleiner als die vorund nachlaufzeit - darf nicht sein
                                     schneckenzeit = 0
                                     verbrauch = 0; 
                                     }
                                  // erzeuge Logeintrag
                                  log("Energieverbrauchsrechnung Intervall :" + vorgintervall, "info"); 
                                  log("Energieverbrauchsrechnung Pause :" + vorgpause, "info"); 
                                  log("Energieverbrauchsrechnung Vorlauf :" + vorgvorlauf, "info"); 
                                  log("Energieverbrauchsrechnung Nachlauf:" + vorgnachlauf, "info"); 
                                  log("Energieverbrauchsrechnung KG/MIN:" + vorgverbrauch, "info"); 
                                  log("Energieverbrauchsrechnung gesamte runtime:" + runtime, "info"); 
                                  log("Energieverbrauchsrechnung Runtime minus Vor-Nachlaufzeit:" + net1runtime, "info"); 
                                  log("Energieverbrauchsrechnung Anzahl Laeufe:" + anzlaeufe, "info"); 
                                  log("Energieverbrauchsrechnung Anzahl Pausen:" + anzpausen, "info"); 
                                  log("Energieverbrauchsrechnung Schneckenzeit:" + schneckenzeit, "info"); 
                                  log("Energieverbrauchsrechnung Verbrauch berechnet:" + verbrauch, "info"); 
                                  
                                  uebergabe[1] = verbrauch
                                  uebergabe[2] = schneckenzeit
                                  
                                  return uebergabe
                                  
                                  }
                                  

                                  O Offline
                                  O Offline
                                  OliWit82
                                  schrieb am zuletzt editiert von OliWit82
                                  #50

                                  @looxer01

                                  Hallo Vielen dank.

                                  Ich glaube nicht.
                                  Zumindest läuft das Gebläse durch und die Schnecke macht auch keine Pause.

                                  Ob ich was anderes erwartet habe weiß ich nicht. Die ca 10kg am Tag kommen mir schon recht wenig vor wenn ich so ins Silo schaue.

                                  600F7156-92C4-4C49-979C-B724C5FE5103.jpeg

                                  Demnach würde ich sagen nein.
                                  Gruss

                                  L 1 Antwort Letzte Antwort
                                  0
                                  • O OliWit82

                                    @looxer01

                                    Hallo Vielen dank.

                                    Ich glaube nicht.
                                    Zumindest läuft das Gebläse durch und die Schnecke macht auch keine Pause.

                                    Ob ich was anderes erwartet habe weiß ich nicht. Die ca 10kg am Tag kommen mir schon recht wenig vor wenn ich so ins Silo schaue.

                                    600F7156-92C4-4C49-979C-B724C5FE5103.jpeg

                                    Demnach würde ich sagen nein.
                                    Gruss

                                    L Offline
                                    L Offline
                                    looxer01
                                    schrieb am zuletzt editiert von
                                    #51

                                    @oliwit82

                                    @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

                                    Ich glaube nicht.

                                    dann musst du das Intervall von 55 auf z.B 1000 stellen. Dann wird da nichts berechnet.

                                    Die anderen Zeiten haben ebenfalls Einfluss auf die Berechnung.
                                    z,B. die Vorlaufzeit ist die Zeit in der der Sauger bereits saugt aber die Schnecke noch nicht läuft.
                                    Dann werden ja keine Pellets transportiert. Ebenso die Nachlaufzeit.

                                    und der andere Faktor ist die Fördermenge je minute.

                                    vG Looxer

                                    A 1 Antwort Letzte Antwort
                                    0
                                    • L looxer01

                                      @oliwit82

                                      @oliwit82 sagte in Ökofen Pelletronic Touch auslesen:

                                      Ich glaube nicht.

                                      dann musst du das Intervall von 55 auf z.B 1000 stellen. Dann wird da nichts berechnet.

                                      Die anderen Zeiten haben ebenfalls Einfluss auf die Berechnung.
                                      z,B. die Vorlaufzeit ist die Zeit in der der Sauger bereits saugt aber die Schnecke noch nicht läuft.
                                      Dann werden ja keine Pellets transportiert. Ebenso die Nachlaufzeit.

                                      und der andere Faktor ist die Fördermenge je minute.

                                      vG Looxer

                                      A Offline
                                      A Offline
                                      AndaleR
                                      schrieb am zuletzt editiert von
                                      #52

                                      @looxer01 Das hier sieht ja alles sehr interessant aus.

                                      Ich hab eine ÖkoFEN Condens, komme an verschiedenste Werte über ioBroker schon ran.

                                      Nur hab ich keine Ahnung, wie ich die hier gezeigten Scripte in ioBroker einpflegen und die Werte dann ausgeben kann. Aktuell bin ich soweit, dass ich mir die aktuellen Werte in einer simplen Visualisierung anzeigen kann, aber für mehr reicht mein Wissen schon nicht mehr aus...

                                      O 1 Antwort Letzte Antwort
                                      0
                                      • A AndaleR

                                        @looxer01 Das hier sieht ja alles sehr interessant aus.

                                        Ich hab eine ÖkoFEN Condens, komme an verschiedenste Werte über ioBroker schon ran.

                                        Nur hab ich keine Ahnung, wie ich die hier gezeigten Scripte in ioBroker einpflegen und die Werte dann ausgeben kann. Aktuell bin ich soweit, dass ich mir die aktuellen Werte in einer simplen Visualisierung anzeigen kann, aber für mehr reicht mein Wissen schon nicht mehr aus...

                                        O Offline
                                        O Offline
                                        OliWit82
                                        schrieb am zuletzt editiert von
                                        #53

                                        @andaler said in Ökofen Pelletronic Touch auslesen:

                                        @looxer01 Das hier sieht ja alles sehr interessant aus.

                                        Ich hab eine ÖkoFEN Condens, komme an verschiedenste Werte über ioBroker schon ran.

                                        Nur hab ich keine Ahnung, wie ich die hier gezeigten Scripte in ioBroker einpflegen und die Werte dann ausgeben kann. Aktuell bin ich soweit, dass ich mir die aktuellen Werte in einer simplen Visualisierung anzeigen kann, aber für mehr reicht mein Wissen schon nicht mehr aus...

                                        Hallo Andaler,
                                        du gehst in den ioBroker unter scripte.
                                        Da erstellst du dir ein neues Javascript und kopierst das Script hier aus dem Forum ein.
                                        Dann musst du noch 2 Zeilen anpassen, und zwar die wo deine Anlage den Status sendet.
                                        Das ganze speicherst du ab und startest das script. Jetzt legt ioBroker alle Datenpunkte an.

                                        1 Antwort Letzte Antwort
                                        0
                                        • I Offline
                                          I Offline
                                          ioBroker-lover
                                          schrieb am zuletzt editiert von
                                          #54

                                          Hallo zusammen,

                                          besitze ebenfalls eine Pellematic und wollte mal meinen Ansatz darstellen.
                                          Mit der letzten Wartung wurde bei mir das Touch V4 aufgespielt. Darüber kann ich per JSON auf alle Messwerte im csv Format zugreifen.
                                          Ich habe mir ein Skript gebastelt, das per GET Befehl den Parameter "PE1 Einschublaufzeit[zs]" auswertet.
                                          Dort wird angegeben, wie lange Pellets in den Brennraum befördert wurden. Vorsicht - es geht hier nicht um die Schnecke des Pelletlagers, sondern die kesselinterne Förderschnecke vom Tagesbehälter in den Brennraum.
                                          Der Wert wird in Zs (Zehntel Sekunden) angegeben.

                                          Das Skript funktioniert trotz meiner rudimentären Fähigkeiten soweit, allerdings fehlt mir noch ein kg/min Wert, für die interne Förderschnecke.
                                          Hat da jemand zufällig eine Idee? Ich habe leider auch gar keinen Ansatz um den Wert zu ermitteln.
                                          Eventuell könnte ja jemand von euch mal prüfen wie lange die interne Förderschnecke im Vergleich zur externen lief (am besten über ein paar Tage summiert).
                                          Dann könnte man euren bekannten Wert auf die interne Förderschnecke umrechnen.

                                          Da meine Lösung ganz ohne externe Sensoren auskommt, wäre der Ansatz für neue User sicher interessant.

                                          var logCSV, log, i, result;
                                          
                                          async function csvToJSON(logCSV) {
                                              var lines=logCSV.replace(/\uFFFD/g, '°').split("\r");
                                              var result = [];
                                          
                                              var headers=lines[0].split(";");
                                              //console.log(headers);
                                              for(var i=1;i<lines.length;i++){
                                                  var obj = {};
                                                  var currentline=lines[i].split(";");
                                          
                                                  for(var j=0;j<headers.length;j++){
                                                      obj[headers[j]] = currentline[j];
                                                  }
                                          
                                                  result.push(obj);
                                              }
                                          
                                              return result;
                                          }
                                          
                                          
                                          schedule("*/15 * * * * *", async function () {
                                            try {
                                              require("request")('http://192.168.178.78:4321/PASSWORT/log0', async function (error, response, result) {
                                                log = await csvToJSON(result);
                                                var summeEinschublaufzeit = 0;
                                              for (i = 0; i <= Object.keys(log).length; i++) {
                                                  var currentElement = parseFloat(getAttr(log,[i,"PE1 Einschublaufzeit[zs]"]));
                                                  if (isNaN(currentElement)) { currentElement = 0; }
                                                  //console.log(currentElement);
                                                  var summeEinschublaufzeit = summeEinschublaufzeit + currentElement;
                                              }
                                              console.log("summeEinschublaufzeit = "+summeEinschublaufzeit);
                                              //console.log(typeof log);
                                              summeEinschublaufzeit = summeEinschublaufzeit / 10  / 60; // Daten im Datensatz sind in "ZS" = Zehntel Sekunden. Anschließend in Minuten umwandeln.
                                              var kgVerbrauch = summeEinschublaufzeit * 7.5; // Umwandlung von kg/min in kg
                                              console.log("kgVerbrauch = "+kgVerbrauch);
                                              setState("0_userdata.0.Pellematic.Pelletverbrauch_pro_Tag",kgVerbrauch, true);
                                              }).on("error", function (e) {console.error(e);});
                                            } catch (e) { console.error(e); }
                                            console.debug("request: " + 'http://192.168.178.78:4321/PASSWORT/log0');
                                          });
                                          
                                          
                                          L 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

                                          765

                                          Online

                                          32.5k

                                          Benutzer

                                          81.8k

                                          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