Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Skripten / Logik
    4. JavaScript
    5. [Vorlage] Tasmota One Click Firmware Update Vis Javascript.

    NEWS

    • Monatsrückblick - April 2025

    • Minor js-controller 7.0.7 Update in latest repo

    • Save The Date: ioBroker@Smart Living Forum Solingen, 14.06.

    [Vorlage] Tasmota One Click Firmware Update Vis Javascript.

    This topic has been deleted. Only users with topic management privileges can see it.
    • falke69
      falke69 @smartboart last edited by

      @smartboart

      genau. Das sehe ich aber nicht so schlimm.
      Mir geht es aktuell darum, dass die OTA URL nicht gesetzt werden kann.

      smartboart 1 Reply Last reply Reply Quote 0
      • smartboart
        smartboart @falke69 last edited by

        @falke69 doch nur für das nicht erreichbare Gerät...Die OTA URL wird an das Gerät übertragen. over the air...damit wird dem gerät gesagt wo es das bin file herbekommt. Wenn das Gerät nicht erreichbar ist, kannst die URL dem gerät auch nicht mitteilen.

        falke69 1 Reply Last reply Reply Quote 0
        • falke69
          falke69 @smartboart last edited by falke69

          @smartboart

          Das Gerät, was das Update bekommen soll, ist erreichbar.
          Bei mir liegt das Gerät auf der id26 und in der Auswahl der Entsprechenden Geräte
          auch auf der 26.

          Da muss ich mal schauen, ob ich die Ursache finde.

          Edit: Ursache gefunden. Habe diese Zeilen vergessen zu erweitern. 😬

              if(dp.state.val===21)select = Device21;
              if(dp.state.val===22)select = Device22;
              if(dp.state.val===23)select = Device23;
              if(dp.state.val===24)select = Device24;
              if(dp.state.val===25)select = Device25;
          
          smartboart 1 Reply Last reply Reply Quote 0
          • smartboart
            smartboart @falke69 last edited by

            @falke69 sagte in [Vorlage] Tasmota One Click Firmware Update Vis Javascript.:

            Edit: Ursache gefunden. Habe diese Zeilen vergessen zu erweitern.

            sehr gut...

            falke69 1 Reply Last reply Reply Quote 0
            • falke69
              falke69 @smartboart last edited by falke69

              @smartboart

              seit gestern ist nun die 10.0.0 auf dem Markt. Das hat mir zumindest das Script mitgeteilt.🤗
              Gibt es eine Möglichkeit, die Nachrichten auf nur einen Benutzer bei Telegram zu beschränken, damit nicht jedesmal meine ganze Family diese Nachrichten bekommt?

              ich habe es schon so versucht:

              sendTo('telegram.0', { user: 'username', text: '_message' });.
              

              da kommt aber nur "_message" in Telegram an.

              Edit:

              habe es hinbekommen👍
              Die entsprechenden Stellen, habe ich mal unten aufgeführt.
              Vielleicht, kannst / willst Du das ja noch mit in Dein Script einarbeiten.

              var sendtelegram = true;
              const user_telegram = '';             //User der die Nachricht bekommen soll
              
                              if(sendtelegram){
              
                                  _message = _message_tmp;
              
                               send_telegram(_message, user_telegram); //geändert
              
              
              function send_telegram (_message, user_telegram) {  //geändert
                  sendTo('telegram.0', { 
              
                      text: _message,
              
                      user: user_telegram,
              
                      parse_mode: 'HTML'
              
                  }); 
              
              
              1 Reply Last reply Reply Quote 0
              • M
                Mike Hellracer @Dragon last edited by Mike Hellracer

                @dragon
                Hi,
                kannst du bitte deine Lösung (View/Widgets) zur Verfügung stellen.
                Ich verwende UHULA Material-Design und möchte aufgrund von kmüpatibilitätsgründen ungern die Material-Design-Widgets installieren.
                Danke

                1 Reply Last reply Reply Quote 0
                • M
                  Mike Hellracer @smartboart last edited by Mike Hellracer

                  @smartboart
                  Hi, oben das Script ist aus 2020 ist das das Aktuelle?
                  Und mit dieser Version wird der DP UpdateAll nicht angelegt.
                  Leider funktioniert bei mir dein Widget nicht, aber wenn ich richtig verstanden habe muss ich dann nur den DP auf true setzen um alle zu aktualisieren oder?

                  1 Reply Last reply Reply Quote 0
                  • M
                    Mike Hellracer @smartboart last edited by Mike Hellracer

                    Hallo zusammen,
                    irgendwie bekomme ich das nicht richtig zum Laufen.
                    Irgendwie kann es die IP der Geräte nicht ermitteln. Der DP stimmt, aber im log steht das die IP nicht ermittelt werden kann.
                    Die veraltete Version der Tasmota Geräte wird angezeigt.
                    Download Verzeichnis ist angelegt. Die Rechte sind gesetzt und der Download der aktuellen Firmware dahin funktioniert auch.
                    Der Download link 'IP-Adresse.8000/Tasmota/tasmota-sensors.bin.gz' und auch 'IP-Adresse:8000/Tasmota/tasmota-sensors.bin.gz' funktionieren nicht.
                    Kann mir jemaand sagen was ich noch prüfen kann bzw, machen muss?
                    Danke

                    smartboart 1 Reply Last reply Reply Quote 0
                    • smartboart
                      smartboart @Mike Hellracer last edited by smartboart

                      @mike-hellracer sorry war lange nicht online...

                      Hast du Schreibtechte auf dem downloadverzeichnis?

                      Beachte die Kommentare im Script..

                      Hast du das script aus dem 1. Beitrag kopiert oder die ungetestete Version aus einem Beitrag zwischendrin? Welcher changelog?

                      Werde demnächst eine aktuelle Version hochladen...wird aber deine Probleme nicht lösen, wenn du das Script aus dem 1. Beitrag genommen hats, da die offizielle Version aus dem 1. Beitrag auch funktionieren muss.

                      In der aktuellen und neuen Version brauchst du nur 2 widgets eines zum Selektieren mittels Nummer und eines um zu starten mittels boolean also true setzen ..

                      Tasmota hat ab einer bestimmten Version die State Datenpunkte namentlich geändert..vlt. musst du erstmal auf ne neuere Version hochrüsten.
                      Probier das Script erstmal mit einem device...

                      smartboart 1 Reply Last reply Reply Quote 0
                      • smartboart
                        smartboart @smartboart last edited by

                        Neue Version im 1. Beitrag ganz oben hochgeladen.

                        16.07.2021
                        V0.0.7 Optimierungen von cruzix (iobroker-forum) integriert.
                        Danke @ cruzix
                        Komplett Test noch offen. Testversion.

                        01.11.2021
                        V0.0.8 Anregungen von cruzix in das script eingearbeitet und getestet. Hier und da noch diverse Bugfixe.

                        M 1 Reply Last reply Reply Quote 0
                        • M
                          Mike Hellracer @smartboart last edited by

                          @smartboart
                          Super danke dir, ich werde es ausprobieren.
                          Ich habe die Einträge aus dem Script für Verzeichnis und rechte verwendet.
                          Welcher User braucht Schreibrechte?
                          Habe einfach mal den Link in den Browser eingegeben. Muss darauf der Download starten, oder ist der Eintrag in die Tasmota Gui gemeint?
                          Kannst du ein Beispiel für die 2 Widgets zur Verfügung stellen?

                          smartboart 1 Reply Last reply Reply Quote 0
                          • smartboart
                            smartboart @Mike Hellracer last edited by

                            @mike-hellracer es wird mit dem Script der download gestartet und ein lokaler download server zur Verfuegung gestellt..ich möchte in meinem smart home nicht alle Geraete im Internet haben. Die tasmota geraete sind bei mir alle fuer das internet gesperrt.
                            Beispiel Widgets sind ganz oben..

                            1 Reply Last reply Reply Quote 0
                            • smartboart
                              smartboart @Dragon last edited by smartboart

                              24.02.2022
                              V0.1.0 - manuelles Konfig Backup für einzelne Geräte eingebaut.
                              - automatisches Konfig Backup bei Firmwareupdate implementiert
                              - Schreibrechte der Download files / Ordner inklusive Unterordner automatisch rekursiv setzen
                              bei server start sudo chmod -R 777 /home/pi/Tasmota
                              - Update für zusätzliche sonder Firmware Tasmota32 eingebaut

                              1 Reply Last reply Reply Quote 0
                              • D
                                Dragon last edited by

                                Ich habe meinen Broker auf Proxmox laufen. Darum existiert kein Benutzer Namens pi und somit auch kein Verzeichnis im Ordner home Namens pi. Das wird auch nicht erstellt...

                                smartboart 1 Reply Last reply Reply Quote 0
                                • smartboart
                                  smartboart @Dragon last edited by smartboart

                                  @dragon dann pass den konfig teil doch einfach an..

                                  D 1 Reply Last reply Reply Quote 0
                                  • D
                                    Dragon @smartboart last edited by

                                    @smartboart Habe ich, der Ordner wurde aber trotzdem nicht erstellt. Habe ihn zu Fuß erstellt, dann lief alles. Nun zeigt er mir bei ein paar Geräten an es sei eine minimal installiert, das stimmt aber nicht...

                                    smartboart 2 Replies Last reply Reply Quote 0
                                    • smartboart
                                      smartboart @Dragon last edited by

                                      @dragon Was steht denn im log? Starte das script mal neu und zeige den log eintrag dazu..

                                      1 Reply Last reply Reply Quote 0
                                      • smartboart
                                        smartboart @Dragon last edited by

                                        @dragon sagte in [Vorlage] Tasmota One Click Firmware Update Vis Javascript.:

                                        @smartboart Habe ich, der Ordner wurde aber trotzdem nicht erstellt. Habe ihn zu Fuß erstellt, dann lief alles.

                                        Ja muss auch manuell erstellt werden..das Script erstellt den Ordner nicht..es greift nur drauf zu und vergibt schreibrechte..

                                        M 1 Reply Last reply Reply Quote 0
                                        • M
                                          Mike Hellracer @smartboart last edited by

                                          @smartboart
                                          Hi, tut mir leid, aber ich denke die Frage gehört eigentlich hierher.
                                          Ich habe das Script aus dem 1. POST Update Ende 2022 installiert. Das Verzeichnis ist angelegt und die Rechte erteilt. Node-js und fs sind geladen ebenso wie die exec Einstellung im Adapter aktiviert.
                                          Wenn ich das Script richtig verstanden habe sollte es eigentlich den http.Server starten.
                                          Leider funktioniert das nicht
                                          Wenn ich den http.server manuell im Verzeichnis /home/pi/ starte zeigt die Webseite des Servers auch die Files und Backups und es läuft auch das Update der Tasmota Devices.
                                          Beu einem Neustart ist das natürlich weg.
                                          Was muss ich tun, damit das Starten des Servers auch über den exec command aus dem Script funktioniert?

                                          smartboart 1 Reply Last reply Reply Quote 0
                                          • smartboart
                                            smartboart @Mike Hellracer last edited by smartboart

                                            @mike-hellracer Wenn es über das Terminal funktionioniert sollte es auch über das script klappen.
                                            im javascript adapter alle Berechtigungen gesetz?
                                            Ansosnten probiere mal mein aktuelles script. hier verwende ich den Linux control Adapter..

                                            /*
                                            von Smartboart / ioBroker Forum
                                            -
                                            https://forum.iobroker.net/topic/38118/tasmota-one-click-firmware-update-vis-0_userdata
                                            -
                                            31.10.2020
                                            -
                                            Tasmota One Click Firmware Update Vis.extra auch für Geräte die für das internet gesperrt sind.
                                            automatischer Download der firmware / minimal , sensors, tasmota und speichern auf dem file system.
                                            Starten eines lokalen http: Servers (python)  und einleiten des OTA download der Tasmota Firmware.
                                            für selektierbare Geräte über Vis.
                                            -
                                            Nötige Addons im 0_userdata adapter:  und fs
                                            -
                                            inspiriert durch das script um auf neue Tasmota Version zu prüfen von forummitglied Machinima..
                                            https://forum.iobroker.net/topic/22389/skript-um-auf-neue-tasmota-version-zu-pr%C3%BCfen/11
                                            -
                                            31.10.2020 Beta release
                                            V0.0.1  Automatisches Tasmota Firmwaredownload bei Update Benachrichtigung:
                                                    onclickupdate mit http Server Start (python) inkl Vorwahl des abzudatenden Teilnehmers.
                                            
                                            31.10.2020
                                            V0.0.2  Konfigurationsteil überarbeitet http source.
                                            
                                            03.11.2020
                                            V0.0.3  Kommentare ergänzt um mölichen Missverständnissen entgegen zu wirken.
                                                    Beim Scriptstart immer die bins runterladen, auch wenn kein Update verfügbar um sicher zu stellen, dass immer was im Download Ordner liegt.
                                            
                                            06.11.2020
                                            V0.0.4  Implementierung der Funktion Update All
                                                    Im Bereich der Device Zuordnung mussten anpassungen vorgenommen werden umd diese beim Updat All der Reihe nach abarbeiten zu können.
                                                    Dazu wurde auch der Userconfig Bereich angepasst.
                                                    Anzahl Geräte wird Automatisch ermittelt und gesetzt. Device 1 - n / AnzahlSensors ist für Sensor reserviert.
                                                    AnzahlSensors muss im Konfigbereich eingetragen werden. Standart Tasmota Firmware Geräte sind dann automatisch gesetzt von
                                                    Anzahl Sensors bis automatisch ermittelte Geräte.
                                            
                                                    Hinweis: damit nicht während des Update Prozess durch Eingabe in Vis beim derDevice Auswahl die Schrittkette durcheinander gebract wird, sollte
                                                    das widget für die DeviceAuswahl nur Sichtbar sein wenn der neue State 0_userdata.0.Status.Tasmota.Tasmota_Firmware.UpdateAll false ist.
                                                    Um alle Geräte upzudaten muss nun einfach der State UpdateAll auf true gesetzt werden und dann mit dem State UpdateStart das Update eingeleitet
                                                    werden. Das einzeln Update der Geräte bleibt natürlich erhalten und ist aktiv wenn UpdateAll false ist.
                                                    Nach Update All wird automatisch die Funktion funcVersion gestartet um alle Geräte nach der installierten Version zu befragen. Im Log kann nun
                                                    alles nachvollzogen werden.
                                            
                                            17.12.2020
                                            V0.0.4  kleine Fehlerkorrekturen
                                            
                                            24.02.2021
                                            V0.0.5 State UpdateAll kann entfallen Auswahl Update all erfolgt nun über den State Auswahl
                                                   Bei Update All Nach Ende Update sicher beenden if (count >= ANZAHL_DEVICE)
                                            
                                            01.03.2021
                                            V0.0.6 	Tasmota Statebezeichner haben sich geändert, dies habe ich nun berücksichtigt.
                                            		Anzahl Device wieder manuell in der Konfig angeben. Autozählung Hat unter bestimmten umständen zu Fehlern geführt.
                                            
                                            16.07.2021
                                            V0.0.7  Optimierungen von cruzix (iobroker-forum) integriert.
                                            		Danke @ cruzix
                                            		Komplett Test noch offen. Testversion.		
                                            		
                                            01.11.2021 
                                            V0.0.8  Anregungen von cruzix in das script eingearbeitet und getestet. Hier und da noch diverse Bugfixe.
                                            
                                            18.02.2022
                                            V0.0.9 Link in Telegramnachrichten hinzugefügt / Changelog - Releaseinfo
                                            
                                            24.02.2022
                                            V0.1.0 manuelles Konfig Backup für einzelne eingebaut.
                                                   automatisches Konfig Backup bei Firmwareupdate implementiert                                         
                                                   Schreibrechte der Download files / Ordner inklusive Unterordner automatisch rekursiv setzen 
                                                   bei server start sudo chmod -R 777 /home/pi/Tasmota
                                            14.04.2022
                                            V0.1.1 Statusabfrage Versionsabfrage per vis Button anfordern
                                            
                                            24.10.2022
                                            V0.1.2 Remote entfernt. Abhängigkeit Linux Remote Adapter hinzugefügt
                                            
                                            
                                            To do....Wenn es die Zeit zulässt..
                                            zusätzlich den Changelog in den Versionsinfostate schreiben.
                                            */
                                            
                                            createState('0_userdata.0.Status.Tasmota.Tasmota_Firmware.Update', {
                                             def: false,
                                             type: 'boolean',
                                             name: 'Tasmota Update verfügbar'
                                            });
                                            createState('0_userdata.0.Status.Tasmota.Tasmota_Firmware.Version', {
                                             type: 'string',
                                             read: true,
                                             write: true,
                                             desc: 'Tasmota Firmware Version online',
                                             name: 'Tasmota Firmware Update Version'
                                            });
                                            createState('0_userdata.0.Status.Tasmota.Tasmota_Firmware.Updatestart', {
                                             def: false,
                                             type: 'boolean',
                                             name: 'Tasmota Firmware Update starten'
                                            });
                                            
                                            createState('0_userdata.0.Status.Tasmota.Tasmota_Firmware.Backupstart', {
                                             def: false,
                                             type: 'boolean',
                                             name: 'Tasmota Firmware Backup starten'
                                            });
                                            
                                            createState('0_userdata.0.Status.Tasmota.Tasmota_Firmware.Versionsabfrage', {
                                             def: false,
                                             type: 'boolean',
                                             name: 'Tasmota Firmware Versionsabfrage starten'
                                            });
                                            
                                            const fc = true; // force creation zum aktualisieren des Auswahl state
                                            
                                            //  1 - AnzahlSensors (bei mir 17) müssen Sensor Geräte zugeordnet haben
                                            //  > AnzahlSensors +  sind Standart Firmware Geräten vorbehalten.
                                            createState('0_userdata.0.Status.Tasmota.Tasmota_Firmware.Auswahl', 0, fc, {
                                             def: 0,
                                             type: 'number',
                                             name: 'Auswahl Teilnehmer fuer Tasmota Firmware Update',
                                             min: 0,
                                             max: 100,
                                             role: 'value',
                                             states: {
                                            0:'Update All',
                                            1:'Wemo Schuppen',
                                            2:'NodeMCU Keller',
                                            3:'NodeMCU Huette',
                                            4:'Wemo Fitttnessraum',
                                            5:'Wemo Eingang',
                                            6:'NodeMCU Dachboden',
                                            7:'Steckdose Waschmaschine',
                                            8:'Steckdose Trockner',
                                            9:'Steckdose Spülmaschine',
                                            10:'Steckdose Dunstabzug',
                                            11:'Steckdose 4',
                                            12:'Steckdose 3',
                                            13:'Steckdose 2',
                                            14:'Steckdose 1',
                                            15:'Wemo Ankleidezimmer',
                                            16:'Wemo Bad',
                                            17:'Steckdosenleiste WZ',
                                            18:'Steckdosenleiste FR',
                                            19:'RGBW Briefkasren',
                                            20:'RGBW Bad',
                                            21:'Olimex ESP32 Garage', // Sonder
                                            22:'Reserve',
                                            23:'Reserve',
                                            24:'Reserve',
                                            25:'Reserve',
                                            26:'Reserve',
                                            27:'Reserve',
                                            28:'Reserve',
                                            29:'Reserve',
                                            30:'Reserve',
                                            31:'Reserve',
                                            32:'Reserve',
                                            33:'Reserve',
                                            34:'Reserve',
                                            35:'Reserve',
                                            36:'Reserve',
                                            37:'Reserve',
                                            38:'Reserve',
                                            39:'Reserve',
                                            40:'Reserve',
                                            }
                                            });
                                            
                                            // User konfig
                                            const WARTEZEIT = '*/5 * * * *'; // jede Minute Trigger Wartezeit zwischen den Updates der Tasmota Geräte
                                            const TIMEOUT = 120 * 1000; // Wartezeit Versionsabfrage und zwischen den Updates bei minimal
                                            const TIMEOUT2 = 6*1000; // Wartezeit zwischen URL Set und Upgrade bzw. http start und URL minimal set
                                            const DOWNLOAD = true; // automatischer Firmware download wenn update verfügbar
                                            const LOGGING = true;
                                            const DEBUG = false;
                                            const SEND_TELEGRAM = true;
                                            const SEND_MAIL = true;
                                            const ANZAHL_SENSORS = 16; // Hier die Anzahl der TasmotaSensor Geräte eintragen Entspicht DEVICE 1-17
                                            const ANZAHL_DEVICE = 20; // Tasmota > ANZAHL_SENSOR < ANZAHL_SONDER 
                                            const ANZAHL_SONDER = 21;  // Sonder Geräte von > ANZAHL_DEVICE
                                            
                                            // linux-control adapter mit den folgenden 2 Befehlen erweitern 
                                            // sudo python3 -m http.server 8000 im Terminal testen. Startet den minimal http server
                                            //'python3 -m http.server 8000';
                                            //'sudo chmod -R 777 /home/pi/Tasmota';
                                            const idServer = 'linux-control.0.Raspi-Master.remote.HTTPserverStart'/*HTTP Server fuer Tasmota Upgrade starten*/;
                                            const idAccess = 'linux-control.0.Raspi-Master.remote.TasmoDateiZugriff'/*Zugriffsrechte für Firmwaredownload Tasmota vergebn*/;
                                            
                                            
                                            // Ordner müssen angelegt werden unter dem Benutzer home/pi und muss schreibrechte für iobroker haben
                                            // sudo chmod -R 777 /home/pi/Tasmota
                                            const DEST_PATH1 = '/home/pi/Tasmota/tasmota-sensors.bin.gz';
                                            const DEST_PATH2 = '/home/pi/Tasmota/tasmota.bin.gz';
                                            const DEST_PATH3 = '/home/pi/Tasmota/tasmota-minimal.bin.gz';
                                            const DEST_PATH4 = '/home/pi/Tasmota/tasmota32.bin';
                                            const DEST_PATHBACKUP = '/home/pi/Tasmota/';
                                            
                                            //http IP Downloadlink muss auch im Browser funktionieren wenn die bins dort liegen
                                            const SOURCE_SENSORS = '192.xxx:8000/Tasmota/tasmota-sensors.bin.gz';
                                            const SOURCE_MINIMAL = '192.xxx:8000/Tasmota/tasmota-minimal.bin.gz';
                                            const SOURCE_TASMOTA = '192.xxxx:8000/Tasmota/tasmota.bin.gz';
                                            const SOURCE_ETHERNET = '192.xxxx:8000/Tasmota/tasmota32.bin';
                                            
                                            
                                            // download Quelle der tasmota firmware
                                            const DOWNLOAD_LINK1 = 'http://ota.tasmota.com/tasmota/release/tasmota-sensors.bin.gz'; //downloadlink für bin file
                                            const DOWNLOAD_LINK2 = 'http://ota.tasmota.com/tasmota/release/tasmota.bin.gz'; //downloadlink für bin file
                                            const DOWNLOAD_LINK3 = 'http://ota.tasmota.com/tasmota/release/tasmota-minimal.bin.gz'; //downloadlink für bin file
                                            const DOWNLOAD_LINK4 = 'http://ota.tasmota.com/tasmota32/release/tasmota32.bin'; //downloadlink für bin file
                                            //http://ota.tasmota.com/tasmota32/release-12.3.1/tasmota32.bin
                                            //http://ota.tasmota.com/tasmota/release-12.3.1/tasmota.bin.gz
                                            //Sensors Tasmota Firmware
                                            const DEVICE = [
                                             //Sensors Tasmota Firmware
                                            // Device 1 - AnzahlSensors müssen Sensor Geräte zugeordnet haben. >Anzahl Sensors bis ANZAHL_DEVICE ist für Standart Tasmota Firmware > ANZAHL_DEVICE ist Sonder
                                            '192.xxx',//WemoSchuppen
                                            '192.xxx',//NodeMCUKeller
                                            '192.xxx',//NodeMCUHuette
                                            '192.xxx',//WemoFitttnesraum
                                            '192.xxx',//WemoEingang
                                            '192.xxx',//NodeMCUDachboden
                                            '192.xxx',//SteckdoseWama
                                            '192.xxx',//SteckdoseTrockner
                                            '192.xxx',//SteckdoseSpülmaschine
                                            '192.xxx',//SteckdoseDunstabzug
                                            '192.xxx',//Steckdose4
                                            '192.xxx',//Steckdose3
                                            '192.xxx',//Steckdose2
                                            '192.xxx',//Steckdose1
                                            '192.xxx',//Wemo Ankleidezimmer
                                            '192.xxx',//Wemo Bad
                                            
                                            
                                            
                                            // Tasmota Firmware
                                            '192.xxx',//SteckdosenleisteWZ
                                            '192.xxx',//SteckdosenleisteFR
                                            '192.xxx',//RGBW1
                                            '192.xxx',//RGBWBad
                                            
                                            // Ethernet Tasmota Firmware
                                            '192.xxx',//Olimex-ESP32-Garage
                                            ]
                                            
                                            // User States / Objekte
                                            const idUpdate = '0_userdata.0.Status.Tasmota.Tasmota_Firmware.Update';
                                            const id_Version_Internet = '0_userdata.0.Status.Tasmota.Tasmota_Firmware.Version';
                                            const idUpdatestart = '0_userdata.0.Status.Tasmota.Tasmota_Firmware.Updatestart';
                                            const idBackupstart = '0_userdata.0.Status.Tasmota.Tasmota_Firmware.Backupstart';
                                            const idAuswahl = '0_userdata.0.Status.Tasmota.Tasmota_Firmware.Auswahl';
                                            const idVersionsabfrage = '0_userdata.0.Status.Tasmota.Tasmota_Firmware.Versionsabfrage';
                                            
                                            let cacheSelectorTasmotaVersions = $('channel[state.id=sonoff.0.*.Info1_Version]');
                                            
                                            // fs unter Einstellungen im 0_userdata Adapter hinzufügen
                                            const fs = require('fs');
                                            const request = require('request');
                                            let select = '';
                                            let linuxremote = false;
                                            let Sensor = null;
                                            let Tasmota = null;
                                            let Sonder = null;
                                            let trigger = null;
                                            //let ANZAHL_DEVICE = 0; //Anzahl der Tasmota Geräte. Wichtig für Update aller Geräte
                                            
                                            let _message = '';
                                            let _message_tmp = '';
                                            
                                            function bLOG(str) {
                                             if (LOGGING) log(str);
                                            }
                                            
                                            function bDEBUG(str) {
                                               if (DEBUG) console.debug(`[DEBUG] ${str}`);
                                             }
                                            
                                            function func_Version() {
                                            let options = {
                                                 url: 'https://api.github.com/repos/arendst/Tasmota/releases/latest',
                                                 headers: {
                                                     'User-Agent': 'ioBroker Tasmota Firmware Check'
                                                 }
                                             };
                                             request(options, function(error, response, body) {
                                                 const availableFirmware = getState(id_Version_Internet).val;
                                                 if (error) {
                                                     log('error: ' + error);
                                                 } else {
                                                     let tasmotaJson = JSON.parse(body);
                                                     let tasmotaTagName = tasmotaJson.tag_name;
                                                     let tasmotaVersion = tasmotaTagName.replace(/v/i, "").trim();
                                                     //if (availableFirmware.length === 0) {
                                                         if (availableFirmware === "Null") {
                                                         bLOG('Ausgewähltes Objekt leer. Firmware wird erstmalig gesetzt. Firmware: ${tasmotaVersion}'); // +' Zentrale: ' +Version[3]);
                                                         setStateAsync(id_Version_Internet, tasmotaVersion);
                                                     }
                                                     let devices = [];
                                                     cacheSelectorTasmotaVersions.each(function(id, i) {
                                                         let Abfrage = getState(idVersionsabfrage).val;
                                                         const installedFirmware = getState(id).val.trim()
                                                           .replace('(sonoff)', '').trim()
                                                           .replace('(tasmota)', '').trim()
                                                           .replace('(sensors)', '').trim();
                                            
                                                         let infoId = id.substring(0, id.lastIndexOf("."));
                                                         let hostName = getState(infoId + '.Info2_Hostname').val;
                                                         if (installedFirmware == tasmotaVersion) {
                                                             bLOG(`Tasmota: Firmware für ${hostName} ist aktuell.`);
                                                         } else {
                                                             bLOG(`Tasmota: Firmware für  ${hostName} (${installedFirmware}) ist nicht aktuell. Verfügbare: ${tasmotaVersion}`);
                                                             if (availableFirmware == tasmotaVersion) {
                                                               setStateAsync(idUpdate, false, true);
                                                               bDEBUG('Tasmota: Version Internet hat sich nicht verändert');
                                                             } else {
                                                                 setState(idUpdate, true, true);
                                                                 bDEBUG('Tasmota: Firmware ist nicht aktuell.');
                                                                 setStateAsync(id_Version_Internet, tasmotaVersion);
                                                                 devices.push(hostName + ' (' + installedFirmware + ')');
                                                             }
                                                         }
                                                        if(Abfrage)setStateDelayed(idVersionsabfrage,false,1000);
                                                     });
                                                     if (devices.length > 0 ) {
                                                         _message_tmp = `Neue Tasmota-Firmware ${tasmotaVersion} für folgende Geräte verfügbar:\n${devices.join('\n')}`;
                                                         if (SEND_TELEGRAM) {
                                                             _message = _message_tmp;
                                                             send_telegram();
                                                             bLOG(`Tasmota: Update verfügbar Telegram abgesetzt.`);
                                                         }
                                                         if (SEND_MAIL) {
                                                             _message = _message_tmp;
                                                             send_mail();
                                                             bLOG(`Tasmota: Update verfügbar Email abgesetzt.`);
                                                         }
                                                     }
                                                 }
                                             });
                                            }
                                            
                                            
                                            function send_telegram() {
                                             sendTo('telegram.0', {
                                                 text: _message + ' https://github.com/arendst/Tasmota/releases '
                                             });
                                            }
                                            
                                            function send_mail() {
                                             sendTo("email", {
                                                 subject: "Servicemeldung",
                                                 text: _message + ' https://github.com/arendst/Tasmota/releases '
                                             });
                                            }
                                            // um 12:45 Uhr prüfen
                                            schedule({
                                             hour: 12,
                                             minute: 45
                                            }, func_Version);
                                            
                                            //Konfig backup
                                            function downloadKonfig() {
                                             request.get({
                                                 url: 'http://'+ select + '/dl',
                                                 encoding: 'binary'
                                             }, function(err, response, body) {
                                                 if (err) {
                                                     return log(`Tasmota: Fehler beim Backup: ${err}`);
                                                 }
                                                 fs.writeFile(DEST_PATHBACKUP + 'Konfig_Backup_' + select + '.dmp', body, 'binary', function(err) {
                                                     const fileName = select.split('/').pop();
                                                     if (err) {
                                                         return log(`Tasmota: Fehler beim Backupspeichern: ${err}`);
                                                     }
                                                     bLOG(`Tasmota: Backupdownload ${select} gestartet `);
                                                 });
                                             });
                                            }
                                            //filedownload
                                            function downloadFile1() {
                                             request.get({
                                                 url: DOWNLOAD_LINK1,
                                                 encoding: 'binary'
                                             }, function(err, response, body) {
                                                 if (err) {
                                                     return log(`Tasmota: Fehler beim Download: ${err}`);
                                                 }
                                                 fs.writeFile(DEST_PATH1, body, 'binary', function(err) {
                                                     const fileName = DOWNLOAD_LINK1.split('/').pop();
                                                     if (err) {
                                                         return log(`Tasmota: Fehler beim Speichern: ${err}`);
                                                     }
                                                     bLOG(`Tasmota: Firmwaredownload ${fileName} gestartet `);
                                                 });
                                             });
                                            }
                                            
                                            function downloadFile2() {
                                             request.get({
                                                 url: DOWNLOAD_LINK2,
                                                 encoding: 'binary'
                                             }, function(err, response, body) {
                                                 if (err) {
                                                     return log(`Tasmota: Fehler beim Download: ${err}`);
                                                 }
                                                 fs.writeFile(DEST_PATH2, body, 'binary', function(err) {
                                                     const fileName = DOWNLOAD_LINK2.split('/').pop();
                                                     if (err) {
                                                         return log(`Tasmota: Fehler beim Speichern: ${err}`);
                                                     }
                                                     bLOG(`Tasmota: Firmwaredownload ${fileName} gestartet `);
                                                 });
                                             });
                                            }
                                            
                                            
                                            function downloadFile3() {
                                             request.get({
                                                 url: DOWNLOAD_LINK3,
                                                 encoding: 'binary'
                                             }, function(err, response, body) {
                                                 if (err) {
                                                     return log(`Tasmota: Fehler beim Download: ${err}`);
                                                 }
                                                 fs.writeFile(DEST_PATH3, body, 'binary', function(err) {
                                                     const fileName = DOWNLOAD_LINK3.split('/').pop();
                                                     if (err) {
                                                         return log(`Tasmota: Fehler beim Speichern: ${err}`);
                                                     }
                                                     bLOG(`Tasmota: Firmwaredownload ${fileName} gestartet `);
                                                 });
                                             });
                                            }
                                            
                                            
                                            function downloadFile4() {
                                             request.get({
                                                 url: DOWNLOAD_LINK4,
                                                 encoding: 'binary'
                                             }, function(err, response, body) {
                                                 if (err) {
                                                     return log(`Tasmota: Fehler beim Download: ${err}`);
                                                 }
                                                 fs.writeFile(DEST_PATH4, body, 'binary', function(err) {
                                                     const fileName = DOWNLOAD_LINK4.split('/').pop();
                                                     if (err) {
                                                         return log(`Tasmota: Fehler beim Speichern: ${err}`);
                                                     }
                                                     bLOG(`Tasmota: Firmwaredownload ${fileName} gestartet `);
                                                 });
                                             });
                                            }
                                            
                                            on({id: idBackupstart,val: true,change: 'ne'}, function() {  
                                            var Vorwahl = getState(idAuswahl).val;
                                            setStateDelayed(idBackupstart, false, true,1000);
                                            if (Vorwahl != 0){
                                            downloadKonfig();
                                            setTimeout(function(){
                                                    setState(idAccess,true);
                                                     log('Tasmota: Schreibrechte für Downloadordner gesetzt.')
                                                    },5*1000);
                                                }
                                            });
                                            
                                            
                                            // http Server starten
                                            on({id: idUpdatestart,val: true,change: 'ne'}, async function() {
                                            setState(idUpdate, false, true);
                                             let UpdateAll = getState(idAuswahl).val;
                                             if (UpdateAll != 0) {
                                                //Änderung ohne Minimal 17.12.2022 +
                                                //variantensetup()
                                                //Änderung ohne Minimal 17.12.2022
                                                 downloadKonfig();
                                                 setTimeout(async function() {
                                                     
                                                    MinimalURLset();
                                                    /* 
                                                     //Änderung ohne Minimal 17.12.2022 +
                                                        if (Sensor) SensorURLset();
                                                        if (Tasmota) TasmotaURLset();
                                                        if (Sonder) SonderURLset();
                                                     //Änderung ohne Minimal 17.12.2022   
                                                     */
                                                     await setStateAsync(idUpdatestart, false, true);
                                                 }, TIMEOUT2);
                                             } else {
                                                 startUpdateAll();
                                             }
                                             if (!linuxremote) {
                                                 linuxremote = true;
                                                 setState(idAccess,true);
                                                 setState(idServer,true);
                                                     log('Tasmota: HTTP Server für Update / Backup gestartet')
                                             }
                                            });
                                                    
                                            
                                            // Alles updaten Alle Geräte werden von 1 an durchgezählt
                                            async function startUpdateAll() {
                                             let count = 0;
                                             bLOG(`Tasmota: Update aller Geräte gestartet.`);
                                             trigger = schedule(WARTEZEIT, async function() {
                                                 count++;
                                                 await setStateAsync(idAuswahl, count, true);
                                                 setTimeout(downloadKonfig, 200)
                                                 setTimeout(MinimalURLset, 2000);
                                                        if (Sensor) setTimeout(SensorURLset,TIMEOUT2);
                                                        if (Tasmota)setTimeout(TasmotaURLset,TIMEOUT2);
                                                        if (Sonder) setTimeout(SonderURLset,TIMEOUT2);
                                            //Änderung ohne Minimal 17.12.2022 
                                                 bLOG(`Tasmota: Aktuell wird das Update für Device ${count} gestartet.`);
                                                 if (count >= ANZAHL_DEVICE) {
                                                 //if (count >= ANZAHL_SONDER) {
                                                     clearSchedule(trigger);
                                                     setTimeout(async function() {
                                                         func_Version();
                                                         await setStateAsync(idAuswahl, 0, true);
                                                     }, 2 * TIMEOUT);
                                                     setTimeout(async function() {
                                                       await setStateAsync(idUpdatestart, false, true);
                                                         count = 0;
                                                     }, TIMEOUT2);
                                                 }
                                             });
                                            }
                                            
                                            // Entscheiden ob Sensor oder Tasmota oder Sonder aktiv für Upgrade und Device Vorwahl
                                            on(idAuswahl, function(dp) {
                                            variantensetup();
                                            });
                                            
                                            function variantensetup(){
                                            var Variante = getState(idAuswahl).val;
                                             if (Variante > 0 && Variante <= ANZAHL_SENSORS) {
                                                 Sensor = true;
                                                 Tasmota = false;
                                                 Sonder = false;
                                             }
                                             if (Variante > ANZAHL_SENSORS && Variante < ANZAHL_SONDER) {
                                                 Sensor = false;
                                                 Tasmota = true;
                                                 Sonder = false;
                                             }
                                             if (Variante > ANZAHL_DEVICE) {
                                                 Sensor = false;
                                                 Tasmota = false;
                                                 Sonder = true;
                                             }
                                            
                                             if (DEVICE.length >= Variante) {
                                                 select = DEVICE[Variante - 1];
                                             }
                                             if (Variante > 0){
                                             bLOG(`Tasmota: Folgende IP wurde für das Update vorgewählt: ${select}`);
                                                }
                                            }
                                            
                                            
                                            
                                            function MinimalURLset() {
                                             let Auswahl = getState(idAuswahl).val;
                                             if (DOWNLOAD && Auswahl > 0 && Sonder === false){
                                                 request(`http://${select}/cm?cmnd=OtaUrl%20http://${SOURCE_MINIMAL}`, function(error, response, body) {
                                                     if (error) {
                                                         log(`Tasmota: Fehler beim  setzen der OTA Minimal URL für: ${select} ${error}`);
                                                     } else {
                                                         bLOG(`Tasmota: OTA Firmware URL auf Minimal gesetzt für IP: ${select}`);
                                                         setTimeout(minimalUpgrade, TIMEOUT2);
                                                     }
                                                });
                                                        }else{
                                                                if (DOWNLOAD && Auswahl > 0 && Sonder){
                                                                SonderURLset();
                                                    }
                                                }
                                            }
                                            
                                            
                                            function minimalUpgrade() {
                                             request(`http://${select}/cm?cmnd=upgrade%201`, function(error, response) {
                                                 if (error) {
                                                     log('Tasmota: Fehler beim setzen des Minimal Upgrade Befehl für: ' + select + ' ' + error);
                                                 } else {
                                                     bLOG('Tasmota: OTA Firmware upgrade Minimal für IP: ' + select);
                                                     setTimeout(function() {
                                                         if (Sensor) SensorURLset();
                                                         if (Tasmota) TasmotaURLset();
                                                         if (Sonder) SonderURLset();
                                                     }, TIMEOUT);
                                                 }
                                             });
                                            }
                                            
                                            // Sensor URL setzen und update
                                            function SensorURLset() {
                                             request(`http://${select}/cm?cmnd=OtaUrl%20http://${SOURCE_SENSORS}`, function(error, response) {
                                                 if (error) {
                                                     log('Fehler beim  setzen der OTA Sensor URL für: ' + select + ' ' + error);
                                                 } else {
                                                     bLOG('Tasmota: OTA Firmware URL auf Sensor gesetzt für IP: ' + select);
                                                     setTimeout(sensorUpgrade, TIMEOUT2);
                                                 }
                                             });
                                            }
                                            
                                            function sensorUpgrade() {
                                             request(`http://${select}/cm?cmnd=upgrade%201`, function(error, response) {
                                                 if (error) {
                                                     log('Tasmota: Fehler beim setzen des Sensor Upgrade Befehl für: ' + select + ' ' + error);
                                                 } else {
                                                     bLOG('Tasmota: OTA Firmware upgrade Sensors für IP: ' + select);
                                                 }
                                             });
                                            }
                                            
                                            // Tasmota URL setzen und update
                                            function TasmotaURLset() {
                                             request(`http://${select}/cm?cmnd=OtaUrl%20http://${SOURCE_TASMOTA}`, function(error, response) {
                                                 if (error) {
                                                     log('Fehler beim  setzen der OTA Tasmota URL: ' + error);
                                                 } else {
                                                     bLOG('Tasmota: OTA Firmware URL auf Tasmota gesetzt für IP: ' + select);
                                                     setTimeout(tasmotaUpgrade, TIMEOUT2);
                                                 }
                                             });
                                            }
                                            
                                            function tasmotaUpgrade() {
                                             request(`http://${select}/cm?cmnd=upgrade%201`, function(error, respnsoe) {
                                                 if (error) {
                                                     log('Tasmota: Fehler beim setzen des Tasmota Upgrade Befehl für: ' + select + ' ' + error);
                                                 } else {
                                                     bLOG('Tasmota: OTA Firmware upgrade Tasmota für IP: ' + select);
                                                 }
                                             });
                                            }
                                            
                                            
                                            // Upate Block für Sondergeräte nur ein file für Update nötig
                                            
                                            // Tasmota URL setzen und update
                                            function SonderURLset() {
                                             request(`http://${select}/cm?cmnd=OtaUrl%20http://${SOURCE_ETHERNET}`, function(error, response) {
                                                 if (error) {
                                                     log('Fehler beim  setzen der OTA Tasmota Ethernet URL: ' + error);
                                                 } else {
                                                     bLOG('Tasmota: OTA Firmware URL auf Tasmota Ethernet gesetzt für IP: ' + select);
                                                     setTimeout(SonderUpgrade, TIMEOUT2);
                                                 }
                                             });
                                            }
                                            
                                            function SonderUpgrade() {
                                             request(`http://${select}/cm?cmnd=upgrade%201`, function(error, respnsoe) {
                                                 if (error) {
                                                     log('Tasmota: Fehler beim setzen des Tasmota Upgrade Befehl für: ' + select + ' ' + error);
                                                 } else {
                                                     bLOG('Tasmota: OTA Firmware upgrade Tasmota für IP: ' + select);
                                                 }
                                             });
                                            }
                                            
                                            
                                            // Firmware automatisch herunter laden
                                            on({
                                             id: idUpdate,
                                             val: true,
                                             change: 'ne'
                                            }, function(dp) {
                                             if (DOWNLOAD) {
                                                 downloadFile1();
                                                 downloadFile2();
                                                 downloadFile3();
                                                 downloadFile4();
                                                 log ('Tasmota: Download bei Update.');
                                             }
                                            });
                                            
                                            // Firmware automatisch herunter laden
                                            on({
                                             id: idVersionsabfrage,
                                             val: true,
                                             change: 'ne'
                                            }, function(dp) {
                                            func_Version();
                                            log ('Tasmota: Manuelle Versionsabfrage gestartet.');
                                            });
                                            
                                            //beim SkriptStart
                                            func_Version();
                                            setState(idVersionsabfrage,false);
                                            
                                            if (DOWNLOAD) {
                                             setTimeout(function() {
                                                     downloadFile1();
                                                     downloadFile2();
                                                     downloadFile3();
                                                     downloadFile4();
                                                     log ('Tasmota: Download bei Skriptstart.');
                                             }, 10 * 1000);
                                            }
                                            
                                            onStop(function () { 
                                                    clearSchedule(trigger);
                                            }, 100);
                                            
                                            M 1 Reply Last reply Reply Quote 0
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            973
                                            Online

                                            31.6k
                                            Users

                                            79.4k
                                            Topics

                                            1.3m
                                            Posts

                                            11
                                            120
                                            10156
                                            Loading More Posts
                                            • Oldest to Newest
                                            • Newest to Oldest
                                            • Most Votes
                                            Reply
                                            • Reply as topic
                                            Log in to reply
                                            Community
                                            Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                            The ioBroker Community 2014-2023
                                            logo