Neuer Blogbeitrag: Monatsrückblick - Dezember 2025 🎄

[FredF]

@haselchen
:rolling_on_the_floor_laughing: Da bin ich mir sicher

[Jan1]

@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.

[crunchip]

@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

[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!

[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.

[McChip]

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

[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.

[BananaJoe]

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

[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

[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.

[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.

[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.

[McChip]

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

[BananaJoe]

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)

[randomuser123]

@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

[michelhsv]

@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

[BananaJoe]

@michelhsv da wird sich was an den JSON-Pfaden geändert haben.
Post man den Inhalt von

mqtt.0.tele.[name-deines-gerätes].SENSOR

Ich habe noch nicht viele auf 13.2.0, von denen die Energie messen noch gar keines.

[michelhsv]

@bananajoe hier die Werte aus dem Sensor
{"Time": "2023-11-02T11:20:37","ENERGY": {"TotalStartTime": "2023-05-10T12:58:00","Total": 0.417,"Yesterday": 0.088,"Today": 0.042,"Period": 0,"Power": 4,"ApparentPower": 12,"ReactivePower": 12,"Factor": 0.3,"Voltage": 229,"Current": 0.053}}

Im Log sehe ich das die Werte gelesen werden:

11:22:27.342 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: aktuellen Status von POWER holen und schreiben
11:22:27.342 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: aktuellen Status von INFO1 holen und schreiben
11:22:27.349 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: DeviceType: NOUS A1T
11:22:27.403 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: Version: 13.2.0(tasmota)
11:22:27.447 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: aktuellen Status von INFO2 holen und schreiben
11:22:27.449 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: IPAddress: 192.168.20.66
11:22:27.449 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: aktuellen Status von SENSOR holen und schreiben
11:22:27.498 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: Energy-Total: 0.417
11:22:27.500 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: Energy-Yesterday: 0.088
11:22:27.502 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: Energy-Today: 0.042
11:22:27.504 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: Energy-Power: 4
11:22:27.506 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: Energy-Voltage: 229
11:22:27.508 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Startup: Energy-Current: 0.053
11:22:27.570 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Subscription on() START: mqtt.0.Steckdose.tele.Gruenbeck.STATE
11:22:27.570 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Subscription on() ENDE: mqtt.0.Steckdose.tele.Gruenbeck.STATE
11:22:27.571 warn javascript.0 (7446) script.js.Tasmota.Gruenbeck: Subscription on() START: mqtt.0.Steckdose.tele.Gruenbeck.SENSOR

Habe auf ein Gerät wieder die Software 12.5 eingespielt, das gleiche Problem. Der Fehler muss irgendwo anders liegen, ich weiß aber nicht wann die Punkte verschwunden sind das nur noch Strom und Spannung angezeigt werden.

[BananaJoe]

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

@bananajoe hier die Werte aus dem Sensor
{"Time": "2023-11-02T11:20:37","ENERGY": {"TotalStartTime": "2023-05-10T12:58:00","Total": 0.417,"Yesterday": 0.088,"Today": 0.042,"Period": 0,"Power": 4,"ApparentPower": 12,"ReactivePower": 12,"Factor": 0.3,"Voltage": 229,"Current": 0.053}}

Sicher das du oben im Kopf des Scriptes var b_Energy = true; gesetzt hast?

Ich wollte schon immer mal eine Version bauen die das automatisch erkennt ... wen ich mal wirklich nichts anderes vor habe ...

Der JSON aus SENSOR sieht ansonsten ok aus.
Welche Version des Skriptes setzt du denn ein?

Ansonsten hier mal meine letzte Version. Schau die die Konfiguration am Anfang genau an bitte, also Zeile 2 bis 14
Die Datenpunkte werden alle unter 0_userdata.0.tasmota angelegt.

// Setup
var s_DeviceName = "Blitzwolf099";
// Suffix wird an den Devicenamen für die Zieldatenpunkte angehängt, z.B. "-Waschmaschine" (KEINE Punkte!!!)
var s_Suffix = "-Handtuchtrocker";
// 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 = true;
// Erfassung von Temperaturwerten (Shelly 1PM)
var b_Temperature = false;
// Sollen die Datenpunkte nachträglich korrigiert werden?
var b_CorrectDatapoints = true;
// Name der MQTT-Instanz
var s_mqtt_Instance = "mqtt.0";
// Festlegen der Skriptversion (für Auswertungen)
var s_VersionJSScript = "1.18"
//
// 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 Firmwware-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 expliziete 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 aktuzelle 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
// 
// 2020 - 2022 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
//
// Ist die Firmware des Tasmota-Gerätes 9.5 oder höger so muss "b_Firmware95 = true" gestezt 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?
const 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.";
// Soll das SystemEventLog genutzt werden? Siehe https://www.smarthome-tricks.de/software-iobroker/eigenes-logging-in-iobroker/
const b_UseSystemEventLog = true;
// ####################################################################################################################################################
// 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
const o_js_Instance = 'system.adapter.javascript.' + instance;
// Logging aktivieren für das Debuggen in die JavaScript-Console und in das ioBroker Log (true oder false):
var b_UseLogging = false;
// 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
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++;
        }
    }
}

// Benötigte Datenpunkte erstellen
async function CreateMyStatesAndStartup(){
    try {
        DebugWarning("Startup: Erstelle ggf. Datenpunkte ...");
        // #######################################################################################################
        // POWER
        await createStateAsync(s_state_FullPath + ".POWER", false, {
            type: 'boolean',
            read: true, 
            write: true, 
            role: "switch",
            name: s_DeviceName + s_Suffix + '.POWER'
        });
        // #######################################################################################################
        // 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: 'Version'
        });
        // #######################################################################################################
        // Datenpunkte für Betriebsstundenzähler / Einschaltdauer
        // 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");
            // #######################################################################################################
        }

        // 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
        s_tempjson = getState(s_mqtt_POWER_path).val;
        if ( s_tempjson == "ON" ) {
            setState(s_state_power_path, true, 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_rootpath + s_DeviceName + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
            }
        } else {
            setState(s_state_power_path, 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));
            }
        }
        // #######################################################################################################
        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: s_mqtt_POWER_path, change: "ne" }, function (obj) {
    DebugWarning("Subscription on() START: " + s_mqtt_POWER_path);
    // 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).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);
            // Aktuelle Uhrzeit wegschreiben - Einschalten
            i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
            setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
            if (b_UseSystemEventLog == true) {
                createEventlog(s_DeviceName, 'ON (per MQTT stat-POWER)');
            }
            DebugWarning("Subscription on() STATUS: " + s_mqtt_POWER_path + ": ON");
        } else {
            setState(s_state_power_path, false, true);
            // Aktuelle Uhrzeit wegschreiben - Ausschalten
            i_global_unixtimeSwitchedOff = Math.floor(Date.now() / 1000);
            setState(s_state_FullPath + ".tmp.unixtimeSwitchedOff", i_global_unixtimeSwitchedOff, true);
            if (b_UseSystemEventLog == true) {
                createEventlog(s_DeviceName, 'OFF (per MQTT stat-POWER)');
            }
            CalculateSwitchedOnDuration();
            DebugWarning("Subscription on() STATUS: " + s_mqtt_POWER_path + ": OFF");
            // Aktuelle Einschaltzeit auf 0 setzen
            setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, true);
            setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", true);

        }
    }
    DebugWarning("Subscription on() ENDE: " + s_mqtt_POWER_path);
});

// ####################################################################################################################################################
// Status setzen nachdem die JavaScript-Varaiable geändert wurde.
// fromNe: o_js_Instance sorgt dafür das es NICHT angetriggert wird wenn der Datenpunkt durch diese JavaScript Instanz geändert 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
on({ id: s_state_power_path, change: "ne", fromNe: o_js_Instance }, function (obj) {
    DebugWarning("Subscription on() START: " + s_state_power_path);
    var s_value_mqtt = obj.state.val;
    var s_value_javascript = getState(s_state_power_path).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 (getState(s_state_power_path).val == true) {
        setState(s_mqtt_CMND_path, 'ON');
        if (b_UseSystemEventLog == true) {
            createEventlog(s_DeviceName, 'ON (per Datenpunkt JavaScript)');
        }
        // Aktuelle Uhrzeit wegschreiben - Einschalten
        i_global_unixtimeSwitchedOn = Math.floor(Date.now() / 1000);
        setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", i_global_unixtimeSwitchedOn, true);
        DebugWarning("Subscription on() STATUS: " + s_state_power_path + ": ON");
        // Aktuelle Einschaltdauer auf 0 setzen
        setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, true);
        setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", true);
    } else {
        setState(s_mqtt_CMND_path, 'OFF');
        if (b_UseSystemEventLog == true) {
            createEventlog(s_DeviceName, 'OFF (per Datenpunkt JavaScript)');
        }
        // Letzte Laufzeit ausrechnen und wegschreiben
        i_global_unixtimeSwitchedOff = Math.floor(Date.now() / 1000);
        setState(s_state_FullPath + ".tmp.unixtimeSwitchedOff", i_global_unixtimeSwitchedOff, true);
        CalculateSwitchedOnDuration();
        DebugWarning("Subscription on() STATUS: " + s_state_power_path + ": OFF");
        // Aktuelle Einschaltzeit auf 0 setzen
        setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", 0, true);
        setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", "0s", true);
    }
    DebugWarning("Subscription on() ENDE: " + s_state_power_path);
});
// Aktuelle Einschaltzeit hochzählen

// ####################################################################################################################################################
// 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);
        }
        var b_helper_mqtt = false;
        if (obj.POWER == "ON") {
            b_helper_mqtt = true;
            // Ok, wo schon mal dabei sind können wir auch gleich die aktuelle Laufzeit errechenen und wegschreiben
            i_global_CurrentPowerOnTimeSeconds = Number(Math.floor(Date.now() / 1000) - i_global_unixtimeSwitchedOn);
            setState(s_state_FullPath + ".Time-CurrentPowerOnTimeSeconds", i_global_CurrentPowerOnTimeSeconds, true);
            i_global_CurrentPowerOnTimeH = ConvertTimeHumanReadable(i_global_CurrentPowerOnTimeSeconds);
            setState(s_state_FullPath + ".Time-CurrentPowerOnTimeH", i_global_CurrentPowerOnTimeH, true);
        } else {
            b_helper_mqtt = false;
        }

        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
        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)');
                }
                // Aktuelle Uhrzeit wegschreiben - Einschalten
                setState(s_state_FullPath + ".tmp.unixtimeSwitchedOn", Date.now(), true);
            } else {
                if (b_UseSystemEventLog == true) {
                    createEventlog(s_DeviceName, 'OFF (per MQTT tele-STATE Meldung)');
                }
                setState(s_state_FullPath + ".tmp.unixtimeSwitchedOff", Date.now(), true);
                CalculateSwitchedOnDuration();
            }
        }
    } 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 (enthält Stromverbrauch)
// Wird nur beachtet wenn der Parameter am Skriptanfang gesetzt wird
if ( b_Energy == true ) {
    on({id: s_mqtt_SENSOR_path, change: "any"}, function(json) { 
        DebugWarning("Subscription on() START: " + s_mqtt_SENSOR_path);
        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);
    });
}

// ####################################################################################################################################################
// ####################################################################################################################################################

PS: Aktuell läuft das Skript bei mir 117 mal (bei allen Tasmota-Geräten wo man etwas schalten oder Messen kann)

[michelhsv]

@bananajoe Vielen Dank für Deine Unterstützung. Keine Ahnung was mit meinem ioBroker los war.
Ich habe in meiner influxdb gesehen das die Punte weiter aufgezeichnet werden. Ich habe dann unter den Objekten einen Filter auf meine influxdb gesetzt, dann habe ich die Punkte gesehen. Beim Ausschalten des Filter sind dann die Punkte geblieben.