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. Praktische Anwendungen (Showcase)
  4. Tasmota Steckdosen per MQTT + JavaScript direkt ansteuern

NEWS

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

  • Weihnachtsangebot 2025! 🎄
    BluefoxB
    Bluefox
    24
    1
    1.6k

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

Tasmota Steckdosen per MQTT + JavaScript direkt ansteuern

Geplant Angeheftet Gesperrt Verschoben Praktische Anwendungen (Showcase)
33 Beiträge 9 Kommentatoren 11.3k Aufrufe 11 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.
  • crunchipC crunchip

    @fredf bei mir ebenfalls, blick da aber noch nicht so durch mit ESPhome

    FredFF Offline
    FredFF Offline
    FredF
    Most Active Forum Testing
    schrieb am zuletzt editiert von FredF
    #6

    @crunchip Geht mir ähnlich, wemos D1 mini habe ich schon hinbekommen, bei Gosund oder anderen Steckdosen hakt es...

    1 Antwort Letzte Antwort
    0
    • FredFF FredF

      @bananajoe
      Schon mal überlegt ganz von MQTT wegzugehen und ESPHome zu nutzen?
      Mit meinen knapp 35 Tasmota Geräten im Sonoff Adapter habe ich zwar (noch :hand_with_index_and_middle_fingers_crossed: ) keine Probleme, bin aber aus anderen Gründen interessiert auf ESPHome zu wechseln. Ich hoffe im jetzt kommenden Winter finde ich die Zeit dazu...

      BananaJoeB Offline
      BananaJoeB Offline
      BananaJoe
      Most Active
      schrieb am zuletzt editiert von
      #7

      @fredf Nope, ESP-Home ist keine alternative für mich. Ich mache alles mit MQTT, nicht nur die Tasmota-Geräte und finde das Protokoll und Funktionsprinzip absolut genial.
      Und ich bin Tasmota-Fan, selbst mein Musik-Steuerungs LED-Display in der Küche läuft über Tasmota (und MQTT)

      ioBroker@Ubuntu 24.04 LTS (VMware) für: >260 Geräte, 5 Switche, 7 AP, 9 IP-Cam, 1 NAS 42TB, 1 ESXi 15TB, 4 Proxmox 1TB, 1 Hyper-V 48TB, 14 x Echo, 5x FireTV, 5 x Tablett/Handy VIS || >=160 Tasmota/Shelly || >=95 ZigBee || PV 8.1kW / Akku 14kWh || 2x USV 750W kaskadiert || Creality CR-10 SE 3D-Drucker

      FredFF 1 Antwort Letzte Antwort
      0
      • BananaJoeB BananaJoe

        @fredf Nope, ESP-Home ist keine alternative für mich. Ich mache alles mit MQTT, nicht nur die Tasmota-Geräte und finde das Protokoll und Funktionsprinzip absolut genial.
        Und ich bin Tasmota-Fan, selbst mein Musik-Steuerungs LED-Display in der Küche läuft über Tasmota (und MQTT)

        FredFF Offline
        FredFF Offline
        FredF
        Most Active Forum Testing
        schrieb am zuletzt editiert von
        #8

        @bananajoe Na klar, jeder wie er will.

        haselchenH 1 Antwort Letzte Antwort
        0
        • FredFF FredF

          @bananajoe Na klar, jeder wie er will.

          haselchenH Offline
          haselchenH Offline
          haselchen
          Most Active
          schrieb am zuletzt editiert von
          #9

          @fredf
          @crunchip

          Ich glaube @OpenSourceNomad kann zu dem ESP Thema ein wenig beitragen oder sogar ein wenig mehr 😉

          Synology DS218+ & 2 x Fujitsu Esprimo (VM/Container) + FritzBox7590 + 2 AVM 3000 Repeater & Homematic & HUE & Osram & Xiaomi, NPM 10.9.4, Nodejs 22.21.0 ,JS Controller 7.0.7 ,Admin 7.7.19

          FredFF J crunchipC 3 Antworten Letzte Antwort
          0
          • haselchenH haselchen

            @fredf
            @crunchip

            Ich glaube @OpenSourceNomad kann zu dem ESP Thema ein wenig beitragen oder sogar ein wenig mehr 😉

            FredFF Offline
            FredFF Offline
            FredF
            Most Active Forum Testing
            schrieb am zuletzt editiert von
            #10

            @haselchen
            :rolling_on_the_floor_laughing: Da bin ich mir sicher

            1 Antwort Letzte Antwort
            1
            • haselchenH haselchen

              @fredf
              @crunchip

              Ich glaube @OpenSourceNomad kann zu dem ESP Thema ein wenig beitragen oder sogar ein wenig mehr 😉

              J Offline
              J Offline
              Jan1
              schrieb am zuletzt editiert von
              #11

              @haselchen
              Außer dass er davon überzeugt ist und auf Nachfrage gerne Links zum Thema verteilt, habe ich da auch noch nicht wirklich weitere Hilfe erhalten und wenn ich mich damit beschäftige, werden die ? nur größer, nicht kleiner.

              1 Antwort Letzte Antwort
              1
              • haselchenH haselchen

                @fredf
                @crunchip

                Ich glaube @OpenSourceNomad kann zu dem ESP Thema ein wenig beitragen oder sogar ein wenig mehr 😉

                crunchipC Abwesend
                crunchipC Abwesend
                crunchip
                Forum Testing Most Active
                schrieb am zuletzt editiert von
                #12

                @haselchen sagte in Tasmota Steckdosen per MQTT + JavaScript direkt ansteuern:

                oder sogar ein wenig mehr

                :stuck_out_tongue_winking_eye:
                gehört aber nicht hier in den Thread, hier gehts um mqtt und tasmota

                umgestiegen von Proxmox auf Unraid

                1 Antwort Letzte Antwort
                1
                • BananaJoeB BananaJoe

                  Changelog:

                  • 31.10.2021 erste öffentliche Version 1.6
                  • 02.03.2023 Version 1.18
                  • 29.09.2024 Version 1.24

                  Noch in Entwicklung / geplant:

                  • Firmware + Gerätetyp (Steckdose oder Licht/Dimmer/RGB) automatisch erkennen
                  • Umgang mit Tasmota-Geräten mit mehreren Schaltausgängen (bisher von Hand im Skript angepasst)
                  • Integration der RGB-Version dieses Skriptes in die normale Version

                  Vorwort:
                  Auf Grund einer Nachfrage poste ich mal mal meinen persönlichen Lösungsweg für die Einbindung von über 60 Tasmota-Geräten bei mir zu Hause in ioBroker.

                  Ich nutze dazu Mosquitto als MQTT-Broker (mit Installiert auf dem ioBroker), den MQTT Adapter als Client zu diesem und je ein eigenes JavaScript pro Tasmota-Gerät zur Auswertung. Der Grund ist das ich damals schon meine Geräte mit einem MQTT-Server verbunden hatte und darauf auch diverse andere Scripte und Dienste zugriffen (bevor ich mit ioBroker angefangen habe). Diese sollten so weiter funktionieren können. Aber per MQTT haben die Steckdosen dann z.B. kein True/False-Datenpunkt den man z.B. für einen Schalter in der VIS verwenden könnte. Der Sonoff-Adapter ist zwar auch ein MQTT-Broker für die Tasmota-Geräte, man kann sich aber nicht als Client mit diesem Verbinden. Also brauchte ich ein Skript.

                  Schritt 1: Mosquitto installieren:
                  Da gibt es genug Anleitungen im Internet. Für Ubuntu (und sollte auch auf dem Raspberry Pi funktionieren) habe ich diese genutzt: How to install and secure Mosquitto on Ubuntu 20.04.

                  Dabei solltet Ihr Abweichend von der Anleitung folgendes ändern:
                  In der

                   /etc/mosquitto/conf.d/default.conf
                  

                  Solltet Ihr den Eintrag listener von 9001 auf 9002 ändern und Mosquitto neu starten:

                  ...
                  port 1883
                  listener 9002
                  protocol websockets
                  ...
                  

                  Grund ist das zumindest bei mir die JavaScript-Instanz von ioBroker schon Port 9001 belegt.
                  Die Einstellungen oben starten auf Port 1883 den MQTT-Broker und auf Port 9002 kann Alternativ per Websocket mit den MQTT-Broker kommuniziert werden. Der Port 1883 sollte entweder in ioBroker nicht von einem anderen Adapter belegt sein (etwa dem Sonoff-Adapter oder einer bestehenden MQTT-Server Instanz) oder ihr wählt einen anderen Port in der Mosquitto-Konfiguration.

                  Schritt 2: Zugriff auf Mosquitto testen:
                  Ich nehme dazu gerne den MQTT-Explorer: http://mqtt-explorer.com/
                  d49354f9-4cf3-4609-aafd-54b6d8358f22-image.png
                  Da sollte unten $SYS zu sehen sein mit Informationen zum Mosquitto-Server:
                  c514003e-79fa-4601-ae62-f57654874f05-image.png

                  Schritt 3: Einstellungen unter Tasmota:
                  In der Weboberfläche des Tasmota-Gerätes stelle ich nun den MQTT-Server ein:
                  2869870a-100a-4396-8818-517cb58226c6-image.png

                  Der Host ist mein ioBroker-Server, der Port ist in Mosquitto konfiguriert.
                  Nach dem Speichern sollte Ihr im MQTT-Explorer das Gerät schon sehen können, und zwar unter den Topics (=Unterordnern) tele, stat und cmnd:

                  d9d55022-4273-44f2-80b2-c6050729f8c7-image.png

                  Schritt 4: MQTT-Adapter in ioBroker:
                  Installiert in ioBroker den MQTT Broker/Client und installiert diesen:
                  14af7c77-33a7-4221-a472-b1f26ef8be75-image.png bzw. c9331fb7-ed74-43a1-8856-a3e2979f4ea2-image.png

                  Der Adapter ist bei mir wie folgt eingestellt:
                  37102f25-a2ac-43d7-8065-60254e0e5b83-image.png

                  08b5cc05-418d-4427-a28d-0b32c458174a-image.png

                  Unter den Datenpunkten des Adapters sollte Ihr nun im Prinzip das gleiche sehe wie im MQTT-Explorer. Sonst einfach mal das Tasmota-Gerät neu starten, der MQTT-Adapter kann nur Meldungen sehen die nach seiner Verbindungsherstellung gekommen sind.

                  Schritt 5: JavaScript pro Tasmota-Gerät
                  Das Skript stelle einen POWER Datenpunkt zur Verfügung der in der VIS genutzt werden kann um das Gerät ein- oder auszuschalten. Zusätzlich werden ein paar Informationen zu Version und WLAN gesammelt:

                  // Setup
                  var s_DeviceName = "Gosund166";
                  // Suffix wird an den Devicenamen für die Zieldatenpunkte angehängt, z.B. "-Waschmaschine" (KEINE Punkte!!!)
                  var s_Suffix = "-2fach";
                  // --------------------------------------------------------------------------------------
                  // Bei Tasmota-Firmware ab Verion 9.5 auf true setzen, bis Version 9.3.1 auf false setzen
                  var b_Firmware95 = true;
                  // Erfassung von Leistungs und Verbrauchsdaten
                  var b_Energy = false;
                  // Anzahl der schaltbaren Ausgänge, 1 bis 4, 1 = nur POWER, ab 2 und mehr POWER1, POWER2 usw.
                  var i_NumberOfPower = 1;
                  // EasyMeter Q3A gemäß https://tasmota.github.io/docs/Smart-Meter-Interface/#easymeter-q1d-ascii-obis
                  var b_EasyMeterQ3A = false;
                  // Erfassung von Temperaturwerten (Shelly 1PM)
                  var b_Temperature = false;
                  // Erfassung HC-SR04 Ultraschall-Sensor
                  var b_hcsr04 = false;
                  // Sollen die Datenpunkte nachträglich korrigiert werden?
                  var b_CorrectDatapoints = false;
                  // Einschaltdauer erfassen (muss noch getestet werden, nicht benutzen!)
                  var b_HourMeter = false;
                  // Name der MQTT-Instanz
                  var s_mqtt_Instance = "mqtt.0";
                  // Festlegen der Skriptversion (für Auswertungen)
                  var s_VersionJSScript = "1.24"
                  // Logging aktivieren für das Debuggen in die JavaScript-Console und in das ioBroker Log (true oder false):
                  var b_UseLogging = false;
                  //
                  // Changelog:
                  // ----------
                  // 13.03.2021   1.0     erste Version mit Versionsnummer + optische Aufbereitung des Quellcodes
                  // 14.03.2021   1.1     Umbau auf fromNe: / Einbau Logging / Einführung Changelog
                  // 25.03.2021   1.2     Ermittlung der Einschaltdauer erster Versuch
                  // 08.05.2021   1.3     Anpassung an JS controller 3.3.8 (ackn bei Datenpunkten die read-only sind)
                  // 30.08.2021   1.4     Angepasst an Tasmota 9.5.0 (hart)
                  // 31.10.2021   1.5     Auswahl der Firmware-Version per Variable
                  // 31.10.2021   1.6     Pfad auf 0_userdata.0 geändert, Name des AccessPoints herauskommentiert.
                  // 31.10.2021   1.7     Heraussuchen des AccessPoint-Names konfigurierbar gemacht
                  // 04.11.2021   1.8     Erstellen der Datenpunkte mit await-Funktion. So muss das Skript nicht mehr 2x gestartet werden.
                  // 20.11.2021   1.9     Bei allen Werten aus JSON-Objekten vor den Schreiben in States explizite Umwandlung in String oder Number
                  // 12.12.2021   1.10    Stromverbrauch mit wird nun auch erfasst sofern entsprechende Daten geliefert werden /tele/xxx/SENSOR
                  // 12.12.2021   1.11    Und kleinere Fehler beseitigt (in Debugging-Meldungen / Typen Konvertierung)
                  // 12.12.2021   1.12    Zusätzliche Datenpunkte für Einschaltdauer hinzugefügt, die aktuelle Dauer wird hochgezählt und in 2 Datenpunkten festgehalten.
                  //                      Die Berechnung erfolgt jedesmal wenn eine /tele/xxxx/STATE Meldung eingeht.
                  // 09.02.2022   1.13    Shelly Temperatur + Einheiten korrigiert
                  // 26.06.2022   1.14    Temperatur Optional gemacht per Schalter
                  //                      Optionales Suffix für die Zieldatenpunkte
                  // 28.06.2022   1.15    Einschaltdauer - Default Wert für Einschaltzeit ist nun die aktuelle Zeit (Falls Gerät noch nie ausgeschaltet war)
                  // 19.07.2022   1.16    FriendlyName wird nun mit ausgewertet (Bezeichnung unter der Echo & Co. das Gerät finden)
                  // 25.07.2022   1.17    Script-Version mit als Datenpunkt aufgenommen + Einheiten von Datenpunkten hinzugefügt (auch nachträglich)
                  // 25.07.2022   1.18    Name des Scriptes als Datenpunkt aufgenommen
                  // 04.04.2023   1.19    EasyMeterQ3A auslesen eingebaut
                  // 25.03.2024   1.20    HC-SR04 Ultraschall Sensor
                  // 16.04.2024   1.21    Fehler bei Zeiterfassung (wenn nicht aktiv) behoben, Zeiterfassung default deaktiviert
                  // 12.06.2024   1.22    Eventlog lokal in das Skript aufgenommen statt über globale Funktion
                  // 28.09.2024   1.23    Umbau auf Möglichkeit mit mehreren Schaltern POWER <=> POWER1 bis POWER4
                  // 29.09.2024   1.24    Bestätigt/Unbestätigt bei POWER-Datenpunkten + Fehlerbehebung
                  // 
                  // 2020 - 2024 von Bernhard Linz / Bernhard@znil.net
                  // ####################################################################################################################################################
                  // Beschreibung:
                  // -------------
                  // Grundaufgabe ist es einen Datenpunkt bereitzustellen über welchen der POWER Status des Tasmota Gerätes als Boolean true false 
                  // ausgelesen aber auch gesetzt werden kann - so wie es viele Widgets in VIS benötigen
                  // Dazu wird der MQTT Datenpunkt /stat/{Gerätename}/POWER ausgewertet und per /cmnd/{Gerätename}/POWER ggf. gesetzt
                  // Zusätzlich werden weitere Informationen gesammelt, z.B. mit welchen AccessPoint das Gerät verbunden ist
                  //
                  // Setup:
                  // ------
                  // oben in Zeile 2 den Namen des Tasmota-Gerätes setzen so wie dieser unter mqtt.0.stat auftaucht.
                  // Name wird durch die Tasmota Optionen
                  // Topic {NamedesGerätes}
                  // MqttClient {NamedesGerätes}
                  // gesetzt und sollte für diese Script bei beiden Identisch sein
                  //
                  // Das Suffix in Zeile 2 wird an die 0_userdata.0 Datenpunkte angehängt
                  // Ist die Firmware des Tasmota-Gerätes 9.5 oder höher so muss "b_Firmware95 = true" gesetzt werden (Die Pfade im MQTT haben sich geändert)
                  // Soll der Energieverbauch erfasst werden so muss "b_Energy = true;" gesetzt werden, die Meldungen von tele/xxx/SENSOR werden dann ausgewertet
                  // ####################################################################################################################################################
                  // Private Einstellungen die nur für meine Umgebung funktionieren oder von euch zuerst die Voraussetzungen geschafft werden müssen
                  // Soll der Name des AccessPoints ermittelt werden?
                  // @ts-ignore
                  var b_GetNameOfAccessPoints = false;
                  // Pfad für das auslesen des AccessPoints. Dort gibt es für jeden AccessPoint einen Datenpunkt vom Typ String welcher die MAC als ID und den Namen als Wert hat
                  var s_AccessPoints_path = "0_userdata.0.001-Konstanten.WLAN.";
                  // Zentrales Log über alle Ein- und Ausschaltvorgänge führen
                  var b_UseSystemEventLog = false;
                  
                  // ####################################################################################################################################################
                  // http://www.network-science.de/ascii/ Font: big
                  // __      __        _       _     _            
                  // \ \    / /       (_)     | |   | |           
                  //  \ \  / /_ _ _ __ _  __ _| |__ | | ___ _ __  
                  //   \ \/ / _` | '__| |/ _` | '_ \| |/ _ \ '_ \ 
                  //    \  / (_| | |  | | (_| | |_) | |  __/ | | |
                  //     \/ \__,_|_|  |_|\__,_|_.__/|_|\___|_| |_|
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  // unsere JavaScript-Instanz um zu prüfen ob die Änderung durch MQTT oder durch VIS ausgelöst wurde
                  // @ts-ignore
                  const o_js_Instance = 'system.adapter.javascript.' + instance;
                  // und der erste Log-Eintrag
                  DebugWarning("Startup: Setze Variablen ...");
                  // Datenpunktstammpfad
                  //var s_state_rootpath = "javascript.0.tasmota.";
                  var s_state_rootpath = "0_userdata.0.tasmota.";
                  var s_state_FullPath = s_state_rootpath + s_DeviceName + s_Suffix;
                  // True/False Datenpunkt für VIS & Co
                  var s_state_power_path = s_state_FullPath + ".POWER";
                  // Datenpunkt an den Tasmota den aktuellen POWER Zustand meldet
                  if (i_NumberOfPower == 1) {
                      var s_mqtt_POWER_path = s_mqtt_Instance + ".stat." + s_DeviceName + ".POWER";
                  } else {
                      var s_mqtt_POWER_path = s_mqtt_Instance + ".stat." + s_DeviceName + ".POWER*";
                  }
                  // Datenpunkt an den die letzte Aktion von Tasmota gesendet wird
                  var s_mqtt_RESULT_path = s_mqtt_Instance + ".stat." + s_DeviceName + ".RESULT";
                  // Datenpunkt den man setzen muss um den Status zu ändern (ON oder OFF oder Toggle)
                  var s_mqtt_CMND_path = s_mqtt_Instance + ".cmnd." + s_DeviceName + ".POWER";
                  // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen STATE landen
                  var s_mqtt_STATE_path = s_mqtt_Instance + ".tele." + s_DeviceName + ".STATE";
                  // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen INFO1 landen (enthält unter anderem die Tasmota-Version)
                  var s_mqtt_INFO1_path = s_mqtt_Instance + ".tele." + s_DeviceName + ".INFO1";
                  // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen INFO2 landen (enthält die IP-Adresse)
                  var s_mqtt_INFO2_path = s_mqtt_Instance + ".tele." + s_DeviceName + ".INFO2";
                  // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen SENSOR landen (enthält Daten zum Energieverbrauch wenn unterstützt)
                  var s_mqtt_SENSOR_path = s_mqtt_Instance + ".tele." + s_DeviceName + ".SENSOR";
                  // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen stat/.../STATUS landen (enthält den FriendlyName)
                  var s_mqtt_STATUS_path = s_mqtt_Instance + ".stat." + s_DeviceName + ".STATUS";
                  // Temporäre Variable für verschiedene Auswertungen
                  var s_tempjson;
                  // Variablen für die Zeitauswertung
                  var i_global_unixtimeSwitchedOn = 0;
                  var i_global_unixtimeSwitchedOff = 0;
                  var i_global_LastSwichtedOnDuration = 0;
                  var i_global_OperationHoursCounter = 0;
                  var i_global_CurrentPowerOnTimeSeconds = 0;
                  var i_global_CurrentPowerOnTimeH = "";
                  
                  // Gibt eine Fehlermeldung wenn diese Variable nicht extra definiert wurde
                  var myAccessPoint;
                  //Fehlerzähler
                  var i_ErrorCounter = 0;
                  
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  //  ______           _    _   _                        
                  // |  ____|         | |  | | (_)                       
                  // | |__ _   _ _ __ | | _| |_ _  ___  _ __   ___ _ __  
                  // |  __| | | | '_ \| |/ / __| |/ _ \| '_ \ / _ \ '_ \ 
                  // | |  | |_| | | | |   <| |_| | (_) | | | |  __/ | | |
                  // |_|   \__,_|_| |_|_|\_\\__|_|\___/|_| |_|\___|_| |_|
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  // DebugWarning gibt in der Console eine Warnmeldung aus wenn b_UseLogging auf true steht
                  /* accepts parameters
                   * s_debugmessage = Print this text to console via warn
                   */
                  function DebugWarning(s_debugmessage) {
                      if (b_UseLogging == true) {
                          console.warn(s_debugmessage);
                      }
                  }
                  // ####################################################################################################################################################
                  // Wandelt Sekunden in Tage/Stunden/Minuten/Sekunden um:
                  function ConvertTimeHumanReadable(i_seconds) {
                      var i_days = Math.floor(i_seconds / (24 * 60 * 60));
                      i_seconds -= i_days * (24 * 60 * 60);
                      var i_hours = Math.floor(i_seconds / (60 * 60));
                      i_seconds -= i_hours * (60 * 60);
                      var i_minutes = Math.floor(i_seconds / (60));
                      i_seconds -= i_minutes * (60);
                      return ((0 < i_days) ? (i_days + "d ") : "") + ((0 < i_hours) ? (i_hours + "h ") : "") + ((0 < i_minutes) ? (i_minutes + "m ") : "") + ((0 < i_seconds) ? (i_seconds + "s") : "");
                  }
                  
                  // ####################################################################################################################################################
                  // Berechnet die Einschaltdauer etc., als Funktion da mehrmals benötigt
                  function CalculateSwitchedOnDuration() {
                      // Diese Funktion wird immer dann aufgerufen wenn ein Ausschalten registriert wurde
                      var i_Duration = i_global_unixtimeSwitchedOff - i_global_unixtimeSwitchedOn;
                      var s_Duration = ConvertTimeHumanReadable(i_Duration);
                      // Letzte Einschaltdauer setzen
                      setState(s_state_FullPath + ".tmp.LastSwichtedOnDuration", i_Duration, true);
                      setState(s_state_FullPath + ".Time-LastSwichtedOnDuration", s_Duration, true);
                      // Betriebsstundenzähler erhöhen
                      var i_TotalDuration = getState(s_state_FullPath + ".tmp.OperationHoursCounter").val;
                      i_TotalDuration = i_TotalDuration + i_Duration;
                      var s_TotalDuration = ConvertTimeHumanReadable(i_TotalDuration);
                      setState(s_state_FullPath + ".tmp.OperationHoursCounter", i_TotalDuration, true);
                      setState(s_state_FullPath + ".Time-OperationHoursCounter", s_TotalDuration, true);
                  }
                  
                  // ####################################################################################################################################################
                  // Modifiziert einen Datenpunkt und fügt eine Einheit dazu
                  function SetUnit(setunit_id, setunit_unit) {
                      if (b_CorrectDatapoints == true) {
                          try {
                              var setunit_obj = getObject(setunit_id);
                              // setunit_obj.common.name = 'neuer Name';
                              setunit_obj.common.unit = setunit_unit;
                              // @ts-ignore
                              setObject(setunit_id, setunit_obj);
                          }
                          catch (e) {
                              // nichts machen
                              i_ErrorCounter++;
                          }
                      }
                  }
                  
                  // ####################################################################################################################################################
                  // Eventlog, abgeschaut bei https://www.smarthome-tricks.de/software-iobroker/eigenes-logging-in-iobroker/
                  
                  function createEventlog(EventType, EventText) {
                      let tasmotaEventListDestination = "0_userdata.0.EventLog.Tasmota.";
                      // vorhandene Einträge einlesen
                      let EventList = getState(tasmotaEventListDestination + "EventLogTasmota").val;
                      // Anzahl der Maximal erlaubten Einträge einlesen
                      let maxEventCount = getState("0_userdata.0.EventLog.Tasmota.maxEventCount").val;
                      // Nur die letzten x Einträge im Script belassen
                      let eventList = EventList.split('<br>');
                      let eventCount = eventList.length;
                      let newEventList = "";
                      for (var i = 0; i < eventCount; i++) {
                          if ( i < (maxEventCount-1) ) {
                              newEventList = newEventList + "<br>" + eventList[i];
                          } else {
                              break;
                          }
                      }
                      EventList = newEventList;
                      // Neue Event-Id und Zeitpunkt ermitteln
                      let EventId = getState(tasmotaEventListDestination + "NextEventId").val;
                      let EventDateTime = formatDate(getDateObject((new Date().getTime())), "TT.MM.JJ hh:mm:ss");
                      EventId = EventId + 1;
                      setState(tasmotaEventListDestination + "NextEventId", EventId);
                      let FormatedEventId = ("0000000" + EventId).slice(-7);
                      let EventLog = FormatedEventId + " - " + EventDateTime + " - " + EventType + " - " + EventText;
                      EventList = EventLog + EventList;
                      setState(tasmotaEventListDestination + "EventLogTasmota", EventList);
                  }
                  
                  // ####################################################################################################################################################
                  // Benötigte Datenpunkte erstellen
                  async function CreateMyStatesAndStartup() {
                      try {
                          DebugWarning("Startup: Erstelle ggf. Datenpunkte ...");
                          // #######################################################################################################
                          // POWER
                          if (b_hcsr04 == false) {
                              if (i_NumberOfPower == 1) {
                                  DebugWarning("Erstelle: " + s_state_FullPath + ".POWER");
                                  await createStateAsync(s_state_FullPath + ".POWER", false, {
                                      type: 'boolean',
                                      read: true,
                                      write: true,
                                      role: "switch",
                                      name: s_DeviceName + s_Suffix + '.POWER'
                                  });
                              } else {
                                  for (let i = 1; i < (i_NumberOfPower + 1); i++) {
                                      DebugWarning("Erstelle: " + s_state_FullPath + ".POWER"  + String(i));
                                      await createStateAsync(s_state_FullPath + ".POWER" + String(i), false, {
                                          type: 'boolean',
                                          read: true,
                                          write: true,
                                          role: "switch",
                                          name: s_DeviceName + s_Suffix + '.POWER' + String(i)
                                      });
                                  }
                              }
                          }
                          // #######################################################################################################
                          // Version-JS-Script
                          await createStateAsync(s_state_FullPath + ".Version-JS-Script", s_VersionJSScript, {
                              type: 'string',
                              read: true,
                              write: false,
                              name: 'Version-JS-Script'
                          });
                          // #######################################################################################################
                          // Version-JS-Script-Path
                          await createStateAsync(s_state_FullPath + ".Version-JS-Script-Path", scriptName, {
                              type: 'string',
                              read: true,
                              write: false,
                              name: 'Name und Pfad des Skriptes'
                          });
                          // #######################################################################################################
                          // RSSI
                          await createStateAsync(s_state_FullPath + ".RSII", 0, {
                              type: 'number',
                              read: true,
                              write: false,
                              name: 'WLAN Stärke in %',
                              unit: "%"
                          });
                          //SetUnit(s_state_FullPath + ".RSII", "%");
                          // #######################################################################################################
                          // Basisstation 1
                          await createStateAsync(s_state_FullPath + ".BSSId", "00:00:00:00:00:00", {
                              type: 'string',
                              read: true,
                              write: false,
                              name: 'MAC des AccessPoints'
                          });
                          // #######################################################################################################
                          // Basisstation 2
                          if (b_GetNameOfAccessPoints == true) {
                              await createStateAsync(s_state_FullPath + ".AccessPoint", "unbekannt", {
                                  type: 'string',
                                  read: true,
                                  write: false,
                                  name: 'Name des AccessPoints'
                              });
                          }
                          // #######################################################################################################
                          // Kanal
                          await createStateAsync(s_state_FullPath + ".Channel", 0, {
                              type: 'number',
                              read: true,
                              write: false,
                              name: 'WLAN Kanal'
                          });
                          // #######################################################################################################
                          // IP-Adresse
                          await createStateAsync(s_state_FullPath + ".IPAddress", "0.0.0.0", {
                              type: 'string',
                              read: true,
                              write: false,
                              name: 'IP-Address'
                          });
                          // #######################################################################################################
                          // Modul (Gerätetyp)
                          await createStateAsync(s_state_FullPath + ".DeviceType", "Generic", {
                              type: 'string',
                              read: true,
                              write: false,
                              name: 'Device Type'
                          });
                          // #######################################################################################################
                          // Version (Firmware)
                          await createStateAsync(s_state_FullPath + ".Version", "0.0.0", {
                              type: 'string',
                              read: true,
                              write: false,
                              name: 'Version'
                          });
                          // #######################################################################################################
                          // FriendlyName (Rufname Amazon Echo & Co)
                          await createStateAsync(s_state_FullPath + ".FriendlyName", "Tasmota", {
                              type: 'string',
                              read: true,
                              write: false,
                              name: 'FriendlyName'
                          });
                          // #######################################################################################################
                          // Datenpunkte für Betriebsstundenzähler / Einschaltdauer
                          if (b_HourMeter == true) {
                              // Zeit wann eingeschaltet
                              await createStateAsync(s_state_FullPath + ".tmp.unixtimeSwitchedOn", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Einschaltzeit als Unix-Timestamp',
                                  unit: "unixtime"
                              });
                              SetUnit(s_state_FullPath + ".tmp.unixtimeSwitchedOn", "unixtime");
                              // #######################################################################################################
                              // Zeit wann ausgeschaltet
                              await createStateAsync(s_state_FullPath + ".tmp.unixtimeSwitchedOff", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Ausschaltzeit als Unix-Timestamp',
                                  unit: "unixtime"
                              });
                              SetUnit(s_state_FullPath + ".tmp.unixtimeSwitchedOff", "unixtime");
                              // #######################################################################################################
                              // Letzte Einschaltdauer
                              await createStateAsync(s_state_FullPath + ".tmp.LastSwichtedOnDuration", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Letzte Einschaltdauer',
                                  unit: "s"
                              });
                              SetUnit(s_state_FullPath + ".tmp.LastSwichtedOnDuration", "s");
                              // #######################################################################################################
                              // Summe der Einschaltdauer
                              await createStateAsync(s_state_FullPath + ".tmp.OperationHoursCounter", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Summe Einschaltdauer',
                                  unit: "s"
                              });
                              SetUnit(s_state_FullPath + ".tmp.OperationHoursCounter", "s");
                              // #######################################################################################################
                              // Letzte Einschaltdauer Lesbar in HH:MM:SS
                              await createStateAsync(s_state_FullPath + ".Time-LastSwichtedOnDuration", "0s", {
                                  type: 'string',
                                  read: true,
                                  write: true,
                                  name: 'Letzte Einschaltdauer'
                              });
                              // #######################################################################################################
                              // Gesamte Einschaltdauer Lesbar in HH:MM:SS
                              await createState(s_state_FullPath + ".Time-OperationHoursCounter", "0s", {
                                  type: 'string',
                                  read: true,
                                  write: true,
                                  name: 'Letzte Einschaltdauer'
                              });
                              // #######################################################################################################
                              // Aktuelle Einschaltdauer in Sekunden
                              await createState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Aktuelle Einschaltdauer in Sekunden',
                                  unit: "s"
                              });
                              SetUnit(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", "s");
                              // #######################################################################################################
                              // Aktuelle Einschaltdauer Lesbar in HH:MM:SS
                              await createState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", {
                                  type: 'string',
                                  read: true,
                                  write: true,
                                  name: 'Aktuelle Einschaltdauer in Tagen, Stunden, Minuten, Sekunden'
                              });
                              // #######################################################################################################
                          }
                          // Datenpunkte für Stromverbrauch
                          if (b_Energy == true) {
                              // Gesamter Energieverbrauch    
                              await createState(s_state_FullPath + ".Energy-Total", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Energie Total',
                                  unit: "kWh"
                              });
                              SetUnit(s_state_FullPath + ".Energy-Total", "kWh");
                              // #######################################################################################################
                              // Energieverbrauch gestern
                              await createState(s_state_FullPath + ".Energy-Yesterday", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Energie Gestern',
                                  unit: "kWh"
                              });
                              SetUnit(s_state_FullPath + ".Energy-Yesterday", "kWh");
                              // #######################################################################################################
                              // Energieverbrauch Heute
                              await createState(s_state_FullPath + ".Energy-Today", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Energie Heute',
                                  unit: "kWh"
                              });
                              SetUnit(s_state_FullPath + ".Energy-Yesterday", "kWh");
                              // #######################################################################################################
                              // Energieverbrauch Aktuell/Momentan/Jetzt gerade
                              await createState(s_state_FullPath + ".Energy-Power", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Energie Momentan',
                                  unit: "W"
                              });
                              SetUnit(s_state_FullPath + ".Energy-Power", "W");
                              // #######################################################################################################
                              // Energieverbrauch aktuelle Spannung
                              await createState(s_state_FullPath + ".Energy-Voltage", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Energie Spannung Momentan',
                                  unit: "V"
                              });
                              SetUnit(s_state_FullPath + ".Energy-Voltage", "V");
                              // #######################################################################################################
                              // Energieverbrauch aktueller Stromfluss
                              await createState(s_state_FullPath + ".Energy-Current", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Energie Stromfluss Momentan',
                                  unit: "A"
                              });
                              SetUnit(s_state_FullPath + ".Energy-Current", "A");
                              // #######################################################################################################
                          }
                          if (b_Temperature == true) {
                              // #######################################################################################################
                              // Temperatur
                              await createState(s_state_FullPath + ".Temperature", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Energie Stromfluss Momentan',
                                  unit: "°C"
                              });
                              SetUnit(s_state_FullPath + ".Temperature", "°C");
                              // #######################################################################################################
                          }
                          if (b_EasyMeterQ3A == true) {
                              // #######################################################################################################
                              // Stromzähler EasyMeter Q3A via Tasmota
                              // Verbrauch-Summe
                              await createState(s_state_FullPath + ".Verbrauch-Summe", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Verbrauch Summe',
                                  unit: "kWh"
                              });
                              // Einspeisung-Summe
                              await createState(s_state_FullPath + ".Einspeisung-Summe", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Einspeisung Summe',
                                  unit: "kWh"
                              });
                              // Watt L1
                              await createState(s_state_FullPath + ".Watt-L1", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Watt-L1',
                                  unit: "W"
                              });
                              // Watt L2
                              await createState(s_state_FullPath + ".Watt-L2", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Watt-L2',
                                  unit: "W"
                              });
                              // Watt L3
                              await createState(s_state_FullPath + ".Watt-L3", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Watt-L3',
                                  unit: "W"
                              });
                              // Watt Summe
                              await createState(s_state_FullPath + ".Watt-Summe", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Watt-Summe',
                                  unit: "W"
                              });
                              // Volt L1
                              await createState(s_state_FullPath + ".Volt-L1", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Volt-L1',
                                  unit: "V"
                              });
                              // Volt L2
                              await createState(s_state_FullPath + ".Volt-L2", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Volt-L2',
                                  unit: "V"
                              });
                              // Volt L3
                              await createState(s_state_FullPath + ".Volt-L3", 0, {
                                  type: 'number',
                                  read: true,
                                  write: true,
                                  name: 'Volt-L3',
                                  unit: "V"
                              });
                          }
                          if (b_hcsr04 == true) {
                              // #######################################################################################################
                              // Ultraschall Entfernungssensor
                              // Verbrauch-Summe
                              await createState(s_state_FullPath + ".Distance", 0, {
                                  type: 'number',
                                  read: true,
                                  write: false,
                                  name: 'Distance in cm',
                                  unit: "cm"
                              });
                          }
                          // Startup - Startwerte schon mal ermitteln und schreiben
                          DebugWarning("Startup: aktuellen Status von POWER holen und schreiben");
                          // Beim Start einmal den aktuellen Status von MQTT stat/POWER holen und schreiben
                          if (b_hcsr04 == false) {
                              if (i_NumberOfPower == 1) {
                                  s_tempjson = getState(s_mqtt_POWER_path).val;
                                  if (s_tempjson == "ON") {
                                      setState(s_state_power_path, true, true);
                                      if (b_HourMeter == true) {
                                          // letztes TimeStamp für das Einschalten wieder auslesen damit Dauer berechnet werden kann
                                          i_global_unixtimeSwitchedOn = getState(s_state_FullPath + ".tmp.unixtimeSwitchedOn").val;
                                          // Kann sein das der Wert 0 ist wenn das Gerät noch nie ausgeschaltet war, dann nehmen wir eben die aktuelle Zeit
                                          if (i_global_unixtimeSwitchedOn == 0) {
                                              i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
                                              setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
                                          }
                                      }
                                  } else {
                                      setState(s_state_power_path, false, true);
                                  }
                              } else {
                                  for (let i = 1; i < (i_NumberOfPower + 1); i++) {
                                      s_tempjson = getState(s_mqtt_POWER_path.replace("*",String(i))).val;
                                      if (s_tempjson == "ON") {
                                          setState(s_state_power_path + String(i), true, true);
                                          if (b_HourMeter == true) {
                                              // letztes TimeStamp für das Einschalten wieder auslesen damit Dauer berechnet werden kann
                                              i_global_unixtimeSwitchedOn = getState(s_state_FullPath + ".tmp.unixtimeSwitchedOn").val;
                                              // Kann sein das der Wert 0 ist wenn das Gerät noch nie ausgeschaltet war, dann nehmen wir eben die aktuelle Zeit
                                              if (i_global_unixtimeSwitchedOn == 0) {
                                                  i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
                                                  setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
                                              }
                                          }
                                      } else {
                                          setState(s_state_power_path + String(i), false, true);
                                      }
                                  }
                              }
                          }
                          // #######################################################################################################
                          // Version setzen / aktualisieren
                          setState(s_state_FullPath + ".Version-JS-Script", s_VersionJSScript, true);
                          setState(s_state_FullPath + ".Version-JS-Script-Path", scriptName, true);
                          // #######################################################################################################
                          // Beim Start einmal einfach die IP-Adresse / Firmware etc. falls schon vorhanden:
                          DebugWarning("Startup: aktuellen Status von INFO1 holen und schreiben");
                          if (await existsStateAsync(s_mqtt_INFO1_path)) {
                              s_tempjson = JSON.parse(getState(s_mqtt_INFO1_path).val);
                              if (b_Firmware95 == false) {
                                  // bis Tasmota Version 9.3.1
                                  DebugWarning("Startup: DeviceType: " + String(s_tempjson.Module));
                                  await setStateAsync(s_state_FullPath + ".DeviceType", String(s_tempjson.Module), true);
                                  DebugWarning("Startup: Version: " + String(s_tempjson.Version));
                                  await setStateAsync(s_state_FullPath + ".Version", String(s_tempjson.Version), true);
                              } else {
                                  // ab Tasmota Version 9.5
                                  DebugWarning("Startup: DeviceType: " + s_tempjson.Info1.Module);
                                  await setStateAsync(s_state_FullPath + ".DeviceType", String(s_tempjson.Info1.Module), true);
                                  DebugWarning("Startup: Version: " + s_tempjson.Info1.Version);
                                  await setStateAsync(s_state_FullPath + ".Version", String(s_tempjson.Info1.Version), true);
                              }
                          }
                          // #######################################################################################################
                          DebugWarning("Startup: aktuellen Status von INFO2 holen und schreiben");
                          if (await existsStateAsync(s_mqtt_INFO2_path)) {
                              s_tempjson = JSON.parse(getState(s_mqtt_INFO2_path).val);
                              if (b_Firmware95 == false) {
                                  // bis Tasmota Version 9.3.1
                                  await setStateAsync(s_state_FullPath + ".IPAddress", String(s_tempjson.IPAddress), true);
                                  DebugWarning("Startup: IPAddress: " + String(s_tempjson.IPAddress));
                              } else {
                                  // ab Tasmota Version 9.5
                                  await setStateAsync(s_state_FullPath + ".IPAddress", String(s_tempjson.Info2.IPAddress), true);
                                  DebugWarning("Startup: IPAddress: " + String(s_tempjson.Info2.IPAddress));
                              }
                          }
                          // #######################################################################################################
                          if (b_Energy == true) {
                              DebugWarning("Startup: aktuellen Status von SENSOR holen und schreiben");
                              if (await existsStateAsync(s_mqtt_SENSOR_path)) {
                                  s_tempjson = JSON.parse(getState(s_mqtt_SENSOR_path).val);
                                  if (b_Firmware95 == false) {
                                      // bis Tasmota Version 9.3.1
                                      // Keine Ahnung wie das vor 9.5 aussieht, muss ich dann noch mal nachpflegen
                                  } else {
                                      // ab Tasmota Version 9.5
                                      await setStateAsync(s_state_FullPath + ".Energy-Total", Number(s_tempjson.ENERGY.Total), true);
                                      DebugWarning("Startup: Energy-Total: " + Number(s_tempjson.ENERGY.Total));
                                      await setStateAsync(s_state_FullPath + ".Energy-Yesterday", Number(s_tempjson.ENERGY.Yesterday), true);
                                      DebugWarning("Startup: Energy-Yesterday: " + Number(s_tempjson.ENERGY.Yesterday));
                                      await setStateAsync(s_state_FullPath + ".Energy-Today", Number(s_tempjson.ENERGY.Today), true);
                                      DebugWarning("Startup: Energy-Today: " + Number(s_tempjson.ENERGY.Today));
                                      await setStateAsync(s_state_FullPath + ".Energy-Power", Number(s_tempjson.ENERGY.Power), true);
                                      DebugWarning("Startup: Energy-Power: " + Number(s_tempjson.ENERGY.Power));
                                      if (isNaN(Number(s_tempjson.ENERGY.Voltage))) {
                                          await setStateAsync(s_state_FullPath + ".Energy-Voltage", 0, true);
                                      } else {
                                          await setStateAsync(s_state_FullPath + ".Energy-Voltage", Number(s_tempjson.ENERGY.Voltage), true);
                                      }
                                      DebugWarning("Startup: Energy-Voltage: " + Number(s_tempjson.ENERGY.Voltage));
                                      if (isNaN(Number(s_tempjson.ENERGY.Current))) {
                                          await setStateAsync(s_state_FullPath + ".Energy-Current", 0, true);
                                      } else {
                                          await setStateAsync(s_state_FullPath + ".Energy-Current", Number(s_tempjson.ENERGY.Current), true);
                                      };
                                      DebugWarning("Startup: Energy-Current: " + Number(s_tempjson.ENERGY.Current));
                                      if (b_Temperature == true) {
                                          await setStateAsync(s_state_FullPath + ".Temperature", Number(s_tempjson.ANALOG.Temperature), true);
                                          DebugWarning("Startup: Temperature: " + Number(s_tempjson.ANALOG.Temperature));
                                      }
                                  }
                              }
                          }
                      }
                      catch (error) {
                          DebugWarning(error);
                          log(error);
                      }
                  }
                  
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  //  _____        _                               _    _       
                  // |  __ \      | |                             | |  | |      
                  // | |  | | __ _| |_ ___ _ __  _ __  _   _ _ __ | | _| |_ ___ 
                  // | |  | |/ _` | __/ _ \ '_ \| '_ \| | | | '_ \| |/ / __/ _ \
                  // | |__| | (_| | ||  __/ | | | |_) | |_| | | | |   <| ||  __/
                  // |_____/ \__,_|\__\___|_| |_| .__/ \__,_|_| |_|_|\_\\__\___|
                  //                            | |                             
                  //                            |_|    
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  // Zielpunkte anlegen falls noch nicht vorhanden
                  //DebugWarning("Startup: Erstelle ggf. Datenpunkte ...");
                  // Das erstellen machen wir in einer async Funktion
                  CreateMyStatesAndStartup();
                  
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  //   _____ _             _               
                  //  / ____| |           | |              
                  // | (___ | |_ __ _ _ __| |_ _   _ _ __  
                  //  \___ \| __/ _` | '__| __| | | | '_ \ 
                  //  ____) | || (_| | |  | |_| |_| | |_) |
                  // |_____/ \__\__,_|_|   \__|\__,_| .__/ 
                  //                                | |    
                  //                                |_|    
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  // Ist nun in die Funktion CreateMyStatesAndStartup(); integriert
                  
                  
                  
                  
                  
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  //   _____       _                   _       _   _                 
                  //  / ____|     | |                 (_)     | | (_)                
                  // | (___  _   _| |__  ___  ___ _ __ _ _ __ | |_ _  ___  _ __  ___ 
                  //  \___ \| | | | '_ \/ __|/ __| '__| | '_ \| __| |/ _ \| '_ \/ __|
                  //  ____) | |_| | |_) \__ \ (__| |  | | |_) | |_| | (_) | | | \__ \
                  // |_____/ \__,_|_.__/|___/\___|_|  |_| .__/ \__|_|\___/|_| |_|___/
                  //                                    | |                          
                  //                                    |_|                          
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  // Status einlesen und nach javascript.0 schreiben wenn per MQTT etwas neues reinkommt
                  // Wird aufgerufen wenn eine MQTT-POWER Meldung reinkommt. Die wird bei jedem Ein-/Ausschalten erzeugt egal ob
                  // ioBroker, ein Schalter, Fernbedienung oder ein Klick in der Weboberfläche das ausgelöst hat
                  // change: "ne" sollte dafür sorgen das es nur aufgerufen wird wenn der Wert sich vom vorherigen unterscheidet
                  //on({ id: [].concat(Array.prototype.slice.apply($('channel[state.id=mqtt.0.stat.Gosund166.POWER*]'))), change: 'ne' },
                  //on({ id: Array.prototype.slice.apply($("channel[state.id="+s_mqtt_POWER_path+"]")), change: "ne" }, function (obj) {
                  if (b_hcsr04 == false) {
                      on({ id: Array.prototype.slice.apply($("channel[state.id="+s_mqtt_POWER_path+"]")), change: "ne" }, function (obj) {
                      //on({ id: s_mqtt_POWER_path, change: "ne" }, function (obj) {
                          // DebugWarning("Subscription on() START: " + s_mqtt_POWER_path);
                          DebugWarning("Subscription on() START: " + obj.id);
                          // POWER oder POWER1..x ? Lässt sich aus dem Datenpunktnamen ermitteln, obj.id
                          let s_powernumber = String(obj.id).slice(-1);
                          if (s_powernumber === "R") {
                              s_powernumber = ""
                          }
                          
                          // Der aktuelle Status der gerade gekommen ist: ON oder OFF
                          var s_value_mqtt = obj.state.val;
                          // Wir holen den Status den wir aktuell unterhalb von JavaScript gespeichert habem
                          var s_value_javascript = getState(s_state_power_path + s_powernumber).val;
                          // Auswerten von ON und OFF und umsetzung on true oder false
                          var b_helper_mqtt = false;
                          if (s_value_mqtt == 'ON') {
                              b_helper_mqtt = true;
                          } else {
                              b_helper_mqtt = false;
                          }
                          // prüfen ob die Werte wirklich ungleich sein sind und wir was ändern müssen
                          if (b_helper_mqtt != s_value_javascript) {
                              if (s_value_mqtt == 'ON') {
                                  setState(s_state_power_path, true, true);
                                  if (b_HourMeter == true) {
                                      // Aktuelle Uhrzeit wegschreiben - Einschalten
                                      i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
                                      setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
                                  }
                                  // @ts-ignore
                                  if (b_UseSystemEventLog == true) {
                                      createEventlog(s_DeviceName, 'ON (per MQTT stat-POWER' + s_powernumber + ')');
                                  }
                                  DebugWarning("Subscription on() STATUS: " + s_mqtt_POWER_path + s_powernumber + ": ON");
                              } else {
                                  setState(s_state_power_path, false, true);
                                  if (b_HourMeter == true) {
                                      // Aktuelle Uhrzeit wegschreiben - Ausschalten
                                      i_global_unixtimeSwitchedOff = Math.floor(Date.now() / 1000);
                                      setState(s_state_FullPath + ".tmp.unixtimeSwitchedOff", i_global_unixtimeSwitchedOff, true);
                                      CalculateSwitchedOnDuration();
                                      // Aktuelle Einschaltzeit auf 0 setzen
                                      setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, true);
                                      setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", true);
                                  }
                                  if (b_UseSystemEventLog == true) {
                                      createEventlog(s_DeviceName, 'OFF (per MQTT stat-POWER)');
                                  }
                  
                                  DebugWarning("Subscription on() STATUS: " + s_mqtt_POWER_path + s_powernumber + ": OFF");
                  
                              }
                          }
                          DebugWarning("Subscription on() ENDE: " + s_mqtt_POWER_path + s_powernumber);
                      });
                  }
                  
                  // ####################################################################################################################################################
                  // Status setzen nachdem der JavaScript-Datenpunkt geändert wurde (den, den wir z.B. für Widgets in VIS verwenden)
                  // fromNe: o_js_Instance sorgt dafür das es NICHT angetriggert wird wenn der Datenpunkt durch diese JavaScript Instanz geändert wurde.
                  // zusätzlich prüfen wir ob ohne Bestätigung geschrieben wurde
                  // Wenn also eine MQTT Auswertung einer der anderen on() der Grund war wird dies hier NICHT aufgerufen
                  // Die Variable o_js_Instance wird oben bei den Variablen-Definitionen gesetzt
                  if (b_hcsr04 == false) {
                      var s_state_power_path_multi = s_state_power_path;
                      if (i_NumberOfPower > 1) {
                          s_state_power_path_multi = s_state_power_path_multi + "*"
                      }
                      on({ id: Array.prototype.slice.apply($("channel[state.id="+s_state_power_path_multi+"]")), change: "ne", fromNe: o_js_Instance, ack: false }, function (obj) {
                      // on({ id: s_state_power_path, change: "ne", fromNe: o_js_Instance, ack: false }, function (obj) {
                          // DebugWarning("Subscription on() START: " + s_state_power_path);
                          DebugWarning("Subscription on() START: " + obj.id);
                          var s_value_mqtt = obj.state.val;
                          // POWER oder POWER1..x ? Lässt sich aus dem Datenpunktnamen ermitteln, obj.id
                          let s_powernumber = String(obj.id).slice(-1);
                          if (s_powernumber === "R") {
                              s_powernumber = ""
                          }
                  
                          //var s_value_javascript = getState(s_state_power_path + s_powernumber).val;
                          var b_helper_mqtt = false;
                          // Beides nach Boolean bringen
                          /*if (s_value_mqtt == 'ON') {
                              b_helper_mqtt = true;
                          } else {
                              b_helper_mqtt = false;
                          } */
                          if (s_value_mqtt == true) {
                              //setState(s_mqtt_CMND_path + s_powernumber, 'ON', false);
                              //DebugWarning(s_mqtt_CMND_path + s_powernumber + ': ON')
                              sendTo(s_mqtt_Instance, 'sendMessage2Client', {topic: 'cmnd/' + s_DeviceName + '/POWER' + s_powernumber, message: 'ON'});
                              DebugWarning(s_mqtt_Instance + ": sendMessage2Client: " + 'cmnd/' + s_DeviceName + '/POWER' + s_powernumber + ": ON")
                              // Quelldatenpunkt auf bestätigt setzen
                              setState(obj.id, true, true);
                              if (b_UseSystemEventLog == true) {
                                  createEventlog(s_DeviceName, 'ON ' + s_powernumber + '(per Datenpunkt JavaScript)');
                              }
                              if (b_HourMeter == true) {
                                  // Aktuelle Uhrzeit wegschreiben - Einschalten
                                  i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
                                  setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
                                  // Aktuelle Einschaltdauer auf 0 setzen
                                  setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, true);
                                  setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", true);
                              }
                              DebugWarning("Subscription on() STATUS: " + s_state_power_path + s_powernumber + ": ON");
                          } else {
                              //setState(s_mqtt_CMND_path + s_powernumber, 'OFF', false);
                              //DebugWarning(s_mqtt_CMND_path + s_powernumber + ': OFF')
                              sendTo(s_mqtt_Instance, 'sendMessage2Client', {topic: 'cmnd/' + s_DeviceName + '/POWER' + s_powernumber, message: 'OFF'});
                              DebugWarning(s_mqtt_Instance + ": sendMessage2Client: " + 'cmnd/' + s_DeviceName + '/POWER' + s_powernumber + ": OFF")
                              // Quelldatenpunkt auf bestätigt setzen
                              setState(obj.id, false, true);
                              if (b_UseSystemEventLog == true) {
                                  createEventlog(s_DeviceName, 'OFF ' + s_powernumber + ' (per Datenpunkt JavaScript)');
                              }
                              if (b_HourMeter == true) {
                                  // Letzte Laufzeit ausrechnen und wegschreiben
                                  i_global_unixtimeSwitchedOff = Math.floor(Date.now() / 1000);
                                  setState(s_state_FullPath + ".tmp.unixtimeSwitchedOff", i_global_unixtimeSwitchedOff, true);
                                  CalculateSwitchedOnDuration();
                                  // Aktuelle Einschaltzeit auf 0 setzen
                                  setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, true);
                                  setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", true);
                              }
                              DebugWarning("Subscription on() STATUS: " + s_state_power_path + s_powernumber + ": OFF");
                          }
                          DebugWarning("Subscription on() ENDE: " + s_state_power_path + s_powernumber);
                      });
                  }
                  
                  // ####################################################################################################################################################
                  // Tasmota sendet seinen Status und Infos regelmäßig per MQTT als JSON, Default sind alle 300 Sekunden
                  // das nutzen wir aus um weitere Daten zu erfassen
                  // ####################################################################################################################################################
                  // STATUS Meldung
                  on({ id: s_mqtt_STATE_path, change: "ne" }, function (json) {
                      DebugWarning("Subscription on() START: " + s_mqtt_STATE_path);
                      try {
                          var obj = JSON.parse(json.state.val);
                  
                          let myBSSId = String(obj.Wifi.BSSId);
                          if (b_GetNameOfAccessPoints == true) {
                              myAccessPoint = String(getState(s_AccessPoints_path + myBSSId).val);
                          }
                          if (b_hcsr04 == false) {
                              if (i_NumberOfPower == 1) {
                                  var b_helper_mqtt = false;
                                  if (obj.POWER == "ON") {
                                      b_helper_mqtt = true;
                                  } else {
                                      b_helper_mqtt = false;
                                  }
                                  if (b_helper_mqtt != getState(s_state_FullPath + ".POWER").val) {
                                      setState(s_state_FullPath + ".POWER", b_helper_mqtt);
                                      if (obj.POWER == 'ON') {
                                          if (b_UseSystemEventLog == true) {
                                              createEventlog(s_DeviceName, 'ON (per MQTT tele-STATE Meldung)');
                                          }
                                      } else {
                                          if (b_UseSystemEventLog == true) {
                                              createEventlog(s_DeviceName, 'OFF (per MQTT tele-STATE Meldung)');
                                          }
                                      }
                                  }
                              }
                          } else {
                              var b_helper_mqtt = false;
                              for (let i = 1; i < (i_NumberOfPower + 1); i++) {
                                  b_helper_mqtt = false;
                                  if (obj["POWER" + i] == "ON") {
                                      b_helper_mqtt = true;
                                  } else {
                                      b_helper_mqtt = false;
                                  }
                                  if (b_helper_mqtt != getState(s_state_FullPath + ".POWER" + i).val) {
                                      setState(s_state_FullPath + ".POWER" + i, b_helper_mqtt);
                                      if (obj["POWER" + i] == 'ON') {
                                          if (b_UseSystemEventLog == true) {
                                              createEventlog(s_DeviceName, 'ON ' + i + ' (per MQTT tele-STATE Meldung)');
                                          }
                                      } else {
                                          if (b_UseSystemEventLog == true) {
                                              createEventlog(s_DeviceName, 'OFF ' + i + ' (per MQTT tele-STATE Meldung)');
                                          }
                                      }
                                  }
                  
                              }
                          }
                  
                          setState(s_state_FullPath + ".RSII", Number(obj.Wifi.RSSI), true);
                          setState(s_state_FullPath + ".BSSId", myBSSId, true);
                          if (b_GetNameOfAccessPoints == true) {
                              setState(s_state_FullPath + ".AccessPoint", myAccessPoint, true);
                          }
                          setState(s_state_FullPath + ".Channel", Number(obj.Wifi.Channel), true);
                          // POWER prüfen ob die Werte wirklich ungleich sein sind und nur dann schreiben
                      } catch (e) {
                          DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_STATE_path + " : " + e);
                          return;
                      }
                      DebugWarning("Subscription on() ENDE: " + s_mqtt_STATE_path);
                  });
                  // ####################################################################################################################################################
                  // INFO1 Meldung (enthält Gerätetyp und Firmwareversion)
                  on({ id: s_mqtt_INFO1_path, change: "any" }, function (json) {
                      DebugWarning("Subscription on() START: " + s_mqtt_INFO1_path);
                      try {
                          var obj = JSON.parse(json.state.val);
                          if (b_Firmware95 == false) {
                              // bis Tasmota Version 9.3.1
                              setState(s_state_FullPath + ".DeviceType", String(obj.Module), true);
                              setState(s_state_FullPath + ".Version", String(obj.Version), true);
                          } else {
                              // ab Tasmota Version 9.5
                              setState(s_state_FullPath + ".DeviceType", String(obj.Info1.Module), true);
                              setState(s_state_FullPath + ".Version", String(obj.Info1.Version), true);
                          }
                      } catch (e) {
                          DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_INFO1_path);
                          return;
                      }
                      DebugWarning("Subscription on() ENDE: " + s_mqtt_INFO1_path);
                  });
                  // ####################################################################################################################################################
                  // INFO2 Meldung (enthält die IP-Adresse)
                  on({ id: s_mqtt_INFO2_path, change: "any" }, function (json) {
                      DebugWarning("Subscription on() START: " + s_mqtt_INFO2_path);
                      try {
                          var obj = JSON.parse(json.state.val);
                          if (b_Firmware95 == false) {
                              // bis Tasmota Version 9.3.1
                              setState(s_state_FullPath + ".IPAddress", String(obj.IPAddress), true);
                          } else {
                              // ab Tasmota Version 9.5
                              setState(s_state_FullPath + ".IPAddress", String(obj.Info2.IPAddress), true);
                          }
                      } catch (e) {
                          DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_INFO2_path);
                          return;
                      }
                      DebugWarning("Subscription on() ENDE: " + s_mqtt_INFO2_path);
                  });
                  // ####################################################################################################################################################
                  // stat/.../STATUS Meldung (enthält den FriendlyName)
                  on({ id: s_mqtt_STATUS_path, change: "any" }, function (json) {
                      DebugWarning("Subscription on() START: " + s_mqtt_STATUS_path);
                      try {
                          var obj = JSON.parse(json.state.val);
                          if (b_Firmware95 == false) {
                              // bis Tasmota Version 9.3.1
                              setState(s_state_FullPath + ".FriendlyName", String(obj.FriendlyName), true);
                          } else {
                              // ab Tasmota Version 9.5
                              setState(s_state_FullPath + ".FriendlyName", String(obj.Status.FriendlyName[0]), true);
                          }
                      } catch (e) {
                          DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_STATUS_path);
                          return;
                      }
                      DebugWarning("Subscription on() ENDE: " + s_mqtt_STATUS_path);
                  });
                  
                  
                  // ####################################################################################################################################################
                  // SENSOR Meldung Stromverbrauch
                  // Wird nur beachtet wenn der Parameter am Skriptanfang gesetzt wird
                  // @ts-ignore
                  if (b_Energy == true) {
                      on({ id: s_mqtt_SENSOR_path, change: "any" }, function (json) {
                          DebugWarning("Subscription on() START: " + s_mqtt_SENSOR_path + " (Energy)");
                          try {
                              var obj = JSON.parse(json.state.val);
                              if (b_Firmware95 == false) {
                                  // bis Tasmota Version 9.3.1
                                  // Muss ich noch nachprüfen, hab nur noch Tasmota 10 Geräte
                              } else {
                                  // ab Tasmota Version 9.5
                                  setState(s_state_FullPath + ".Energy-Total", Number(obj.ENERGY.Total), true);
                                  setState(s_state_FullPath + ".Energy-Yesterday", Number(obj.ENERGY.Yesterday), true);
                                  setState(s_state_FullPath + ".Energy-Today", Number(obj.ENERGY.Today), true);
                                  setState(s_state_FullPath + ".Energy-Power", Number(obj.ENERGY.Power), true);
                                  if (isNaN(Number(obj.ENERGY.Voltage))) {
                                      setState(s_state_FullPath + ".Energy-Voltage", 0, true);
                                  } else {
                                      setState(s_state_FullPath + ".Energy-Voltage", Number(obj.ENERGY.Voltage), true);
                                  };
                                  if (isNaN(Number(obj.ENERGY.Current))) {
                                      setState(s_state_FullPath + ".Energy-Current", 0, true);
                                  } else {
                                      setState(s_state_FullPath + ".Energy-Current", Number(obj.ENERGY.Current), true);
                                  }
                                  if (b_Temperature == true) {
                                      setState(s_state_FullPath + ".Temperature", Number(obj.ANALOG.Temperature), true);
                                  }
                              }
                          } catch (e) {
                              DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_SENSOR_path);
                              return;
                          }
                          DebugWarning("Subscription on() ENDE: " + s_mqtt_SENSOR_path);
                      });
                  }
                  // ####################################################################################################################################################
                  // SENSOR Meldung EasyMeterQ3A
                  // @ts-ignore
                  if (b_EasyMeterQ3A == true) {
                      on({ id: s_mqtt_SENSOR_path, change: "any" }, function (json) {
                          DebugWarning("Subscription on() START: " + s_mqtt_SENSOR_path + " (EasyMeterQ3A)");
                          /*
                          {"Time":"2023-04-04T23:07:45",
                              "SML":{
                                  "Verbrauch_T1":95.4412923,
                                  "Verbrauch_T2":0.2737477,
                                  "Verbrauch_Summe":95.7150401,
                                  "Einspeisung_Summe":101.5756287,
                                  "Watt_L1":2803.85,
                                  "Watt_L2":1062.85,
                                  "Watt_L3":242.30,
                                  "Watt_Summe":4109.01,
                                  "Volt_L1":235.9,
                                  "Volt_L2":236.3,
                                  "Volt_L3":236.2}}
                          */
                          try {
                              var obj = JSON.parse(json.state.val);
                              setState(s_state_FullPath + ".Verbrauch-Summe", Number(obj.SML.Verbrauch_Summe), true);
                              setState(s_state_FullPath + ".Einspeisung-Summe", Number(obj.SML.Einspeisung_Summe), true);
                              setState(s_state_FullPath + ".Watt-L1", Number(obj.SML.Watt_L1), true);
                              setState(s_state_FullPath + ".Watt-L2", Number(obj.SML.Watt_L2), true);
                              setState(s_state_FullPath + ".Watt-L3", Number(obj.SML.Watt_L3), true);
                              setState(s_state_FullPath + ".Watt-Summe", Number(obj.SML.Watt_Summe), true);
                              setState(s_state_FullPath + ".Volt-L1", Number(obj.SML.Volt_L1), true);
                              setState(s_state_FullPath + ".Volt-L2", Number(obj.SML.Volt_L2), true);
                              setState(s_state_FullPath + ".Volt-L3", Number(obj.SML.Volt_L3), true);
                          } catch (e) {
                              DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_SENSOR_path);
                              return;
                          }
                          DebugWarning("Subscription on() ENDE: " + s_mqtt_SENSOR_path);
                      });
                  }
                  // ####################################################################################################################################################
                  // SENSOR Meldung Ultraschall Entfernungsmessung
                  // Wird nur beachtet wenn der Parameter am Skriptanfang gesetzt wird
                  // @ts-ignore
                  if (b_hcsr04 == true) {
                      on({ id: s_mqtt_SENSOR_path, change: "any" }, function (json) {
                          DebugWarning("Subscription on() START: " + s_mqtt_SENSOR_path + " (HC-SR04)");
                          try {
                              var obj = JSON.parse(json.state.val);
                              if (b_Firmware95 == false) {
                                  // bis Tasmota Version 9.3.1
                                  // Muss ich noch nachprüfen, hab nur noch Tasmota 10 Geräte
                              } else {
                                  // ab Tasmota Version 9.5
                                  setState(s_state_FullPath + ".Distance", Number(obj.SR04.Distance), true);
                              }
                          } catch (e) {
                              DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_SENSOR_path);
                              return;
                          }
                          DebugWarning("Subscription on() ENDE: " + s_mqtt_SENSOR_path);
                      });
                  }
                  
                  
                  // ####################################################################################################################################################
                  // ####################################################################################################################################################
                  
                  

                  Im Skript müsst Ihr oben in Zeile 2 den Namen einsetzen den Ihr beim Tasmota-Gerät als Topic eingestellt habt. Unter diesen Namen tauchen auch die Einträge in den Topics /tele etc. auf.
                  Das Suffix in Zeile 3 könnte ihr leer lassen, ansonsten wird es an den Namen des Gerätes angehängt bei dem Stammpfad unterhalb von 0_userdata.0.tasmota.xxx
                  In Zeile 10 könnt Ihr die Anzahl der Schaltbaren Ausgänge einstellen, normalerweise 1

                  // Anzahl der schaltbaren Ausgänge, 1 bis x, 1 = nur POWER, ab 2 und mehr POWER1, POWER2 usw.
                  var i_NumberOfPower = 1;
                  

                  In Zeile 23 könnte ihr ggf. die MQTT-Instanz anpassen

                  // Name der MQTT-Instanz
                  var s_mqtt_Instance = "mqtt.0";
                  

                  Dann startet das Skript. Beim ersten mal werden die Datenpunkte angelegt.

                  In Zeile 27 gibt es den Eintrag

                  var b_logging = false;
                  

                  Wenn Ihr den auf true setzt so bekommt Ihr Statusmeldungen im Log und in der JavaScript-Konsole. Das würde ich nur zum testen anmachen und auf keinen Fall für alle Geräte.

                  Pro Tasmota-Gerät braucht Ihr eine neue Kopie des Skriptes!
                  In ioBroker sieht das dann so bei den Datenpunkten aus:
                  01f7f533-97b7-4a3e-8409-c152909193e5-image.png


                  Sonderfunktionen 1: Eventlog
                  Es gibt eine Funktion createEventlog ab Zeile 213:

                  function createEventlog(EventType, EventText) {
                      let tasmotaEventListDestination = "0_userdata.0.EventLog.Tasmota.";
                      // vorhandene Einträge einlesen
                      let EventList = getState(tasmotaEventListDestination + "EventLogTasmota").val;
                      // Anzahl der Maximal erlaubten Einträge einlesen
                      let maxEventCount = getState("0_userdata.0.EventLog.Tasmota.maxEventCount").val;
                  

                  Um diese zu Verwenden muss man die folgenden 3 Datenpunkte von Hand erstellen:

                  0_userdata.0.EventLog.Tasmota.EventLogTasmota => String
                  0_userdata.0.EventLog.Tasmota.NextEventId => Zahl
                  0_userdata.0.EventLog.Tasmota.maxEventCount  => Zahl => Wert 1024 oder nach Wunsch
                  

                  de7da837-f623-49aa-993c-889cece3a4eb-image.png

                  Das Eventlogging schaltet man dann in Zeile 86 ein:

                  // Zentrales Log über alle Ein- und Ausschaltvorgänge führen
                  var b_UseSystemEventLog = true;
                  

                  Er führt dann eine Ereignisliste die man sich in einem HTML-Widget ausgeben lassen kann:

                  0008686 - 29.09.24 11:29:00 - Steckdose-2-142 - OFF (per MQTT stat-POWER)
                  0008685 - 29.09.24 11:29:00 - Steckdose-2-141 - OFF (per MQTT stat-POWER)
                  0008684 - 29.09.24 11:28:00 - Steckdose-2-141 - ON (per MQTT stat-POWER)
                  0008683 - 29.09.24 11:27:00 - Steckdose-2-147 - OFF (per MQTT stat-POWER)
                  0008682 - 29.09.24 11:27:00 - Steckdose-2-142 - ON (per MQTT stat-POWER)
                  0008681 - 29.09.24 11:27:00 - Steckdose-2-141 - OFF (per MQTT stat-POWER)
                  0008680 - 29.09.24 11:26:00 - Steckdose-2-141 - ON (per MQTT stat-POWER)
                  0008679 - 29.09.24 11:25:00 - Steckdose-2-141 - OFF (per MQTT stat-POWER)
                  0008678 - 29.09.24 11:25:00 - Steckdose-2-142 - OFF (per MQTT stat-POWER)
                  0008677 - 29.09.24 11:25:00 - Steckdose-2-147 - ON (per MQTT stat-POWER)
                  0008676 - 29.09.24 11:24:00 - Steckdose-2-142 - ON (per MQTT stat-POWER)
                  0008675 - 29.09.24 11:23:00 - Steckdose-2-141 - ON (per MQTT stat-POWER)
                  0008674 - 29.09.24 11:19:51 - Gosund166 - ON 1(per Datenpunkt JavaScript)
                  0008673 - 29.09.24 11:19:46 - Gosund166 - OFF 1 (per Datenpunkt JavaScript)
                  0008672 - 29.09.24 11:17:27 - Gosund166 - ON 1(per Datenpunkt JavaScript)
                  0008671 - 29.09.24 11:16:49 - Gosund166 - OFF 1 (per Datenpunkt JavaScript)
                  0008670 - 29.09.24 11:10:40 - Gosund166 - OFF 1 (per Datenpunkt JavaScript)
                  0008669 - 29.09.24 11:06:40 - Gosund166 - ON 1(per Datenpunkt JavaScript)
                  0008668 - 29.09.24 11:06:18 - Gosund166 - OFF 1 (per Datenpunkt JavaScript)
                  0008667 - 29.09.24 10:00:56 - K07-Badezimmerspiegel - OFF (per MQTT stat-POWER)
                  0008666 - 29.09.24 09:53:38 - K07-Badezimmerspiegel - ON (per MQTT stat-POWER)
                  0008665 - 29.09.24 09:50:31 - K07-Badezimmerspiegel - OFF (per MQTT stat-POWER)
                  0008664 - 29.09.24 09:50:31 - K06-Licht-Badezimmer - OFF (per MQTT stat-POWER)
                  0008663 - 29.09.24 09:46:44 - K07-Badezimmerspiegel - ON (per MQTT stat-POWER)
                  0008662 - 29.09.24 09:46:42 - K06-Licht-Badezimmer - ON (per MQTT stat-POWER)
                  0008661 - 29.09.24 09:18:10 - K07-Badezimmerspiegel - OFF (per MQTT stat-POWER)
                  0008660 - 29.09.24 09:04:38 - K07-Badezimmerspiegel - ON (per MQTT stat-POWER)
                  0008659 - 29.09.24 08:23:00 - Steckdose-2-145 - OFF (per Datenpunkt JavaScript)
                  


                  Sonderfunktionen 1: AccessPoints
                  Ich lasse mir bei meinen Geräten anzeigen mit welchen meiner AccessPoints diese verbunden sind:
                  7ed38255-cc6b-4edc-b3bb-a54fcedeecfc-image.png

                  Wer das auch will muss unterhalb von

                  0_userdata.0.001-Konstanten.WLAN.
                  

                  Seine AccessPoints mit deren BSSId als Datenpunktnamen als String anlegen, als Wert dann den Namen des AccessPoint:
                  a0eb167c-433d-40c7-b89a-7d9782a6fb79-image.png

                  Dann kann man das in Zeile 82 Einschalten:

                  // Private Einstellungen die nur für meine Umgebung funktionieren oder von euch zuerst die Voraussetzungen geschafft werden müssen
                  // Soll der Name des AccessPoints ermittelt werden?
                  // @ts-ignore
                  var b_GetNameOfAccessPoints = true;
                  // Pfad für das auslesen des AccessPoints. Dort gibt es für jeden AccessPoint einen Datenpunkt vom Typ String welcher die MAC als ID und den Namen als Wert hat
                  var s_AccessPoints_path = "0_userdata.0.001-Konstanten.WLAN.";
                  
                  M Offline
                  M Offline
                  McChip
                  schrieb am zuletzt editiert von McChip
                  #13

                  @bananajoe sagte in Tasmota Steckdosen per MQTT + JavaScript direkt ansteuern:

                  Ich habe das Script soeben bei mir angelegt - doch leider bekommen ich den Powerwert der Gosund SP1 Steckdose nicht übermittelt. Weißt du wie ich den Wert erhalte?
                  (alle anderen Werte sind wie bei Dir da)

                  Vielen Dank schon einmal für einen Tipp!

                  BananaJoeB 1 Antwort Letzte Antwort
                  0
                  • M McChip

                    @bananajoe sagte in Tasmota Steckdosen per MQTT + JavaScript direkt ansteuern:

                    Ich habe das Script soeben bei mir angelegt - doch leider bekommen ich den Powerwert der Gosund SP1 Steckdose nicht übermittelt. Weißt du wie ich den Wert erhalte?
                    (alle anderen Werte sind wie bei Dir da)

                    Vielen Dank schon einmal für einen Tipp!

                    BananaJoeB Offline
                    BananaJoeB Offline
                    BananaJoe
                    Most Active
                    schrieb am zuletzt editiert von BananaJoe
                    #14

                    @mcchip ich habe den ersten Post bearbeitet und dort nun meine aktuelle Version 1.18 hinterlegt.
                    In dieser kannst du im Setup am Anfang ein- oder ausschalten ob die Energie- und Temperaturwerte mit ausgewertet werden sollen.

                    Zudem wird alles nun unter 0_userdate.0.tasmota angelegt (was man im Skript einstellen kann).
                    die letzten 12 Versionen waren diverse Fehlerbereinigungen (Probleme mit Zahlen und Strings) aber auch Datenpunkte in denen ich sehen kann welche Skriptversion es ist und wo das Skript gespeichert ist. da dachte das es wohl eh keiner nutzt habe ich das hier nicht gepflegt.
                    Im Moment läuft das Skript 108 mal bei mir, inklusive Spezialversionen (2 Steckdosen, Display)

                    Sollte es beim Start eine Warnung geben einfach nochmal neu starten, bei der nächsten Version wird auch das weg sein.

                    Das mit der automatischen Erkennung habe ich immer noch nicht drin :-( wobei der Aufwand dafür überschaubar wäre.

                    ioBroker@Ubuntu 24.04 LTS (VMware) für: >260 Geräte, 5 Switche, 7 AP, 9 IP-Cam, 1 NAS 42TB, 1 ESXi 15TB, 4 Proxmox 1TB, 1 Hyper-V 48TB, 14 x Echo, 5x FireTV, 5 x Tablett/Handy VIS || >=160 Tasmota/Shelly || >=95 ZigBee || PV 8.1kW / Akku 14kWh || 2x USV 750W kaskadiert || Creality CR-10 SE 3D-Drucker

                    M 2 Antworten Letzte Antwort
                    0
                    • BananaJoeB BananaJoe

                      @mcchip ich habe den ersten Post bearbeitet und dort nun meine aktuelle Version 1.18 hinterlegt.
                      In dieser kannst du im Setup am Anfang ein- oder ausschalten ob die Energie- und Temperaturwerte mit ausgewertet werden sollen.

                      Zudem wird alles nun unter 0_userdate.0.tasmota angelegt (was man im Skript einstellen kann).
                      die letzten 12 Versionen waren diverse Fehlerbereinigungen (Probleme mit Zahlen und Strings) aber auch Datenpunkte in denen ich sehen kann welche Skriptversion es ist und wo das Skript gespeichert ist. da dachte das es wohl eh keiner nutzt habe ich das hier nicht gepflegt.
                      Im Moment läuft das Skript 108 mal bei mir, inklusive Spezialversionen (2 Steckdosen, Display)

                      Sollte es beim Start eine Warnung geben einfach nochmal neu starten, bei der nächsten Version wird auch das weg sein.

                      Das mit der automatischen Erkennung habe ich immer noch nicht drin :-( wobei der Aufwand dafür überschaubar wäre.

                      M Offline
                      M Offline
                      McChip
                      schrieb am zuletzt editiert von
                      #15

                      @bananajoe Super Danke Dir. Werde gleich heute Abend testen!

                      1 Antwort Letzte Antwort
                      0
                      • BananaJoeB BananaJoe

                        @mcchip ich habe den ersten Post bearbeitet und dort nun meine aktuelle Version 1.18 hinterlegt.
                        In dieser kannst du im Setup am Anfang ein- oder ausschalten ob die Energie- und Temperaturwerte mit ausgewertet werden sollen.

                        Zudem wird alles nun unter 0_userdate.0.tasmota angelegt (was man im Skript einstellen kann).
                        die letzten 12 Versionen waren diverse Fehlerbereinigungen (Probleme mit Zahlen und Strings) aber auch Datenpunkte in denen ich sehen kann welche Skriptversion es ist und wo das Skript gespeichert ist. da dachte das es wohl eh keiner nutzt habe ich das hier nicht gepflegt.
                        Im Moment läuft das Skript 108 mal bei mir, inklusive Spezialversionen (2 Steckdosen, Display)

                        Sollte es beim Start eine Warnung geben einfach nochmal neu starten, bei der nächsten Version wird auch das weg sein.

                        Das mit der automatischen Erkennung habe ich immer noch nicht drin :-( wobei der Aufwand dafür überschaubar wäre.

                        M Offline
                        M Offline
                        McChip
                        schrieb am zuletzt editiert von
                        #16

                        @bananajoe Ich hatte das ein paar Tage später umgesetzt. Leider wird z.B. der Powerwert einmal in die Objektliste eingetragen - egal ob unter 0_userdate.0.tasmota oder im Aliasbereich.
                        Dann wird der Powerwert und andere nicht mehr geändert bis ich den Adapter neu starte.
                        Ob die Steckdose an oder aus ist (true oder false) wird immer sofort angezeigt.
                        Ich bin da echt etwas ratlos.

                        BananaJoeB 1 Antwort Letzte Antwort
                        0
                        • M McChip

                          @bananajoe Ich hatte das ein paar Tage später umgesetzt. Leider wird z.B. der Powerwert einmal in die Objektliste eingetragen - egal ob unter 0_userdate.0.tasmota oder im Aliasbereich.
                          Dann wird der Powerwert und andere nicht mehr geändert bis ich den Adapter neu starte.
                          Ob die Steckdose an oder aus ist (true oder false) wird immer sofort angezeigt.
                          Ich bin da echt etwas ratlos.

                          BananaJoeB Offline
                          BananaJoeB Offline
                          BananaJoe
                          Most Active
                          schrieb am zuletzt editiert von
                          #17

                          @mcchip welche Teleperiod hast du eingestellt? Ab Werk sendet der nur alle 600 Sekunden.
                          Ich nutze zumeist 60 Sekunden, bei den Solarpanelen 15 Sekunden.

                          ioBroker@Ubuntu 24.04 LTS (VMware) für: >260 Geräte, 5 Switche, 7 AP, 9 IP-Cam, 1 NAS 42TB, 1 ESXi 15TB, 4 Proxmox 1TB, 1 Hyper-V 48TB, 14 x Echo, 5x FireTV, 5 x Tablett/Handy VIS || >=160 Tasmota/Shelly || >=95 ZigBee || PV 8.1kW / Akku 14kWh || 2x USV 750W kaskadiert || Creality CR-10 SE 3D-Drucker

                          1 Antwort Letzte Antwort
                          0
                          • M Offline
                            M Offline
                            McChip
                            schrieb am zuletzt editiert von
                            #18

                            @bananajoe

                            ich hatte 100 jetzt 60 - ändert aber nichts.....

                            Jetzt bin ich über ein Video von Stefan "Verdrahtet" gestolpert:
                            "ioBroker #3 - OTA Tasmota Update auf Gosund Zwischenstecker | verdrahtet.info"

                            und dort nimmt er nicht den ioBroker MQTT Server her sondern den Sonoff Adapter, bei einer Tasmota Steckdose.
                            Der Sonoff war bei mir schon installiert - ich musste in der Steckdose nur den Port ändern.
                            Was soll ich sagen - alles da! Die Werte ändern sich innerhalb von 10 Sekunden und es sieht so aus

                            Bildschirm­foto 2023-04-04 um 08.50.17.png

                            J 1 Antwort Letzte Antwort
                            0
                            • M McChip

                              @bananajoe

                              ich hatte 100 jetzt 60 - ändert aber nichts.....

                              Jetzt bin ich über ein Video von Stefan "Verdrahtet" gestolpert:
                              "ioBroker #3 - OTA Tasmota Update auf Gosund Zwischenstecker | verdrahtet.info"

                              und dort nimmt er nicht den ioBroker MQTT Server her sondern den Sonoff Adapter, bei einer Tasmota Steckdose.
                              Der Sonoff war bei mir schon installiert - ich musste in der Steckdose nur den Port ändern.
                              Was soll ich sagen - alles da! Die Werte ändern sich innerhalb von 10 Sekunden und es sieht so aus

                              Bildschirm­foto 2023-04-04 um 08.50.17.png

                              J Offline
                              J Offline
                              Jan1
                              schrieb am zuletzt editiert von
                              #19

                              @mcchip
                              Der Sonoff Adapter ist ein abgespeckter und auf Tasmota zugeschnittener MQTT, somit wesentlich einfacher in der Handhabung, da eh alles schon drin was man dafür braucht ;)
                              Sonoff heißt der Adapter nur, weil Tasmota zu Beginn auf Sonoff Geräten lief und da den Namen quasi adaptiert hatte.

                              M 1 Antwort Letzte Antwort
                              0
                              • J Jan1

                                @mcchip
                                Der Sonoff Adapter ist ein abgespeckter und auf Tasmota zugeschnittener MQTT, somit wesentlich einfacher in der Handhabung, da eh alles schon drin was man dafür braucht ;)
                                Sonoff heißt der Adapter nur, weil Tasmota zu Beginn auf Sonoff Geräten lief und da den Namen quasi adaptiert hatte.

                                M Offline
                                M Offline
                                McChip
                                schrieb am zuletzt editiert von
                                #20

                                @jan1
                                Vielen Dank für deine Antwort.

                                ABER - ich hab nie verstanden warum bei dem MQTT Adapter die Werte unter "Objekte" immer mit Anführungszeichen, hintereinander ankommen. Beim Sonoff-Adapter habe ich jetzt für jeden Wert einen Eintrag und kann die leicht ohne Javaskript dazwischen verwenden. Mag ja sein dass der "kastriert" ist - aber so ist es einfacher.

                                J 1 Antwort Letzte Antwort
                                0
                                • M McChip

                                  @jan1
                                  Vielen Dank für deine Antwort.

                                  ABER - ich hab nie verstanden warum bei dem MQTT Adapter die Werte unter "Objekte" immer mit Anführungszeichen, hintereinander ankommen. Beim Sonoff-Adapter habe ich jetzt für jeden Wert einen Eintrag und kann die leicht ohne Javaskript dazwischen verwenden. Mag ja sein dass der "kastriert" ist - aber so ist es einfacher.

                                  J Offline
                                  J Offline
                                  Jan1
                                  schrieb am zuletzt editiert von Jan1
                                  #21

                                  @mcchip
                                  Das ist doch der exakte Unterschied, der Sonoff Adapter bereitet die Daten schön auf und stellt sie ohne Gefummel direkt zur Verfügung :)
                                  Kastriert ist da nicht richtig, sondern eher aufgewertet. Kastriert bezieht sich dann auf andere MQTT Dinge, die man aber für Tasmota nicht braucht.

                                  M 1 Antwort Letzte Antwort
                                  0
                                  • J Jan1

                                    @mcchip
                                    Das ist doch der exakte Unterschied, der Sonoff Adapter bereitet die Daten schön auf und stellt sie ohne Gefummel direkt zur Verfügung :)
                                    Kastriert ist da nicht richtig, sondern eher aufgewertet. Kastriert bezieht sich dann auf andere MQTT Dinge, die man aber für Tasmota nicht braucht.

                                    M Offline
                                    M Offline
                                    McChip
                                    schrieb am zuletzt editiert von
                                    #22

                                    @jan1 Jetzt wird ein Schuh draus - Danke Dir! :face_with_cowboy_hat:

                                    1 Antwort Letzte Antwort
                                    0
                                    • BananaJoeB Offline
                                      BananaJoeB Offline
                                      BananaJoe
                                      Most Active
                                      schrieb am zuletzt editiert von
                                      #23

                                      Also mein Skript reagiert auf die Änderungen an den MQTT-Datenpunkten.
                                      Stromverbrauch etc. ist also abhängig davon wie oft da Daten reinkommen => TelePeriod

                                      Die Daten müssen natürlich auch im MQTT ankommen / sich aktualsieren.
                                      Und im Script muss die Option var b_Energy = true; auch gesetzt sein (gleich am Anfang)

                                      ioBroker@Ubuntu 24.04 LTS (VMware) für: >260 Geräte, 5 Switche, 7 AP, 9 IP-Cam, 1 NAS 42TB, 1 ESXi 15TB, 4 Proxmox 1TB, 1 Hyper-V 48TB, 14 x Echo, 5x FireTV, 5 x Tablett/Handy VIS || >=160 Tasmota/Shelly || >=95 ZigBee || PV 8.1kW / Akku 14kWh || 2x USV 750W kaskadiert || Creality CR-10 SE 3D-Drucker

                                      1 Antwort Letzte Antwort
                                      0
                                      • BananaJoeB BananaJoe

                                        @crunchip Jepp, da hast du recht. Leider. Eine optimale Lösung dafür ist mir noch nicht eingefallen, ich wäre aber für Vorschläge zu haben :-)

                                        Es unter common zu setzen halte ich auch nicht für gut (dann als Funktion).

                                        In der Regel entwickle ich auf einem Gerät ... und dann halt Fleißarbeit. Ich muss ja nur Copy & Paste nach den ersten beiden Zeilen machen.

                                        R Offline
                                        R Offline
                                        randomuser123
                                        schrieb am zuletzt editiert von
                                        #24

                                        @bananajoe Hi, bezüglich den 60 scripten: Ich habe für mich eine Lösung gefunden die mit nur einem Script funktioniert. Ist zwar in meinem Fall gedacht für ein zigbee2tasmota Gerät, aber da dieses letztendlich auch "nur" tasmota messages verschickt, könnte es (mit ein paar Anpassungen) auch für dich funktionieren. Kannst es dir bei Gelegenheit ja mal anschauen: https://forum.iobroker.net/topic/64570/full-zigbee2tasmota-integration/3?_=1682971332108

                                        Viele Grüße

                                        1 Antwort Letzte Antwort
                                        0
                                        • BananaJoeB BananaJoe

                                          Changelog:

                                          • 31.10.2021 erste öffentliche Version 1.6
                                          • 02.03.2023 Version 1.18
                                          • 29.09.2024 Version 1.24

                                          Noch in Entwicklung / geplant:

                                          • Firmware + Gerätetyp (Steckdose oder Licht/Dimmer/RGB) automatisch erkennen
                                          • Umgang mit Tasmota-Geräten mit mehreren Schaltausgängen (bisher von Hand im Skript angepasst)
                                          • Integration der RGB-Version dieses Skriptes in die normale Version

                                          Vorwort:
                                          Auf Grund einer Nachfrage poste ich mal mal meinen persönlichen Lösungsweg für die Einbindung von über 60 Tasmota-Geräten bei mir zu Hause in ioBroker.

                                          Ich nutze dazu Mosquitto als MQTT-Broker (mit Installiert auf dem ioBroker), den MQTT Adapter als Client zu diesem und je ein eigenes JavaScript pro Tasmota-Gerät zur Auswertung. Der Grund ist das ich damals schon meine Geräte mit einem MQTT-Server verbunden hatte und darauf auch diverse andere Scripte und Dienste zugriffen (bevor ich mit ioBroker angefangen habe). Diese sollten so weiter funktionieren können. Aber per MQTT haben die Steckdosen dann z.B. kein True/False-Datenpunkt den man z.B. für einen Schalter in der VIS verwenden könnte. Der Sonoff-Adapter ist zwar auch ein MQTT-Broker für die Tasmota-Geräte, man kann sich aber nicht als Client mit diesem Verbinden. Also brauchte ich ein Skript.

                                          Schritt 1: Mosquitto installieren:
                                          Da gibt es genug Anleitungen im Internet. Für Ubuntu (und sollte auch auf dem Raspberry Pi funktionieren) habe ich diese genutzt: How to install and secure Mosquitto on Ubuntu 20.04.

                                          Dabei solltet Ihr Abweichend von der Anleitung folgendes ändern:
                                          In der

                                           /etc/mosquitto/conf.d/default.conf
                                          

                                          Solltet Ihr den Eintrag listener von 9001 auf 9002 ändern und Mosquitto neu starten:

                                          ...
                                          port 1883
                                          listener 9002
                                          protocol websockets
                                          ...
                                          

                                          Grund ist das zumindest bei mir die JavaScript-Instanz von ioBroker schon Port 9001 belegt.
                                          Die Einstellungen oben starten auf Port 1883 den MQTT-Broker und auf Port 9002 kann Alternativ per Websocket mit den MQTT-Broker kommuniziert werden. Der Port 1883 sollte entweder in ioBroker nicht von einem anderen Adapter belegt sein (etwa dem Sonoff-Adapter oder einer bestehenden MQTT-Server Instanz) oder ihr wählt einen anderen Port in der Mosquitto-Konfiguration.

                                          Schritt 2: Zugriff auf Mosquitto testen:
                                          Ich nehme dazu gerne den MQTT-Explorer: http://mqtt-explorer.com/
                                          d49354f9-4cf3-4609-aafd-54b6d8358f22-image.png
                                          Da sollte unten $SYS zu sehen sein mit Informationen zum Mosquitto-Server:
                                          c514003e-79fa-4601-ae62-f57654874f05-image.png

                                          Schritt 3: Einstellungen unter Tasmota:
                                          In der Weboberfläche des Tasmota-Gerätes stelle ich nun den MQTT-Server ein:
                                          2869870a-100a-4396-8818-517cb58226c6-image.png

                                          Der Host ist mein ioBroker-Server, der Port ist in Mosquitto konfiguriert.
                                          Nach dem Speichern sollte Ihr im MQTT-Explorer das Gerät schon sehen können, und zwar unter den Topics (=Unterordnern) tele, stat und cmnd:

                                          d9d55022-4273-44f2-80b2-c6050729f8c7-image.png

                                          Schritt 4: MQTT-Adapter in ioBroker:
                                          Installiert in ioBroker den MQTT Broker/Client und installiert diesen:
                                          14af7c77-33a7-4221-a472-b1f26ef8be75-image.png bzw. c9331fb7-ed74-43a1-8856-a3e2979f4ea2-image.png

                                          Der Adapter ist bei mir wie folgt eingestellt:
                                          37102f25-a2ac-43d7-8065-60254e0e5b83-image.png

                                          08b5cc05-418d-4427-a28d-0b32c458174a-image.png

                                          Unter den Datenpunkten des Adapters sollte Ihr nun im Prinzip das gleiche sehe wie im MQTT-Explorer. Sonst einfach mal das Tasmota-Gerät neu starten, der MQTT-Adapter kann nur Meldungen sehen die nach seiner Verbindungsherstellung gekommen sind.

                                          Schritt 5: JavaScript pro Tasmota-Gerät
                                          Das Skript stelle einen POWER Datenpunkt zur Verfügung der in der VIS genutzt werden kann um das Gerät ein- oder auszuschalten. Zusätzlich werden ein paar Informationen zu Version und WLAN gesammelt:

                                          // Setup
                                          var s_DeviceName = "Gosund166";
                                          // Suffix wird an den Devicenamen für die Zieldatenpunkte angehängt, z.B. "-Waschmaschine" (KEINE Punkte!!!)
                                          var s_Suffix = "-2fach";
                                          // --------------------------------------------------------------------------------------
                                          // Bei Tasmota-Firmware ab Verion 9.5 auf true setzen, bis Version 9.3.1 auf false setzen
                                          var b_Firmware95 = true;
                                          // Erfassung von Leistungs und Verbrauchsdaten
                                          var b_Energy = false;
                                          // Anzahl der schaltbaren Ausgänge, 1 bis 4, 1 = nur POWER, ab 2 und mehr POWER1, POWER2 usw.
                                          var i_NumberOfPower = 1;
                                          // EasyMeter Q3A gemäß https://tasmota.github.io/docs/Smart-Meter-Interface/#easymeter-q1d-ascii-obis
                                          var b_EasyMeterQ3A = false;
                                          // Erfassung von Temperaturwerten (Shelly 1PM)
                                          var b_Temperature = false;
                                          // Erfassung HC-SR04 Ultraschall-Sensor
                                          var b_hcsr04 = false;
                                          // Sollen die Datenpunkte nachträglich korrigiert werden?
                                          var b_CorrectDatapoints = false;
                                          // Einschaltdauer erfassen (muss noch getestet werden, nicht benutzen!)
                                          var b_HourMeter = false;
                                          // Name der MQTT-Instanz
                                          var s_mqtt_Instance = "mqtt.0";
                                          // Festlegen der Skriptversion (für Auswertungen)
                                          var s_VersionJSScript = "1.24"
                                          // Logging aktivieren für das Debuggen in die JavaScript-Console und in das ioBroker Log (true oder false):
                                          var b_UseLogging = false;
                                          //
                                          // Changelog:
                                          // ----------
                                          // 13.03.2021   1.0     erste Version mit Versionsnummer + optische Aufbereitung des Quellcodes
                                          // 14.03.2021   1.1     Umbau auf fromNe: / Einbau Logging / Einführung Changelog
                                          // 25.03.2021   1.2     Ermittlung der Einschaltdauer erster Versuch
                                          // 08.05.2021   1.3     Anpassung an JS controller 3.3.8 (ackn bei Datenpunkten die read-only sind)
                                          // 30.08.2021   1.4     Angepasst an Tasmota 9.5.0 (hart)
                                          // 31.10.2021   1.5     Auswahl der Firmware-Version per Variable
                                          // 31.10.2021   1.6     Pfad auf 0_userdata.0 geändert, Name des AccessPoints herauskommentiert.
                                          // 31.10.2021   1.7     Heraussuchen des AccessPoint-Names konfigurierbar gemacht
                                          // 04.11.2021   1.8     Erstellen der Datenpunkte mit await-Funktion. So muss das Skript nicht mehr 2x gestartet werden.
                                          // 20.11.2021   1.9     Bei allen Werten aus JSON-Objekten vor den Schreiben in States explizite Umwandlung in String oder Number
                                          // 12.12.2021   1.10    Stromverbrauch mit wird nun auch erfasst sofern entsprechende Daten geliefert werden /tele/xxx/SENSOR
                                          // 12.12.2021   1.11    Und kleinere Fehler beseitigt (in Debugging-Meldungen / Typen Konvertierung)
                                          // 12.12.2021   1.12    Zusätzliche Datenpunkte für Einschaltdauer hinzugefügt, die aktuelle Dauer wird hochgezählt und in 2 Datenpunkten festgehalten.
                                          //                      Die Berechnung erfolgt jedesmal wenn eine /tele/xxxx/STATE Meldung eingeht.
                                          // 09.02.2022   1.13    Shelly Temperatur + Einheiten korrigiert
                                          // 26.06.2022   1.14    Temperatur Optional gemacht per Schalter
                                          //                      Optionales Suffix für die Zieldatenpunkte
                                          // 28.06.2022   1.15    Einschaltdauer - Default Wert für Einschaltzeit ist nun die aktuelle Zeit (Falls Gerät noch nie ausgeschaltet war)
                                          // 19.07.2022   1.16    FriendlyName wird nun mit ausgewertet (Bezeichnung unter der Echo & Co. das Gerät finden)
                                          // 25.07.2022   1.17    Script-Version mit als Datenpunkt aufgenommen + Einheiten von Datenpunkten hinzugefügt (auch nachträglich)
                                          // 25.07.2022   1.18    Name des Scriptes als Datenpunkt aufgenommen
                                          // 04.04.2023   1.19    EasyMeterQ3A auslesen eingebaut
                                          // 25.03.2024   1.20    HC-SR04 Ultraschall Sensor
                                          // 16.04.2024   1.21    Fehler bei Zeiterfassung (wenn nicht aktiv) behoben, Zeiterfassung default deaktiviert
                                          // 12.06.2024   1.22    Eventlog lokal in das Skript aufgenommen statt über globale Funktion
                                          // 28.09.2024   1.23    Umbau auf Möglichkeit mit mehreren Schaltern POWER <=> POWER1 bis POWER4
                                          // 29.09.2024   1.24    Bestätigt/Unbestätigt bei POWER-Datenpunkten + Fehlerbehebung
                                          // 
                                          // 2020 - 2024 von Bernhard Linz / Bernhard@znil.net
                                          // ####################################################################################################################################################
                                          // Beschreibung:
                                          // -------------
                                          // Grundaufgabe ist es einen Datenpunkt bereitzustellen über welchen der POWER Status des Tasmota Gerätes als Boolean true false 
                                          // ausgelesen aber auch gesetzt werden kann - so wie es viele Widgets in VIS benötigen
                                          // Dazu wird der MQTT Datenpunkt /stat/{Gerätename}/POWER ausgewertet und per /cmnd/{Gerätename}/POWER ggf. gesetzt
                                          // Zusätzlich werden weitere Informationen gesammelt, z.B. mit welchen AccessPoint das Gerät verbunden ist
                                          //
                                          // Setup:
                                          // ------
                                          // oben in Zeile 2 den Namen des Tasmota-Gerätes setzen so wie dieser unter mqtt.0.stat auftaucht.
                                          // Name wird durch die Tasmota Optionen
                                          // Topic {NamedesGerätes}
                                          // MqttClient {NamedesGerätes}
                                          // gesetzt und sollte für diese Script bei beiden Identisch sein
                                          //
                                          // Das Suffix in Zeile 2 wird an die 0_userdata.0 Datenpunkte angehängt
                                          // Ist die Firmware des Tasmota-Gerätes 9.5 oder höher so muss "b_Firmware95 = true" gesetzt werden (Die Pfade im MQTT haben sich geändert)
                                          // Soll der Energieverbauch erfasst werden so muss "b_Energy = true;" gesetzt werden, die Meldungen von tele/xxx/SENSOR werden dann ausgewertet
                                          // ####################################################################################################################################################
                                          // Private Einstellungen die nur für meine Umgebung funktionieren oder von euch zuerst die Voraussetzungen geschafft werden müssen
                                          // Soll der Name des AccessPoints ermittelt werden?
                                          // @ts-ignore
                                          var b_GetNameOfAccessPoints = false;
                                          // Pfad für das auslesen des AccessPoints. Dort gibt es für jeden AccessPoint einen Datenpunkt vom Typ String welcher die MAC als ID und den Namen als Wert hat
                                          var s_AccessPoints_path = "0_userdata.0.001-Konstanten.WLAN.";
                                          // Zentrales Log über alle Ein- und Ausschaltvorgänge führen
                                          var b_UseSystemEventLog = false;
                                          
                                          // ####################################################################################################################################################
                                          // http://www.network-science.de/ascii/ Font: big
                                          // __      __        _       _     _            
                                          // \ \    / /       (_)     | |   | |           
                                          //  \ \  / /_ _ _ __ _  __ _| |__ | | ___ _ __  
                                          //   \ \/ / _` | '__| |/ _` | '_ \| |/ _ \ '_ \ 
                                          //    \  / (_| | |  | | (_| | |_) | |  __/ | | |
                                          //     \/ \__,_|_|  |_|\__,_|_.__/|_|\___|_| |_|
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          // unsere JavaScript-Instanz um zu prüfen ob die Änderung durch MQTT oder durch VIS ausgelöst wurde
                                          // @ts-ignore
                                          const o_js_Instance = 'system.adapter.javascript.' + instance;
                                          // und der erste Log-Eintrag
                                          DebugWarning("Startup: Setze Variablen ...");
                                          // Datenpunktstammpfad
                                          //var s_state_rootpath = "javascript.0.tasmota.";
                                          var s_state_rootpath = "0_userdata.0.tasmota.";
                                          var s_state_FullPath = s_state_rootpath + s_DeviceName + s_Suffix;
                                          // True/False Datenpunkt für VIS & Co
                                          var s_state_power_path = s_state_FullPath + ".POWER";
                                          // Datenpunkt an den Tasmota den aktuellen POWER Zustand meldet
                                          if (i_NumberOfPower == 1) {
                                              var s_mqtt_POWER_path = s_mqtt_Instance + ".stat." + s_DeviceName + ".POWER";
                                          } else {
                                              var s_mqtt_POWER_path = s_mqtt_Instance + ".stat." + s_DeviceName + ".POWER*";
                                          }
                                          // Datenpunkt an den die letzte Aktion von Tasmota gesendet wird
                                          var s_mqtt_RESULT_path = s_mqtt_Instance + ".stat." + s_DeviceName + ".RESULT";
                                          // Datenpunkt den man setzen muss um den Status zu ändern (ON oder OFF oder Toggle)
                                          var s_mqtt_CMND_path = s_mqtt_Instance + ".cmnd." + s_DeviceName + ".POWER";
                                          // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen STATE landen
                                          var s_mqtt_STATE_path = s_mqtt_Instance + ".tele." + s_DeviceName + ".STATE";
                                          // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen INFO1 landen (enthält unter anderem die Tasmota-Version)
                                          var s_mqtt_INFO1_path = s_mqtt_Instance + ".tele." + s_DeviceName + ".INFO1";
                                          // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen INFO2 landen (enthält die IP-Adresse)
                                          var s_mqtt_INFO2_path = s_mqtt_Instance + ".tele." + s_DeviceName + ".INFO2";
                                          // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen SENSOR landen (enthält Daten zum Energieverbrauch wenn unterstützt)
                                          var s_mqtt_SENSOR_path = s_mqtt_Instance + ".tele." + s_DeviceName + ".SENSOR";
                                          // Datenpunkt in welchen die regelmäßigen MQTT Statusmeldungen stat/.../STATUS landen (enthält den FriendlyName)
                                          var s_mqtt_STATUS_path = s_mqtt_Instance + ".stat." + s_DeviceName + ".STATUS";
                                          // Temporäre Variable für verschiedene Auswertungen
                                          var s_tempjson;
                                          // Variablen für die Zeitauswertung
                                          var i_global_unixtimeSwitchedOn = 0;
                                          var i_global_unixtimeSwitchedOff = 0;
                                          var i_global_LastSwichtedOnDuration = 0;
                                          var i_global_OperationHoursCounter = 0;
                                          var i_global_CurrentPowerOnTimeSeconds = 0;
                                          var i_global_CurrentPowerOnTimeH = "";
                                          
                                          // Gibt eine Fehlermeldung wenn diese Variable nicht extra definiert wurde
                                          var myAccessPoint;
                                          //Fehlerzähler
                                          var i_ErrorCounter = 0;
                                          
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          //  ______           _    _   _                        
                                          // |  ____|         | |  | | (_)                       
                                          // | |__ _   _ _ __ | | _| |_ _  ___  _ __   ___ _ __  
                                          // |  __| | | | '_ \| |/ / __| |/ _ \| '_ \ / _ \ '_ \ 
                                          // | |  | |_| | | | |   <| |_| | (_) | | | |  __/ | | |
                                          // |_|   \__,_|_| |_|_|\_\\__|_|\___/|_| |_|\___|_| |_|
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          // DebugWarning gibt in der Console eine Warnmeldung aus wenn b_UseLogging auf true steht
                                          /* accepts parameters
                                           * s_debugmessage = Print this text to console via warn
                                           */
                                          function DebugWarning(s_debugmessage) {
                                              if (b_UseLogging == true) {
                                                  console.warn(s_debugmessage);
                                              }
                                          }
                                          // ####################################################################################################################################################
                                          // Wandelt Sekunden in Tage/Stunden/Minuten/Sekunden um:
                                          function ConvertTimeHumanReadable(i_seconds) {
                                              var i_days = Math.floor(i_seconds / (24 * 60 * 60));
                                              i_seconds -= i_days * (24 * 60 * 60);
                                              var i_hours = Math.floor(i_seconds / (60 * 60));
                                              i_seconds -= i_hours * (60 * 60);
                                              var i_minutes = Math.floor(i_seconds / (60));
                                              i_seconds -= i_minutes * (60);
                                              return ((0 < i_days) ? (i_days + "d ") : "") + ((0 < i_hours) ? (i_hours + "h ") : "") + ((0 < i_minutes) ? (i_minutes + "m ") : "") + ((0 < i_seconds) ? (i_seconds + "s") : "");
                                          }
                                          
                                          // ####################################################################################################################################################
                                          // Berechnet die Einschaltdauer etc., als Funktion da mehrmals benötigt
                                          function CalculateSwitchedOnDuration() {
                                              // Diese Funktion wird immer dann aufgerufen wenn ein Ausschalten registriert wurde
                                              var i_Duration = i_global_unixtimeSwitchedOff - i_global_unixtimeSwitchedOn;
                                              var s_Duration = ConvertTimeHumanReadable(i_Duration);
                                              // Letzte Einschaltdauer setzen
                                              setState(s_state_FullPath + ".tmp.LastSwichtedOnDuration", i_Duration, true);
                                              setState(s_state_FullPath + ".Time-LastSwichtedOnDuration", s_Duration, true);
                                              // Betriebsstundenzähler erhöhen
                                              var i_TotalDuration = getState(s_state_FullPath + ".tmp.OperationHoursCounter").val;
                                              i_TotalDuration = i_TotalDuration + i_Duration;
                                              var s_TotalDuration = ConvertTimeHumanReadable(i_TotalDuration);
                                              setState(s_state_FullPath + ".tmp.OperationHoursCounter", i_TotalDuration, true);
                                              setState(s_state_FullPath + ".Time-OperationHoursCounter", s_TotalDuration, true);
                                          }
                                          
                                          // ####################################################################################################################################################
                                          // Modifiziert einen Datenpunkt und fügt eine Einheit dazu
                                          function SetUnit(setunit_id, setunit_unit) {
                                              if (b_CorrectDatapoints == true) {
                                                  try {
                                                      var setunit_obj = getObject(setunit_id);
                                                      // setunit_obj.common.name = 'neuer Name';
                                                      setunit_obj.common.unit = setunit_unit;
                                                      // @ts-ignore
                                                      setObject(setunit_id, setunit_obj);
                                                  }
                                                  catch (e) {
                                                      // nichts machen
                                                      i_ErrorCounter++;
                                                  }
                                              }
                                          }
                                          
                                          // ####################################################################################################################################################
                                          // Eventlog, abgeschaut bei https://www.smarthome-tricks.de/software-iobroker/eigenes-logging-in-iobroker/
                                          
                                          function createEventlog(EventType, EventText) {
                                              let tasmotaEventListDestination = "0_userdata.0.EventLog.Tasmota.";
                                              // vorhandene Einträge einlesen
                                              let EventList = getState(tasmotaEventListDestination + "EventLogTasmota").val;
                                              // Anzahl der Maximal erlaubten Einträge einlesen
                                              let maxEventCount = getState("0_userdata.0.EventLog.Tasmota.maxEventCount").val;
                                              // Nur die letzten x Einträge im Script belassen
                                              let eventList = EventList.split('<br>');
                                              let eventCount = eventList.length;
                                              let newEventList = "";
                                              for (var i = 0; i < eventCount; i++) {
                                                  if ( i < (maxEventCount-1) ) {
                                                      newEventList = newEventList + "<br>" + eventList[i];
                                                  } else {
                                                      break;
                                                  }
                                              }
                                              EventList = newEventList;
                                              // Neue Event-Id und Zeitpunkt ermitteln
                                              let EventId = getState(tasmotaEventListDestination + "NextEventId").val;
                                              let EventDateTime = formatDate(getDateObject((new Date().getTime())), "TT.MM.JJ hh:mm:ss");
                                              EventId = EventId + 1;
                                              setState(tasmotaEventListDestination + "NextEventId", EventId);
                                              let FormatedEventId = ("0000000" + EventId).slice(-7);
                                              let EventLog = FormatedEventId + " - " + EventDateTime + " - " + EventType + " - " + EventText;
                                              EventList = EventLog + EventList;
                                              setState(tasmotaEventListDestination + "EventLogTasmota", EventList);
                                          }
                                          
                                          // ####################################################################################################################################################
                                          // Benötigte Datenpunkte erstellen
                                          async function CreateMyStatesAndStartup() {
                                              try {
                                                  DebugWarning("Startup: Erstelle ggf. Datenpunkte ...");
                                                  // #######################################################################################################
                                                  // POWER
                                                  if (b_hcsr04 == false) {
                                                      if (i_NumberOfPower == 1) {
                                                          DebugWarning("Erstelle: " + s_state_FullPath + ".POWER");
                                                          await createStateAsync(s_state_FullPath + ".POWER", false, {
                                                              type: 'boolean',
                                                              read: true,
                                                              write: true,
                                                              role: "switch",
                                                              name: s_DeviceName + s_Suffix + '.POWER'
                                                          });
                                                      } else {
                                                          for (let i = 1; i < (i_NumberOfPower + 1); i++) {
                                                              DebugWarning("Erstelle: " + s_state_FullPath + ".POWER"  + String(i));
                                                              await createStateAsync(s_state_FullPath + ".POWER" + String(i), false, {
                                                                  type: 'boolean',
                                                                  read: true,
                                                                  write: true,
                                                                  role: "switch",
                                                                  name: s_DeviceName + s_Suffix + '.POWER' + String(i)
                                                              });
                                                          }
                                                      }
                                                  }
                                                  // #######################################################################################################
                                                  // Version-JS-Script
                                                  await createStateAsync(s_state_FullPath + ".Version-JS-Script", s_VersionJSScript, {
                                                      type: 'string',
                                                      read: true,
                                                      write: false,
                                                      name: 'Version-JS-Script'
                                                  });
                                                  // #######################################################################################################
                                                  // Version-JS-Script-Path
                                                  await createStateAsync(s_state_FullPath + ".Version-JS-Script-Path", scriptName, {
                                                      type: 'string',
                                                      read: true,
                                                      write: false,
                                                      name: 'Name und Pfad des Skriptes'
                                                  });
                                                  // #######################################################################################################
                                                  // RSSI
                                                  await createStateAsync(s_state_FullPath + ".RSII", 0, {
                                                      type: 'number',
                                                      read: true,
                                                      write: false,
                                                      name: 'WLAN Stärke in %',
                                                      unit: "%"
                                                  });
                                                  //SetUnit(s_state_FullPath + ".RSII", "%");
                                                  // #######################################################################################################
                                                  // Basisstation 1
                                                  await createStateAsync(s_state_FullPath + ".BSSId", "00:00:00:00:00:00", {
                                                      type: 'string',
                                                      read: true,
                                                      write: false,
                                                      name: 'MAC des AccessPoints'
                                                  });
                                                  // #######################################################################################################
                                                  // Basisstation 2
                                                  if (b_GetNameOfAccessPoints == true) {
                                                      await createStateAsync(s_state_FullPath + ".AccessPoint", "unbekannt", {
                                                          type: 'string',
                                                          read: true,
                                                          write: false,
                                                          name: 'Name des AccessPoints'
                                                      });
                                                  }
                                                  // #######################################################################################################
                                                  // Kanal
                                                  await createStateAsync(s_state_FullPath + ".Channel", 0, {
                                                      type: 'number',
                                                      read: true,
                                                      write: false,
                                                      name: 'WLAN Kanal'
                                                  });
                                                  // #######################################################################################################
                                                  // IP-Adresse
                                                  await createStateAsync(s_state_FullPath + ".IPAddress", "0.0.0.0", {
                                                      type: 'string',
                                                      read: true,
                                                      write: false,
                                                      name: 'IP-Address'
                                                  });
                                                  // #######################################################################################################
                                                  // Modul (Gerätetyp)
                                                  await createStateAsync(s_state_FullPath + ".DeviceType", "Generic", {
                                                      type: 'string',
                                                      read: true,
                                                      write: false,
                                                      name: 'Device Type'
                                                  });
                                                  // #######################################################################################################
                                                  // Version (Firmware)
                                                  await createStateAsync(s_state_FullPath + ".Version", "0.0.0", {
                                                      type: 'string',
                                                      read: true,
                                                      write: false,
                                                      name: 'Version'
                                                  });
                                                  // #######################################################################################################
                                                  // FriendlyName (Rufname Amazon Echo & Co)
                                                  await createStateAsync(s_state_FullPath + ".FriendlyName", "Tasmota", {
                                                      type: 'string',
                                                      read: true,
                                                      write: false,
                                                      name: 'FriendlyName'
                                                  });
                                                  // #######################################################################################################
                                                  // Datenpunkte für Betriebsstundenzähler / Einschaltdauer
                                                  if (b_HourMeter == true) {
                                                      // Zeit wann eingeschaltet
                                                      await createStateAsync(s_state_FullPath + ".tmp.unixtimeSwitchedOn", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Einschaltzeit als Unix-Timestamp',
                                                          unit: "unixtime"
                                                      });
                                                      SetUnit(s_state_FullPath + ".tmp.unixtimeSwitchedOn", "unixtime");
                                                      // #######################################################################################################
                                                      // Zeit wann ausgeschaltet
                                                      await createStateAsync(s_state_FullPath + ".tmp.unixtimeSwitchedOff", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Ausschaltzeit als Unix-Timestamp',
                                                          unit: "unixtime"
                                                      });
                                                      SetUnit(s_state_FullPath + ".tmp.unixtimeSwitchedOff", "unixtime");
                                                      // #######################################################################################################
                                                      // Letzte Einschaltdauer
                                                      await createStateAsync(s_state_FullPath + ".tmp.LastSwichtedOnDuration", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Letzte Einschaltdauer',
                                                          unit: "s"
                                                      });
                                                      SetUnit(s_state_FullPath + ".tmp.LastSwichtedOnDuration", "s");
                                                      // #######################################################################################################
                                                      // Summe der Einschaltdauer
                                                      await createStateAsync(s_state_FullPath + ".tmp.OperationHoursCounter", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Summe Einschaltdauer',
                                                          unit: "s"
                                                      });
                                                      SetUnit(s_state_FullPath + ".tmp.OperationHoursCounter", "s");
                                                      // #######################################################################################################
                                                      // Letzte Einschaltdauer Lesbar in HH:MM:SS
                                                      await createStateAsync(s_state_FullPath + ".Time-LastSwichtedOnDuration", "0s", {
                                                          type: 'string',
                                                          read: true,
                                                          write: true,
                                                          name: 'Letzte Einschaltdauer'
                                                      });
                                                      // #######################################################################################################
                                                      // Gesamte Einschaltdauer Lesbar in HH:MM:SS
                                                      await createState(s_state_FullPath + ".Time-OperationHoursCounter", "0s", {
                                                          type: 'string',
                                                          read: true,
                                                          write: true,
                                                          name: 'Letzte Einschaltdauer'
                                                      });
                                                      // #######################################################################################################
                                                      // Aktuelle Einschaltdauer in Sekunden
                                                      await createState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Aktuelle Einschaltdauer in Sekunden',
                                                          unit: "s"
                                                      });
                                                      SetUnit(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", "s");
                                                      // #######################################################################################################
                                                      // Aktuelle Einschaltdauer Lesbar in HH:MM:SS
                                                      await createState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", {
                                                          type: 'string',
                                                          read: true,
                                                          write: true,
                                                          name: 'Aktuelle Einschaltdauer in Tagen, Stunden, Minuten, Sekunden'
                                                      });
                                                      // #######################################################################################################
                                                  }
                                                  // Datenpunkte für Stromverbrauch
                                                  if (b_Energy == true) {
                                                      // Gesamter Energieverbrauch    
                                                      await createState(s_state_FullPath + ".Energy-Total", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Energie Total',
                                                          unit: "kWh"
                                                      });
                                                      SetUnit(s_state_FullPath + ".Energy-Total", "kWh");
                                                      // #######################################################################################################
                                                      // Energieverbrauch gestern
                                                      await createState(s_state_FullPath + ".Energy-Yesterday", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Energie Gestern',
                                                          unit: "kWh"
                                                      });
                                                      SetUnit(s_state_FullPath + ".Energy-Yesterday", "kWh");
                                                      // #######################################################################################################
                                                      // Energieverbrauch Heute
                                                      await createState(s_state_FullPath + ".Energy-Today", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Energie Heute',
                                                          unit: "kWh"
                                                      });
                                                      SetUnit(s_state_FullPath + ".Energy-Yesterday", "kWh");
                                                      // #######################################################################################################
                                                      // Energieverbrauch Aktuell/Momentan/Jetzt gerade
                                                      await createState(s_state_FullPath + ".Energy-Power", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Energie Momentan',
                                                          unit: "W"
                                                      });
                                                      SetUnit(s_state_FullPath + ".Energy-Power", "W");
                                                      // #######################################################################################################
                                                      // Energieverbrauch aktuelle Spannung
                                                      await createState(s_state_FullPath + ".Energy-Voltage", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Energie Spannung Momentan',
                                                          unit: "V"
                                                      });
                                                      SetUnit(s_state_FullPath + ".Energy-Voltage", "V");
                                                      // #######################################################################################################
                                                      // Energieverbrauch aktueller Stromfluss
                                                      await createState(s_state_FullPath + ".Energy-Current", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Energie Stromfluss Momentan',
                                                          unit: "A"
                                                      });
                                                      SetUnit(s_state_FullPath + ".Energy-Current", "A");
                                                      // #######################################################################################################
                                                  }
                                                  if (b_Temperature == true) {
                                                      // #######################################################################################################
                                                      // Temperatur
                                                      await createState(s_state_FullPath + ".Temperature", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Energie Stromfluss Momentan',
                                                          unit: "°C"
                                                      });
                                                      SetUnit(s_state_FullPath + ".Temperature", "°C");
                                                      // #######################################################################################################
                                                  }
                                                  if (b_EasyMeterQ3A == true) {
                                                      // #######################################################################################################
                                                      // Stromzähler EasyMeter Q3A via Tasmota
                                                      // Verbrauch-Summe
                                                      await createState(s_state_FullPath + ".Verbrauch-Summe", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Verbrauch Summe',
                                                          unit: "kWh"
                                                      });
                                                      // Einspeisung-Summe
                                                      await createState(s_state_FullPath + ".Einspeisung-Summe", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Einspeisung Summe',
                                                          unit: "kWh"
                                                      });
                                                      // Watt L1
                                                      await createState(s_state_FullPath + ".Watt-L1", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Watt-L1',
                                                          unit: "W"
                                                      });
                                                      // Watt L2
                                                      await createState(s_state_FullPath + ".Watt-L2", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Watt-L2',
                                                          unit: "W"
                                                      });
                                                      // Watt L3
                                                      await createState(s_state_FullPath + ".Watt-L3", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Watt-L3',
                                                          unit: "W"
                                                      });
                                                      // Watt Summe
                                                      await createState(s_state_FullPath + ".Watt-Summe", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Watt-Summe',
                                                          unit: "W"
                                                      });
                                                      // Volt L1
                                                      await createState(s_state_FullPath + ".Volt-L1", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Volt-L1',
                                                          unit: "V"
                                                      });
                                                      // Volt L2
                                                      await createState(s_state_FullPath + ".Volt-L2", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Volt-L2',
                                                          unit: "V"
                                                      });
                                                      // Volt L3
                                                      await createState(s_state_FullPath + ".Volt-L3", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: true,
                                                          name: 'Volt-L3',
                                                          unit: "V"
                                                      });
                                                  }
                                                  if (b_hcsr04 == true) {
                                                      // #######################################################################################################
                                                      // Ultraschall Entfernungssensor
                                                      // Verbrauch-Summe
                                                      await createState(s_state_FullPath + ".Distance", 0, {
                                                          type: 'number',
                                                          read: true,
                                                          write: false,
                                                          name: 'Distance in cm',
                                                          unit: "cm"
                                                      });
                                                  }
                                                  // Startup - Startwerte schon mal ermitteln und schreiben
                                                  DebugWarning("Startup: aktuellen Status von POWER holen und schreiben");
                                                  // Beim Start einmal den aktuellen Status von MQTT stat/POWER holen und schreiben
                                                  if (b_hcsr04 == false) {
                                                      if (i_NumberOfPower == 1) {
                                                          s_tempjson = getState(s_mqtt_POWER_path).val;
                                                          if (s_tempjson == "ON") {
                                                              setState(s_state_power_path, true, true);
                                                              if (b_HourMeter == true) {
                                                                  // letztes TimeStamp für das Einschalten wieder auslesen damit Dauer berechnet werden kann
                                                                  i_global_unixtimeSwitchedOn = getState(s_state_FullPath + ".tmp.unixtimeSwitchedOn").val;
                                                                  // Kann sein das der Wert 0 ist wenn das Gerät noch nie ausgeschaltet war, dann nehmen wir eben die aktuelle Zeit
                                                                  if (i_global_unixtimeSwitchedOn == 0) {
                                                                      i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
                                                                      setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
                                                                  }
                                                              }
                                                          } else {
                                                              setState(s_state_power_path, false, true);
                                                          }
                                                      } else {
                                                          for (let i = 1; i < (i_NumberOfPower + 1); i++) {
                                                              s_tempjson = getState(s_mqtt_POWER_path.replace("*",String(i))).val;
                                                              if (s_tempjson == "ON") {
                                                                  setState(s_state_power_path + String(i), true, true);
                                                                  if (b_HourMeter == true) {
                                                                      // letztes TimeStamp für das Einschalten wieder auslesen damit Dauer berechnet werden kann
                                                                      i_global_unixtimeSwitchedOn = getState(s_state_FullPath + ".tmp.unixtimeSwitchedOn").val;
                                                                      // Kann sein das der Wert 0 ist wenn das Gerät noch nie ausgeschaltet war, dann nehmen wir eben die aktuelle Zeit
                                                                      if (i_global_unixtimeSwitchedOn == 0) {
                                                                          i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
                                                                          setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
                                                                      }
                                                                  }
                                                              } else {
                                                                  setState(s_state_power_path + String(i), false, true);
                                                              }
                                                          }
                                                      }
                                                  }
                                                  // #######################################################################################################
                                                  // Version setzen / aktualisieren
                                                  setState(s_state_FullPath + ".Version-JS-Script", s_VersionJSScript, true);
                                                  setState(s_state_FullPath + ".Version-JS-Script-Path", scriptName, true);
                                                  // #######################################################################################################
                                                  // Beim Start einmal einfach die IP-Adresse / Firmware etc. falls schon vorhanden:
                                                  DebugWarning("Startup: aktuellen Status von INFO1 holen und schreiben");
                                                  if (await existsStateAsync(s_mqtt_INFO1_path)) {
                                                      s_tempjson = JSON.parse(getState(s_mqtt_INFO1_path).val);
                                                      if (b_Firmware95 == false) {
                                                          // bis Tasmota Version 9.3.1
                                                          DebugWarning("Startup: DeviceType: " + String(s_tempjson.Module));
                                                          await setStateAsync(s_state_FullPath + ".DeviceType", String(s_tempjson.Module), true);
                                                          DebugWarning("Startup: Version: " + String(s_tempjson.Version));
                                                          await setStateAsync(s_state_FullPath + ".Version", String(s_tempjson.Version), true);
                                                      } else {
                                                          // ab Tasmota Version 9.5
                                                          DebugWarning("Startup: DeviceType: " + s_tempjson.Info1.Module);
                                                          await setStateAsync(s_state_FullPath + ".DeviceType", String(s_tempjson.Info1.Module), true);
                                                          DebugWarning("Startup: Version: " + s_tempjson.Info1.Version);
                                                          await setStateAsync(s_state_FullPath + ".Version", String(s_tempjson.Info1.Version), true);
                                                      }
                                                  }
                                                  // #######################################################################################################
                                                  DebugWarning("Startup: aktuellen Status von INFO2 holen und schreiben");
                                                  if (await existsStateAsync(s_mqtt_INFO2_path)) {
                                                      s_tempjson = JSON.parse(getState(s_mqtt_INFO2_path).val);
                                                      if (b_Firmware95 == false) {
                                                          // bis Tasmota Version 9.3.1
                                                          await setStateAsync(s_state_FullPath + ".IPAddress", String(s_tempjson.IPAddress), true);
                                                          DebugWarning("Startup: IPAddress: " + String(s_tempjson.IPAddress));
                                                      } else {
                                                          // ab Tasmota Version 9.5
                                                          await setStateAsync(s_state_FullPath + ".IPAddress", String(s_tempjson.Info2.IPAddress), true);
                                                          DebugWarning("Startup: IPAddress: " + String(s_tempjson.Info2.IPAddress));
                                                      }
                                                  }
                                                  // #######################################################################################################
                                                  if (b_Energy == true) {
                                                      DebugWarning("Startup: aktuellen Status von SENSOR holen und schreiben");
                                                      if (await existsStateAsync(s_mqtt_SENSOR_path)) {
                                                          s_tempjson = JSON.parse(getState(s_mqtt_SENSOR_path).val);
                                                          if (b_Firmware95 == false) {
                                                              // bis Tasmota Version 9.3.1
                                                              // Keine Ahnung wie das vor 9.5 aussieht, muss ich dann noch mal nachpflegen
                                                          } else {
                                                              // ab Tasmota Version 9.5
                                                              await setStateAsync(s_state_FullPath + ".Energy-Total", Number(s_tempjson.ENERGY.Total), true);
                                                              DebugWarning("Startup: Energy-Total: " + Number(s_tempjson.ENERGY.Total));
                                                              await setStateAsync(s_state_FullPath + ".Energy-Yesterday", Number(s_tempjson.ENERGY.Yesterday), true);
                                                              DebugWarning("Startup: Energy-Yesterday: " + Number(s_tempjson.ENERGY.Yesterday));
                                                              await setStateAsync(s_state_FullPath + ".Energy-Today", Number(s_tempjson.ENERGY.Today), true);
                                                              DebugWarning("Startup: Energy-Today: " + Number(s_tempjson.ENERGY.Today));
                                                              await setStateAsync(s_state_FullPath + ".Energy-Power", Number(s_tempjson.ENERGY.Power), true);
                                                              DebugWarning("Startup: Energy-Power: " + Number(s_tempjson.ENERGY.Power));
                                                              if (isNaN(Number(s_tempjson.ENERGY.Voltage))) {
                                                                  await setStateAsync(s_state_FullPath + ".Energy-Voltage", 0, true);
                                                              } else {
                                                                  await setStateAsync(s_state_FullPath + ".Energy-Voltage", Number(s_tempjson.ENERGY.Voltage), true);
                                                              }
                                                              DebugWarning("Startup: Energy-Voltage: " + Number(s_tempjson.ENERGY.Voltage));
                                                              if (isNaN(Number(s_tempjson.ENERGY.Current))) {
                                                                  await setStateAsync(s_state_FullPath + ".Energy-Current", 0, true);
                                                              } else {
                                                                  await setStateAsync(s_state_FullPath + ".Energy-Current", Number(s_tempjson.ENERGY.Current), true);
                                                              };
                                                              DebugWarning("Startup: Energy-Current: " + Number(s_tempjson.ENERGY.Current));
                                                              if (b_Temperature == true) {
                                                                  await setStateAsync(s_state_FullPath + ".Temperature", Number(s_tempjson.ANALOG.Temperature), true);
                                                                  DebugWarning("Startup: Temperature: " + Number(s_tempjson.ANALOG.Temperature));
                                                              }
                                                          }
                                                      }
                                                  }
                                              }
                                              catch (error) {
                                                  DebugWarning(error);
                                                  log(error);
                                              }
                                          }
                                          
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          //  _____        _                               _    _       
                                          // |  __ \      | |                             | |  | |      
                                          // | |  | | __ _| |_ ___ _ __  _ __  _   _ _ __ | | _| |_ ___ 
                                          // | |  | |/ _` | __/ _ \ '_ \| '_ \| | | | '_ \| |/ / __/ _ \
                                          // | |__| | (_| | ||  __/ | | | |_) | |_| | | | |   <| ||  __/
                                          // |_____/ \__,_|\__\___|_| |_| .__/ \__,_|_| |_|_|\_\\__\___|
                                          //                            | |                             
                                          //                            |_|    
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          // Zielpunkte anlegen falls noch nicht vorhanden
                                          //DebugWarning("Startup: Erstelle ggf. Datenpunkte ...");
                                          // Das erstellen machen wir in einer async Funktion
                                          CreateMyStatesAndStartup();
                                          
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          //   _____ _             _               
                                          //  / ____| |           | |              
                                          // | (___ | |_ __ _ _ __| |_ _   _ _ __  
                                          //  \___ \| __/ _` | '__| __| | | | '_ \ 
                                          //  ____) | || (_| | |  | |_| |_| | |_) |
                                          // |_____/ \__\__,_|_|   \__|\__,_| .__/ 
                                          //                                | |    
                                          //                                |_|    
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          // Ist nun in die Funktion CreateMyStatesAndStartup(); integriert
                                          
                                          
                                          
                                          
                                          
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          //   _____       _                   _       _   _                 
                                          //  / ____|     | |                 (_)     | | (_)                
                                          // | (___  _   _| |__  ___  ___ _ __ _ _ __ | |_ _  ___  _ __  ___ 
                                          //  \___ \| | | | '_ \/ __|/ __| '__| | '_ \| __| |/ _ \| '_ \/ __|
                                          //  ____) | |_| | |_) \__ \ (__| |  | | |_) | |_| | (_) | | | \__ \
                                          // |_____/ \__,_|_.__/|___/\___|_|  |_| .__/ \__|_|\___/|_| |_|___/
                                          //                                    | |                          
                                          //                                    |_|                          
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          // Status einlesen und nach javascript.0 schreiben wenn per MQTT etwas neues reinkommt
                                          // Wird aufgerufen wenn eine MQTT-POWER Meldung reinkommt. Die wird bei jedem Ein-/Ausschalten erzeugt egal ob
                                          // ioBroker, ein Schalter, Fernbedienung oder ein Klick in der Weboberfläche das ausgelöst hat
                                          // change: "ne" sollte dafür sorgen das es nur aufgerufen wird wenn der Wert sich vom vorherigen unterscheidet
                                          //on({ id: [].concat(Array.prototype.slice.apply($('channel[state.id=mqtt.0.stat.Gosund166.POWER*]'))), change: 'ne' },
                                          //on({ id: Array.prototype.slice.apply($("channel[state.id="+s_mqtt_POWER_path+"]")), change: "ne" }, function (obj) {
                                          if (b_hcsr04 == false) {
                                              on({ id: Array.prototype.slice.apply($("channel[state.id="+s_mqtt_POWER_path+"]")), change: "ne" }, function (obj) {
                                              //on({ id: s_mqtt_POWER_path, change: "ne" }, function (obj) {
                                                  // DebugWarning("Subscription on() START: " + s_mqtt_POWER_path);
                                                  DebugWarning("Subscription on() START: " + obj.id);
                                                  // POWER oder POWER1..x ? Lässt sich aus dem Datenpunktnamen ermitteln, obj.id
                                                  let s_powernumber = String(obj.id).slice(-1);
                                                  if (s_powernumber === "R") {
                                                      s_powernumber = ""
                                                  }
                                                  
                                                  // Der aktuelle Status der gerade gekommen ist: ON oder OFF
                                                  var s_value_mqtt = obj.state.val;
                                                  // Wir holen den Status den wir aktuell unterhalb von JavaScript gespeichert habem
                                                  var s_value_javascript = getState(s_state_power_path + s_powernumber).val;
                                                  // Auswerten von ON und OFF und umsetzung on true oder false
                                                  var b_helper_mqtt = false;
                                                  if (s_value_mqtt == 'ON') {
                                                      b_helper_mqtt = true;
                                                  } else {
                                                      b_helper_mqtt = false;
                                                  }
                                                  // prüfen ob die Werte wirklich ungleich sein sind und wir was ändern müssen
                                                  if (b_helper_mqtt != s_value_javascript) {
                                                      if (s_value_mqtt == 'ON') {
                                                          setState(s_state_power_path, true, true);
                                                          if (b_HourMeter == true) {
                                                              // Aktuelle Uhrzeit wegschreiben - Einschalten
                                                              i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
                                                              setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
                                                          }
                                                          // @ts-ignore
                                                          if (b_UseSystemEventLog == true) {
                                                              createEventlog(s_DeviceName, 'ON (per MQTT stat-POWER' + s_powernumber + ')');
                                                          }
                                                          DebugWarning("Subscription on() STATUS: " + s_mqtt_POWER_path + s_powernumber + ": ON");
                                                      } else {
                                                          setState(s_state_power_path, false, true);
                                                          if (b_HourMeter == true) {
                                                              // Aktuelle Uhrzeit wegschreiben - Ausschalten
                                                              i_global_unixtimeSwitchedOff = Math.floor(Date.now() / 1000);
                                                              setState(s_state_FullPath + ".tmp.unixtimeSwitchedOff", i_global_unixtimeSwitchedOff, true);
                                                              CalculateSwitchedOnDuration();
                                                              // Aktuelle Einschaltzeit auf 0 setzen
                                                              setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, true);
                                                              setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", true);
                                                          }
                                                          if (b_UseSystemEventLog == true) {
                                                              createEventlog(s_DeviceName, 'OFF (per MQTT stat-POWER)');
                                                          }
                                          
                                                          DebugWarning("Subscription on() STATUS: " + s_mqtt_POWER_path + s_powernumber + ": OFF");
                                          
                                                      }
                                                  }
                                                  DebugWarning("Subscription on() ENDE: " + s_mqtt_POWER_path + s_powernumber);
                                              });
                                          }
                                          
                                          // ####################################################################################################################################################
                                          // Status setzen nachdem der JavaScript-Datenpunkt geändert wurde (den, den wir z.B. für Widgets in VIS verwenden)
                                          // fromNe: o_js_Instance sorgt dafür das es NICHT angetriggert wird wenn der Datenpunkt durch diese JavaScript Instanz geändert wurde.
                                          // zusätzlich prüfen wir ob ohne Bestätigung geschrieben wurde
                                          // Wenn also eine MQTT Auswertung einer der anderen on() der Grund war wird dies hier NICHT aufgerufen
                                          // Die Variable o_js_Instance wird oben bei den Variablen-Definitionen gesetzt
                                          if (b_hcsr04 == false) {
                                              var s_state_power_path_multi = s_state_power_path;
                                              if (i_NumberOfPower > 1) {
                                                  s_state_power_path_multi = s_state_power_path_multi + "*"
                                              }
                                              on({ id: Array.prototype.slice.apply($("channel[state.id="+s_state_power_path_multi+"]")), change: "ne", fromNe: o_js_Instance, ack: false }, function (obj) {
                                              // on({ id: s_state_power_path, change: "ne", fromNe: o_js_Instance, ack: false }, function (obj) {
                                                  // DebugWarning("Subscription on() START: " + s_state_power_path);
                                                  DebugWarning("Subscription on() START: " + obj.id);
                                                  var s_value_mqtt = obj.state.val;
                                                  // POWER oder POWER1..x ? Lässt sich aus dem Datenpunktnamen ermitteln, obj.id
                                                  let s_powernumber = String(obj.id).slice(-1);
                                                  if (s_powernumber === "R") {
                                                      s_powernumber = ""
                                                  }
                                          
                                                  //var s_value_javascript = getState(s_state_power_path + s_powernumber).val;
                                                  var b_helper_mqtt = false;
                                                  // Beides nach Boolean bringen
                                                  /*if (s_value_mqtt == 'ON') {
                                                      b_helper_mqtt = true;
                                                  } else {
                                                      b_helper_mqtt = false;
                                                  } */
                                                  if (s_value_mqtt == true) {
                                                      //setState(s_mqtt_CMND_path + s_powernumber, 'ON', false);
                                                      //DebugWarning(s_mqtt_CMND_path + s_powernumber + ': ON')
                                                      sendTo(s_mqtt_Instance, 'sendMessage2Client', {topic: 'cmnd/' + s_DeviceName + '/POWER' + s_powernumber, message: 'ON'});
                                                      DebugWarning(s_mqtt_Instance + ": sendMessage2Client: " + 'cmnd/' + s_DeviceName + '/POWER' + s_powernumber + ": ON")
                                                      // Quelldatenpunkt auf bestätigt setzen
                                                      setState(obj.id, true, true);
                                                      if (b_UseSystemEventLog == true) {
                                                          createEventlog(s_DeviceName, 'ON ' + s_powernumber + '(per Datenpunkt JavaScript)');
                                                      }
                                                      if (b_HourMeter == true) {
                                                          // Aktuelle Uhrzeit wegschreiben - Einschalten
                                                          i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
                                                          setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
                                                          // Aktuelle Einschaltdauer auf 0 setzen
                                                          setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, true);
                                                          setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", true);
                                                      }
                                                      DebugWarning("Subscription on() STATUS: " + s_state_power_path + s_powernumber + ": ON");
                                                  } else {
                                                      //setState(s_mqtt_CMND_path + s_powernumber, 'OFF', false);
                                                      //DebugWarning(s_mqtt_CMND_path + s_powernumber + ': OFF')
                                                      sendTo(s_mqtt_Instance, 'sendMessage2Client', {topic: 'cmnd/' + s_DeviceName + '/POWER' + s_powernumber, message: 'OFF'});
                                                      DebugWarning(s_mqtt_Instance + ": sendMessage2Client: " + 'cmnd/' + s_DeviceName + '/POWER' + s_powernumber + ": OFF")
                                                      // Quelldatenpunkt auf bestätigt setzen
                                                      setState(obj.id, false, true);
                                                      if (b_UseSystemEventLog == true) {
                                                          createEventlog(s_DeviceName, 'OFF ' + s_powernumber + ' (per Datenpunkt JavaScript)');
                                                      }
                                                      if (b_HourMeter == true) {
                                                          // Letzte Laufzeit ausrechnen und wegschreiben
                                                          i_global_unixtimeSwitchedOff = Math.floor(Date.now() / 1000);
                                                          setState(s_state_FullPath + ".tmp.unixtimeSwitchedOff", i_global_unixtimeSwitchedOff, true);
                                                          CalculateSwitchedOnDuration();
                                                          // Aktuelle Einschaltzeit auf 0 setzen
                                                          setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, true);
                                                          setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", true);
                                                      }
                                                      DebugWarning("Subscription on() STATUS: " + s_state_power_path + s_powernumber + ": OFF");
                                                  }
                                                  DebugWarning("Subscription on() ENDE: " + s_state_power_path + s_powernumber);
                                              });
                                          }
                                          
                                          // ####################################################################################################################################################
                                          // Tasmota sendet seinen Status und Infos regelmäßig per MQTT als JSON, Default sind alle 300 Sekunden
                                          // das nutzen wir aus um weitere Daten zu erfassen
                                          // ####################################################################################################################################################
                                          // STATUS Meldung
                                          on({ id: s_mqtt_STATE_path, change: "ne" }, function (json) {
                                              DebugWarning("Subscription on() START: " + s_mqtt_STATE_path);
                                              try {
                                                  var obj = JSON.parse(json.state.val);
                                          
                                                  let myBSSId = String(obj.Wifi.BSSId);
                                                  if (b_GetNameOfAccessPoints == true) {
                                                      myAccessPoint = String(getState(s_AccessPoints_path + myBSSId).val);
                                                  }
                                                  if (b_hcsr04 == false) {
                                                      if (i_NumberOfPower == 1) {
                                                          var b_helper_mqtt = false;
                                                          if (obj.POWER == "ON") {
                                                              b_helper_mqtt = true;
                                                          } else {
                                                              b_helper_mqtt = false;
                                                          }
                                                          if (b_helper_mqtt != getState(s_state_FullPath + ".POWER").val) {
                                                              setState(s_state_FullPath + ".POWER", b_helper_mqtt);
                                                              if (obj.POWER == 'ON') {
                                                                  if (b_UseSystemEventLog == true) {
                                                                      createEventlog(s_DeviceName, 'ON (per MQTT tele-STATE Meldung)');
                                                                  }
                                                              } else {
                                                                  if (b_UseSystemEventLog == true) {
                                                                      createEventlog(s_DeviceName, 'OFF (per MQTT tele-STATE Meldung)');
                                                                  }
                                                              }
                                                          }
                                                      }
                                                  } else {
                                                      var b_helper_mqtt = false;
                                                      for (let i = 1; i < (i_NumberOfPower + 1); i++) {
                                                          b_helper_mqtt = false;
                                                          if (obj["POWER" + i] == "ON") {
                                                              b_helper_mqtt = true;
                                                          } else {
                                                              b_helper_mqtt = false;
                                                          }
                                                          if (b_helper_mqtt != getState(s_state_FullPath + ".POWER" + i).val) {
                                                              setState(s_state_FullPath + ".POWER" + i, b_helper_mqtt);
                                                              if (obj["POWER" + i] == 'ON') {
                                                                  if (b_UseSystemEventLog == true) {
                                                                      createEventlog(s_DeviceName, 'ON ' + i + ' (per MQTT tele-STATE Meldung)');
                                                                  }
                                                              } else {
                                                                  if (b_UseSystemEventLog == true) {
                                                                      createEventlog(s_DeviceName, 'OFF ' + i + ' (per MQTT tele-STATE Meldung)');
                                                                  }
                                                              }
                                                          }
                                          
                                                      }
                                                  }
                                          
                                                  setState(s_state_FullPath + ".RSII", Number(obj.Wifi.RSSI), true);
                                                  setState(s_state_FullPath + ".BSSId", myBSSId, true);
                                                  if (b_GetNameOfAccessPoints == true) {
                                                      setState(s_state_FullPath + ".AccessPoint", myAccessPoint, true);
                                                  }
                                                  setState(s_state_FullPath + ".Channel", Number(obj.Wifi.Channel), true);
                                                  // POWER prüfen ob die Werte wirklich ungleich sein sind und nur dann schreiben
                                              } catch (e) {
                                                  DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_STATE_path + " : " + e);
                                                  return;
                                              }
                                              DebugWarning("Subscription on() ENDE: " + s_mqtt_STATE_path);
                                          });
                                          // ####################################################################################################################################################
                                          // INFO1 Meldung (enthält Gerätetyp und Firmwareversion)
                                          on({ id: s_mqtt_INFO1_path, change: "any" }, function (json) {
                                              DebugWarning("Subscription on() START: " + s_mqtt_INFO1_path);
                                              try {
                                                  var obj = JSON.parse(json.state.val);
                                                  if (b_Firmware95 == false) {
                                                      // bis Tasmota Version 9.3.1
                                                      setState(s_state_FullPath + ".DeviceType", String(obj.Module), true);
                                                      setState(s_state_FullPath + ".Version", String(obj.Version), true);
                                                  } else {
                                                      // ab Tasmota Version 9.5
                                                      setState(s_state_FullPath + ".DeviceType", String(obj.Info1.Module), true);
                                                      setState(s_state_FullPath + ".Version", String(obj.Info1.Version), true);
                                                  }
                                              } catch (e) {
                                                  DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_INFO1_path);
                                                  return;
                                              }
                                              DebugWarning("Subscription on() ENDE: " + s_mqtt_INFO1_path);
                                          });
                                          // ####################################################################################################################################################
                                          // INFO2 Meldung (enthält die IP-Adresse)
                                          on({ id: s_mqtt_INFO2_path, change: "any" }, function (json) {
                                              DebugWarning("Subscription on() START: " + s_mqtt_INFO2_path);
                                              try {
                                                  var obj = JSON.parse(json.state.val);
                                                  if (b_Firmware95 == false) {
                                                      // bis Tasmota Version 9.3.1
                                                      setState(s_state_FullPath + ".IPAddress", String(obj.IPAddress), true);
                                                  } else {
                                                      // ab Tasmota Version 9.5
                                                      setState(s_state_FullPath + ".IPAddress", String(obj.Info2.IPAddress), true);
                                                  }
                                              } catch (e) {
                                                  DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_INFO2_path);
                                                  return;
                                              }
                                              DebugWarning("Subscription on() ENDE: " + s_mqtt_INFO2_path);
                                          });
                                          // ####################################################################################################################################################
                                          // stat/.../STATUS Meldung (enthält den FriendlyName)
                                          on({ id: s_mqtt_STATUS_path, change: "any" }, function (json) {
                                              DebugWarning("Subscription on() START: " + s_mqtt_STATUS_path);
                                              try {
                                                  var obj = JSON.parse(json.state.val);
                                                  if (b_Firmware95 == false) {
                                                      // bis Tasmota Version 9.3.1
                                                      setState(s_state_FullPath + ".FriendlyName", String(obj.FriendlyName), true);
                                                  } else {
                                                      // ab Tasmota Version 9.5
                                                      setState(s_state_FullPath + ".FriendlyName", String(obj.Status.FriendlyName[0]), true);
                                                  }
                                              } catch (e) {
                                                  DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_STATUS_path);
                                                  return;
                                              }
                                              DebugWarning("Subscription on() ENDE: " + s_mqtt_STATUS_path);
                                          });
                                          
                                          
                                          // ####################################################################################################################################################
                                          // SENSOR Meldung Stromverbrauch
                                          // Wird nur beachtet wenn der Parameter am Skriptanfang gesetzt wird
                                          // @ts-ignore
                                          if (b_Energy == true) {
                                              on({ id: s_mqtt_SENSOR_path, change: "any" }, function (json) {
                                                  DebugWarning("Subscription on() START: " + s_mqtt_SENSOR_path + " (Energy)");
                                                  try {
                                                      var obj = JSON.parse(json.state.val);
                                                      if (b_Firmware95 == false) {
                                                          // bis Tasmota Version 9.3.1
                                                          // Muss ich noch nachprüfen, hab nur noch Tasmota 10 Geräte
                                                      } else {
                                                          // ab Tasmota Version 9.5
                                                          setState(s_state_FullPath + ".Energy-Total", Number(obj.ENERGY.Total), true);
                                                          setState(s_state_FullPath + ".Energy-Yesterday", Number(obj.ENERGY.Yesterday), true);
                                                          setState(s_state_FullPath + ".Energy-Today", Number(obj.ENERGY.Today), true);
                                                          setState(s_state_FullPath + ".Energy-Power", Number(obj.ENERGY.Power), true);
                                                          if (isNaN(Number(obj.ENERGY.Voltage))) {
                                                              setState(s_state_FullPath + ".Energy-Voltage", 0, true);
                                                          } else {
                                                              setState(s_state_FullPath + ".Energy-Voltage", Number(obj.ENERGY.Voltage), true);
                                                          };
                                                          if (isNaN(Number(obj.ENERGY.Current))) {
                                                              setState(s_state_FullPath + ".Energy-Current", 0, true);
                                                          } else {
                                                              setState(s_state_FullPath + ".Energy-Current", Number(obj.ENERGY.Current), true);
                                                          }
                                                          if (b_Temperature == true) {
                                                              setState(s_state_FullPath + ".Temperature", Number(obj.ANALOG.Temperature), true);
                                                          }
                                                      }
                                                  } catch (e) {
                                                      DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_SENSOR_path);
                                                      return;
                                                  }
                                                  DebugWarning("Subscription on() ENDE: " + s_mqtt_SENSOR_path);
                                              });
                                          }
                                          // ####################################################################################################################################################
                                          // SENSOR Meldung EasyMeterQ3A
                                          // @ts-ignore
                                          if (b_EasyMeterQ3A == true) {
                                              on({ id: s_mqtt_SENSOR_path, change: "any" }, function (json) {
                                                  DebugWarning("Subscription on() START: " + s_mqtt_SENSOR_path + " (EasyMeterQ3A)");
                                                  /*
                                                  {"Time":"2023-04-04T23:07:45",
                                                      "SML":{
                                                          "Verbrauch_T1":95.4412923,
                                                          "Verbrauch_T2":0.2737477,
                                                          "Verbrauch_Summe":95.7150401,
                                                          "Einspeisung_Summe":101.5756287,
                                                          "Watt_L1":2803.85,
                                                          "Watt_L2":1062.85,
                                                          "Watt_L3":242.30,
                                                          "Watt_Summe":4109.01,
                                                          "Volt_L1":235.9,
                                                          "Volt_L2":236.3,
                                                          "Volt_L3":236.2}}
                                                  */
                                                  try {
                                                      var obj = JSON.parse(json.state.val);
                                                      setState(s_state_FullPath + ".Verbrauch-Summe", Number(obj.SML.Verbrauch_Summe), true);
                                                      setState(s_state_FullPath + ".Einspeisung-Summe", Number(obj.SML.Einspeisung_Summe), true);
                                                      setState(s_state_FullPath + ".Watt-L1", Number(obj.SML.Watt_L1), true);
                                                      setState(s_state_FullPath + ".Watt-L2", Number(obj.SML.Watt_L2), true);
                                                      setState(s_state_FullPath + ".Watt-L3", Number(obj.SML.Watt_L3), true);
                                                      setState(s_state_FullPath + ".Watt-Summe", Number(obj.SML.Watt_Summe), true);
                                                      setState(s_state_FullPath + ".Volt-L1", Number(obj.SML.Volt_L1), true);
                                                      setState(s_state_FullPath + ".Volt-L2", Number(obj.SML.Volt_L2), true);
                                                      setState(s_state_FullPath + ".Volt-L3", Number(obj.SML.Volt_L3), true);
                                                  } catch (e) {
                                                      DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_SENSOR_path);
                                                      return;
                                                  }
                                                  DebugWarning("Subscription on() ENDE: " + s_mqtt_SENSOR_path);
                                              });
                                          }
                                          // ####################################################################################################################################################
                                          // SENSOR Meldung Ultraschall Entfernungsmessung
                                          // Wird nur beachtet wenn der Parameter am Skriptanfang gesetzt wird
                                          // @ts-ignore
                                          if (b_hcsr04 == true) {
                                              on({ id: s_mqtt_SENSOR_path, change: "any" }, function (json) {
                                                  DebugWarning("Subscription on() START: " + s_mqtt_SENSOR_path + " (HC-SR04)");
                                                  try {
                                                      var obj = JSON.parse(json.state.val);
                                                      if (b_Firmware95 == false) {
                                                          // bis Tasmota Version 9.3.1
                                                          // Muss ich noch nachprüfen, hab nur noch Tasmota 10 Geräte
                                                      } else {
                                                          // ab Tasmota Version 9.5
                                                          setState(s_state_FullPath + ".Distance", Number(obj.SR04.Distance), true);
                                                      }
                                                  } catch (e) {
                                                      DebugWarning("Subscription on() ENDE per Fehler: " + s_mqtt_SENSOR_path);
                                                      return;
                                                  }
                                                  DebugWarning("Subscription on() ENDE: " + s_mqtt_SENSOR_path);
                                              });
                                          }
                                          
                                          
                                          // ####################################################################################################################################################
                                          // ####################################################################################################################################################
                                          
                                          

                                          Im Skript müsst Ihr oben in Zeile 2 den Namen einsetzen den Ihr beim Tasmota-Gerät als Topic eingestellt habt. Unter diesen Namen tauchen auch die Einträge in den Topics /tele etc. auf.
                                          Das Suffix in Zeile 3 könnte ihr leer lassen, ansonsten wird es an den Namen des Gerätes angehängt bei dem Stammpfad unterhalb von 0_userdata.0.tasmota.xxx
                                          In Zeile 10 könnt Ihr die Anzahl der Schaltbaren Ausgänge einstellen, normalerweise 1

                                          // Anzahl der schaltbaren Ausgänge, 1 bis x, 1 = nur POWER, ab 2 und mehr POWER1, POWER2 usw.
                                          var i_NumberOfPower = 1;
                                          

                                          In Zeile 23 könnte ihr ggf. die MQTT-Instanz anpassen

                                          // Name der MQTT-Instanz
                                          var s_mqtt_Instance = "mqtt.0";
                                          

                                          Dann startet das Skript. Beim ersten mal werden die Datenpunkte angelegt.

                                          In Zeile 27 gibt es den Eintrag

                                          var b_logging = false;
                                          

                                          Wenn Ihr den auf true setzt so bekommt Ihr Statusmeldungen im Log und in der JavaScript-Konsole. Das würde ich nur zum testen anmachen und auf keinen Fall für alle Geräte.

                                          Pro Tasmota-Gerät braucht Ihr eine neue Kopie des Skriptes!
                                          In ioBroker sieht das dann so bei den Datenpunkten aus:
                                          01f7f533-97b7-4a3e-8409-c152909193e5-image.png


                                          Sonderfunktionen 1: Eventlog
                                          Es gibt eine Funktion createEventlog ab Zeile 213:

                                          function createEventlog(EventType, EventText) {
                                              let tasmotaEventListDestination = "0_userdata.0.EventLog.Tasmota.";
                                              // vorhandene Einträge einlesen
                                              let EventList = getState(tasmotaEventListDestination + "EventLogTasmota").val;
                                              // Anzahl der Maximal erlaubten Einträge einlesen
                                              let maxEventCount = getState("0_userdata.0.EventLog.Tasmota.maxEventCount").val;
                                          

                                          Um diese zu Verwenden muss man die folgenden 3 Datenpunkte von Hand erstellen:

                                          0_userdata.0.EventLog.Tasmota.EventLogTasmota => String
                                          0_userdata.0.EventLog.Tasmota.NextEventId => Zahl
                                          0_userdata.0.EventLog.Tasmota.maxEventCount  => Zahl => Wert 1024 oder nach Wunsch
                                          

                                          de7da837-f623-49aa-993c-889cece3a4eb-image.png

                                          Das Eventlogging schaltet man dann in Zeile 86 ein:

                                          // Zentrales Log über alle Ein- und Ausschaltvorgänge führen
                                          var b_UseSystemEventLog = true;
                                          

                                          Er führt dann eine Ereignisliste die man sich in einem HTML-Widget ausgeben lassen kann:

                                          0008686 - 29.09.24 11:29:00 - Steckdose-2-142 - OFF (per MQTT stat-POWER)
                                          0008685 - 29.09.24 11:29:00 - Steckdose-2-141 - OFF (per MQTT stat-POWER)
                                          0008684 - 29.09.24 11:28:00 - Steckdose-2-141 - ON (per MQTT stat-POWER)
                                          0008683 - 29.09.24 11:27:00 - Steckdose-2-147 - OFF (per MQTT stat-POWER)
                                          0008682 - 29.09.24 11:27:00 - Steckdose-2-142 - ON (per MQTT stat-POWER)
                                          0008681 - 29.09.24 11:27:00 - Steckdose-2-141 - OFF (per MQTT stat-POWER)
                                          0008680 - 29.09.24 11:26:00 - Steckdose-2-141 - ON (per MQTT stat-POWER)
                                          0008679 - 29.09.24 11:25:00 - Steckdose-2-141 - OFF (per MQTT stat-POWER)
                                          0008678 - 29.09.24 11:25:00 - Steckdose-2-142 - OFF (per MQTT stat-POWER)
                                          0008677 - 29.09.24 11:25:00 - Steckdose-2-147 - ON (per MQTT stat-POWER)
                                          0008676 - 29.09.24 11:24:00 - Steckdose-2-142 - ON (per MQTT stat-POWER)
                                          0008675 - 29.09.24 11:23:00 - Steckdose-2-141 - ON (per MQTT stat-POWER)
                                          0008674 - 29.09.24 11:19:51 - Gosund166 - ON 1(per Datenpunkt JavaScript)
                                          0008673 - 29.09.24 11:19:46 - Gosund166 - OFF 1 (per Datenpunkt JavaScript)
                                          0008672 - 29.09.24 11:17:27 - Gosund166 - ON 1(per Datenpunkt JavaScript)
                                          0008671 - 29.09.24 11:16:49 - Gosund166 - OFF 1 (per Datenpunkt JavaScript)
                                          0008670 - 29.09.24 11:10:40 - Gosund166 - OFF 1 (per Datenpunkt JavaScript)
                                          0008669 - 29.09.24 11:06:40 - Gosund166 - ON 1(per Datenpunkt JavaScript)
                                          0008668 - 29.09.24 11:06:18 - Gosund166 - OFF 1 (per Datenpunkt JavaScript)
                                          0008667 - 29.09.24 10:00:56 - K07-Badezimmerspiegel - OFF (per MQTT stat-POWER)
                                          0008666 - 29.09.24 09:53:38 - K07-Badezimmerspiegel - ON (per MQTT stat-POWER)
                                          0008665 - 29.09.24 09:50:31 - K07-Badezimmerspiegel - OFF (per MQTT stat-POWER)
                                          0008664 - 29.09.24 09:50:31 - K06-Licht-Badezimmer - OFF (per MQTT stat-POWER)
                                          0008663 - 29.09.24 09:46:44 - K07-Badezimmerspiegel - ON (per MQTT stat-POWER)
                                          0008662 - 29.09.24 09:46:42 - K06-Licht-Badezimmer - ON (per MQTT stat-POWER)
                                          0008661 - 29.09.24 09:18:10 - K07-Badezimmerspiegel - OFF (per MQTT stat-POWER)
                                          0008660 - 29.09.24 09:04:38 - K07-Badezimmerspiegel - ON (per MQTT stat-POWER)
                                          0008659 - 29.09.24 08:23:00 - Steckdose-2-145 - OFF (per Datenpunkt JavaScript)
                                          


                                          Sonderfunktionen 1: AccessPoints
                                          Ich lasse mir bei meinen Geräten anzeigen mit welchen meiner AccessPoints diese verbunden sind:
                                          7ed38255-cc6b-4edc-b3bb-a54fcedeecfc-image.png

                                          Wer das auch will muss unterhalb von

                                          0_userdata.0.001-Konstanten.WLAN.
                                          

                                          Seine AccessPoints mit deren BSSId als Datenpunktnamen als String anlegen, als Wert dann den Namen des AccessPoint:
                                          a0eb167c-433d-40c7-b89a-7d9782a6fb79-image.png

                                          Dann kann man das in Zeile 82 Einschalten:

                                          // Private Einstellungen die nur für meine Umgebung funktionieren oder von euch zuerst die Voraussetzungen geschafft werden müssen
                                          // Soll der Name des AccessPoints ermittelt werden?
                                          // @ts-ignore
                                          var b_GetNameOfAccessPoints = true;
                                          // Pfad für das auslesen des AccessPoints. Dort gibt es für jeden AccessPoint einen Datenpunkt vom Typ String welcher die MAC als ID und den Namen als Wert hat
                                          var s_AccessPoints_path = "0_userdata.0.001-Konstanten.WLAN.";
                                          
                                          M Offline
                                          M Offline
                                          michelhsv
                                          schrieb am zuletzt editiert von
                                          #25

                                          @bananajoe Hallo, vielen Dank für das Script. Es hat bisher wunderbar funktioniert, jetzt habe ich meine Tasmota Geräte auf 13.2.0 upgedatet. Leider bekomme ich jetzt keine Energy Meldungen mehr außer Spannung und Strom. Wenn ich den Log aktiviere sehe ich aber das er die Werte ausliest. Hast Du hierzu vielleich eine Idee? Danke

                                          BananaJoeB 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

                                          788

                                          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