iobroker.faikout 0.0.5

package/io-package.json

@@ -0,0 +1,185 @@
+{
+  "common": {
+    "name": "faikout",
+    "version": "0.0.5",
+    "titleLang": {
+      "en": "Faikout",
+      "de": "Faikout",
+      "ru": "Faikout",
+      "pt": "Faikout",
+      "nl": "Faikout",
+      "fr": "Faikout",
+      "it": "Faikout",
+      "es": "Faikout",
+      "pl": "Faikout",
+      "uk": "Faikout",
+      "zh-cn": "Faikout"
+    },
+    "desc": {
+      "en": "Connect Daikin air conditioners with a faikout module locally via MQTT.",
+      "de": "Verbindet Daikin-Klimaanlagen mit faikout-Modul lokal über MQTT.",
+      "ru": "Локальное подключение кондиционеров Daikin с модулем faikout через MQTT.",
+      "pt": "Liga ar condicionados Daikin com módulo faikout localmente via MQTT.",
+      "nl": "Verbindt Daikin-airco's met faikout-module lokaal via MQTT.",
+      "fr": "Connecte localement les climatiseurs Daikin équipés d'un module faikout via MQTT.",
+      "it": "Collega localmente i condizionatori Daikin con modulo faikout tramite MQTT.",
+      "es": "Conecta localmente aires acondicionados Daikin con módulo faikout mediante MQTT.",
+      "pl": "Łączy lokalnie klimatyzatory Daikin z modułem faikout przez MQTT.",
+      "uk": "Локальне підключення кондиціонерів Daikin з модулем faikout через MQTT.",
+      "zh-cn": "通过 MQTT 在本地连接带 faikout 模块的大金空调。"
+    },
+    "authors": [
+      "Immanuel"
+    ],
+    "keywords": [
+      "faikout",
+      "faikin",
+      "daikin",
+      "mqtt",
+      "climate"
+    ],
+    "licenseInformation": {
+      "type": "free",
+      "license": "MIT"
+    },
+    "platform": "Javascript/Node.js",
+    "icon": "faikout.png",
+    "enabled": true,
+    "extIcon": "https://raw.githubusercontent.com/SmarthomeElektroniker/ioBroker.faikout/main/admin/faikout.png",
+    "readme": "https://github.com/SmarthomeElektroniker/ioBroker.faikout/blob/main/README.md",
+    "loglevel": "info",
+    "tier": 2,
+    "mode": "daemon",
+    "type": "climate-control",
+    "compact": true,
+    "connectionType": "local",
+    "dataSource": "push",
+    "adminUI": {
+      "config": "json"
+    },
+    "dependencies": [
+      {
+        "js-controller": ">=6.0.11"
+      }
+    ],
+    "globalDependencies": [
+      {
+        "admin": ">=7.6.20"
+      }
+    ],
+    "news": {
+      "0.0.5": {
+        "en": "Meet the ioBroker repository requirements",
+        "de": "Anforderungen des ioBroker-Repositorys erfuellt",
+        "ru": "Соответствие требованиям репозитория ioBroker",
+        "pt": "Cumpre os requisitos do repositório ioBroker",
+        "nl": "Voldoet aan de eisen van het ioBroker-repository",
+        "fr": "Conforme aux exigences du dépôt ioBroker",
+        "it": "Conforme ai requisiti del repository ioBroker",
+        "es": "Cumple los requisitos del repositorio ioBroker",
+        "pl": "Spełnia wymagania repozytorium ioBroker",
+        "uk": "Відповідає вимогам репозиторію ioBroker",
+        "zh-cn": "满足 ioBroker 仓库的收录要求"
+      },
+      "0.0.4": {
+        "en": "Fix: admin rejected the configuration (\"invalid jsonConfig\")",
+        "de": "Fehlerbehebung: Admin verwarf die Konfiguration (\"invalid jsonConfig\")",
+        "ru": "Исправление: admin отклонял конфигурацию",
+        "pt": "Correção: o admin rejeitava a configuração",
+        "nl": "Fix: admin weigerde de configuratie",
+        "fr": "Correctif : l'admin rejetait la configuration",
+        "it": "Correzione: admin rifiutava la configurazione",
+        "es": "Corrección: admin rechazaba la configuración",
+        "pl": "Poprawka: admin odrzucał konfigurację",
+        "uk": "Виправлення: admin відхиляв конфігурацію",
+        "zh-cn": "修复：admin 拒绝了配置"
+      },
+      "0.0.3": {
+        "en": "Fix: consumption crashed after updating from 0.0.1 (missing day/month rings)",
+        "de": "Fehlerbehebung: Verbrauch lief nach dem Update von 0.0.1 auf einen Fehler (fehlende Tages-/Monatsringe)",
+        "ru": "Исправление: расход давал сбой после обновления с 0.0.1",
+        "pt": "Correção: o consumo falhava após a atualização a partir de 0.0.1",
+        "nl": "Fix: verbruik liep vast na de update vanaf 0.0.1",
+        "fr": "Correctif : la consommation échouait après la mise à jour depuis 0.0.1",
+        "it": "Correzione: il consumo si interrompeva dopo l'aggiornamento da 0.0.1",
+        "es": "Corrección: el consumo fallaba tras actualizar desde 0.0.1",
+        "pl": "Poprawka: zużycie zawodziło po aktualizacji z 0.0.1",
+        "uk": "Виправлення: споживання давало збій після оновлення з 0.0.1",
+        "zh-cn": "修复：从 0.0.1 更新后能耗计算出错"
+      },
+      "0.0.2": {
+        "en": "New VIS widget: energy history, switchable between day, month and year",
+        "de": "Neuer VIS-Baustein: Energieverlauf, umschaltbar zwischen Tag, Monat und Jahr",
+        "ru": "Отображение энергопотребления как VIS-виджета, месячные значения в адаптере",
+        "pt": "Consumo de energia como widget VIS, valores mensais no adaptador",
+        "nl": "Energieverloop als VIS-widget, maandwaarden in de adapter",
+        "fr": "Historique d'énergie comme widget VIS, valeurs mensuelles dans l'adaptateur",
+        "it": "Andamento energetico come widget VIS, valori mensili nell'adapter",
+        "es": "Histórico de energía como widget VIS, valores mensuales en el adaptador",
+        "pl": "Przebieg energii jako widget VIS, wartości miesięczne w adapterze",
+        "uk": "Графік енергоспоживання як VIS-віджет, місячні значення в адаптері",
+        "zh-cn": "能耗曲线 VIS 控件，适配器内月度数值"
+      },
+      "0.0.1": {
+        "en": "Initial version: own MQTT broker, dynamic data points, writable controls.",
+        "de": "Erste Version: eigener MQTT-Broker, dynamische Datenpunkte, schreibbare Steuerung.",
+        "ru": "Первая версия: собственный MQTT-брокер, динамические точки данных, управление.",
+        "pt": "Primeira versão: broker MQTT próprio, pontos de dados dinâmicos, controlo gravável.",
+        "nl": "Eerste versie: eigen MQTT-broker, dynamische datapunten, schrijfbare besturing.",
+        "fr": "Première version : courtier MQTT intégré, points de données dynamiques, commandes inscriptibles.",
+        "it": "Prima versione: broker MQTT proprio, punti dati dinamici, controlli scrivibili.",
+        "es": "Primera versión: broker MQTT propio, puntos de datos dinámicos, controles escribibles.",
+        "pl": "Pierwsza wersja: własny broker MQTT, dynamiczne punkty danych, sterowanie zapisywalne.",
+        "uk": "Перша версія: власний MQTT-брокер, динамічні точки даних, керування.",
+        "zh-cn": "首个版本：自带 MQTT 代理、动态数据点、可写控制。"
+      }
+    },
+    "restartAdapters": [
+      "vis",
+      "vis-2"
+    ]
+  },
+  "native": {
+    "port": 1888,
+    "user": "",
+    "pass": "",
+    "historyAnmelden": true,
+    "historyInstanz": "history.0"
+  },
+  "encryptedNative": [
+    "pass"
+  ],
+  "protectedNative": [
+    "pass"
+  ],
+  "objects": [],
+  "instanceObjects": [
+    {
+      "_id": "info",
+      "type": "channel",
+      "common": {
+        "name": {
+          "en": "Information",
+          "de": "Informationen"
+        }
+      },
+      "native": {}
+    },
+    {
+      "_id": "info.connection",
+      "type": "state",
+      "common": {
+        "role": "indicator.connected",
+        "name": {
+          "en": "At least one faikout module connected",
+          "de": "Mindestens ein faikout-Modul verbunden"
+        },
+        "type": "boolean",
+        "read": true,
+        "write": false,
+        "def": false
+      },
+      "native": {}
+    }
+  ]
+}

package/lib/broker.js

@@ -0,0 +1,129 @@
+'use strict';
+
+/*
+ * Eigener MQTT-Broker fuer die faikout-Module.
+ *
+ * Bewusst ein eigener Broker auf eigenem Port statt Mitbenutzung eines vorhandenen
+ * (z. B. mqtt.0): Die Klimaanlagen sollen von allem anderen getrennt bleiben, und der
+ * Adapter kennt so jede Nachricht seiner Geraete, ohne fremden Verkehr mitzulesen.
+ */
+
+const net = require('node:net');
+// aedes 1.x exportiert die Klasse benannt; der Aufruf als Funktion (aedes(...)) faellt weg.
+const { Aedes } = require('aedes');
+
+class FaikoutBroker {
+    /**
+     * @param {object} opts
+     * @param {number} opts.port          Port, auf dem gelauscht wird
+     * @param {string} [opts.user]        Optionaler Benutzername; leer = keine Anmeldung noetig
+     * @param {string} [opts.pass]        Passwort dazu
+     * @param {object} opts.log           Logger des Adapters
+     * @param {(topic:string, payload:Buffer)=>void} opts.onMessage
+     * @param {(clientId:string, verbunden:boolean)=>void} [opts.onClient]
+     */
+    constructor(opts) {
+        this.port = opts.port;
+        this.user = opts.user || '';
+        this.pass = opts.pass || '';
+        this.log = opts.log;
+        this.onMessage = opts.onMessage;
+        this.onClient = opts.onClient || (() => {});
+        this.broker = null;
+        this.server = null;
+    }
+
+    async start() {
+        // aedes 1.x wird ueber eine asynchrone Fabrik erzeugt. Ein blosses `new Aedes()`
+        // liefert zwar eine Instanz, deren `handle` aber nie antwortet - der Client laeuft
+        // dann in "connack timeout".
+        this.broker = await Aedes.createBroker({
+            id: 'iobroker-faikout',
+            // Anmeldung nur pruefen, wenn in den Instanzeinstellungen etwas hinterlegt ist.
+            // Ohne Benutzer bleibt der Broker offen - im eigenen LAN der uebliche Fall, und
+            // die faikout-Module koennen ohne Anmeldung senden.
+            authenticate: (client, username, password, done) => {
+                if (!this.user) return done(null, true);
+                const u = username ? String(username) : '';
+                const p = password ? password.toString() : '';
+                if (u !== this.user || p !== this.pass) {
+                    this.log.warn(`MQTT-Anmeldung abgelehnt für "${client && client.id}" (Benutzer "${u}")`);
+                    const err = new Error('Anmeldung abgelehnt');
+                    err.returnCode = 4; // bad user name or password
+                    return done(err, false);
+                }
+                done(null, true);
+            },
+        });
+
+        return new Promise((resolve, reject) => {
+            this.broker.on('client', client => {
+                this.log.info(`MQTT-Client verbunden: ${client.id}`);
+                this.onClient(client.id, true);
+            });
+            this.broker.on('clientDisconnect', client => {
+                this.log.info(`MQTT-Client getrennt: ${client.id}`);
+                this.onClient(client.id, false);
+            });
+            this.broker.on('clientError', (client, err) => {
+                this.log.debug(`MQTT-Clientfehler ${client && client.id}: ${err.message}`);
+            });
+            this.broker.on('publish', (packet, client) => {
+                // Ohne client sind es die internen $SYS-Nachrichten des Brokers.
+                if (!client || !packet || !packet.topic) return;
+                try {
+                    this.onMessage(packet.topic, packet.payload);
+                } catch (e) {
+                    this.log.warn(`Fehler beim Verarbeiten von "${packet.topic}": ${e.message}`);
+                }
+            });
+
+            this.server = net.createServer(stream => this.broker.handle(stream));
+            this.server.on('error', err => {
+                if (err.code === 'EADDRINUSE') {
+                    this.log.error(`Port ${this.port} ist belegt - anderen Port in den Instanzeinstellungen wählen.`);
+                }
+                reject(err);
+            });
+            this.server.listen(this.port, () => {
+                this.log.info(`MQTT-Broker lauscht auf Port ${this.port}`);
+                resolve();
+            });
+        });
+    }
+
+    /** Veroeffentlicht ein Kommando an ein Geraet. */
+    publish(topic, payload) {
+        return new Promise(resolve => {
+            if (!this.broker) return resolve(false);
+            this.broker.publish(
+                { topic, payload: Buffer.from(String(payload)), qos: 0, retain: false, cmd: 'publish' },
+                err => {
+                    if (err) this.log.warn(`Senden an "${topic}" fehlgeschlagen: ${err.message}`);
+                    resolve(!err);
+                },
+            );
+        });
+    }
+
+    stop() {
+        return new Promise(resolve => {
+            const fertig = () => {
+                if (this.broker) {
+                    this.broker.close(() => resolve());
+                    this.broker = null;
+                } else {
+                    resolve();
+                }
+            };
+            if (this.server) {
+                this.server.close(fertig);
+                this.server = null;
+            } else {
+                fertig();
+            }
+        });
+    }
+}
+
+module.exports = { FaikoutBroker };

package/lib/fields.js

@@ -0,0 +1,266 @@
+'use strict';
+
+/*
+ * Feldkunde der faikout-Module.
+ *
+ * Grundlage sind die Makrolisten des Originals (ESP/main/acfields.m, accontrols.m,
+ * acextras.m) und die Funktion revk_state_extra() in Faikout.c. Wichtig: Ein Modul sendet
+ * ein Feld nur, wenn es die angeschlossene Klimaanlage tatsaechlich kann
+ * (`daikin.status_known & CONTROL_<name>`), zusaetzlich blenden die no*-Einstellungen aus.
+ * Es gibt deshalb KEINE feste Feldliste je Geraet - der Adapter legt an, was ankommt, und
+ * benutzt diese Tabelle nur, um bekannten Feldern Rolle, Einheit und Schreibbarkeit zu geben.
+ * Unbekannte Felder landen ueber ableiten() trotzdem im Objektbaum.
+ *
+ * Als Grundlage dient das `state/<Name>`-Topic, nicht `Faikout/<Name>`: Ersteres liefert
+ * Klartext (mode "cool", fan "medium") und passt damit zu den Kommandotopics; letzteres das
+ * native Format mit Kuerzeln (mode "C", fan "3") und Energie als Whoutside/Whheating.
+ */
+
+/** Betriebsarten, wie sie state/ meldet und command/<Name>/mode entgegennimmt. */
+const MODES = ['off', 'heat_cool', 'cool', 'heat', 'dry', 'fan_only'];
+
+/** Luefterstufen in der Reihenfolge der Originaloberflaeche. */
+const FAN_MODES = ['auto', 'night', 'low', 'lowMedium', 'medium', 'mediumHigh', 'high'];
+
+function liste(werte) {
+    const s = {};
+    for (const w of werte) s[w] = w;
+    return s;
+}
+
+/**
+ * Bekannte Felder. `w: true` heisst: es gibt ein Kommandotopic command/<Name>/<Feld>.
+ * `kanal` sortiert den Datenpunkt in den Objektbaum ein.
+ */
+const FELDER = {
+    // ---------------------------------------------------------------- Steuerung
+    power: { kanal: 'control', type: 'boolean', role: 'switch.power', w: true, name: { en: 'Power', de: 'Ein/Aus' } },
+    mode: {
+        kanal: 'control', type: 'string', role: 'level.mode.airconditioner', w: true,
+        states: liste(MODES), name: { en: 'Operating mode', de: 'Betriebsart' },
+    },
+    // ACHTUNG, Asymmetrie: Gelesen wird der Sollwert als `target`, geschrieben aber auf
+    // command/<Name>/temp. Belegt durch die HA-Discovery des Geraets selbst
+    // (temp_stat_tpl = {{value_json.target}}, temp_cmd_t = ~/temp) und durch die Anlage im
+    // Wohnzimmer: temp 23 bei target 18 - 23 war die Raumtemperatur, 18 der Sollwert.
+    target: {
+        kanal: 'control', type: 'number', role: 'level.temperature', unit: '°C', w: true,
+        cmd: 'temp', min: 16, max: 29,
+        name: { en: 'Target temperature', de: 'Solltemperatur' },
+    },
+    fan: {
+        kanal: 'control', type: 'string', role: 'level.mode.fan', w: true,
+        states: liste(FAN_MODES), name: { en: 'Fan speed', de: 'Lüfterstufe' },
+    },
+    // ACHTUNG: `swing` kennt sechs Werte, nicht nur off/on. Die HA-Discovery meldet zwar nur
+    // off|on, das Geraet selbst sendet aber H, V, H+V (beide Achsen) und C (Komfortbetrieb) -
+    // siehe SWING_* in Faikout.c. Am Wohnzimmer-Geraet stand live "V"; mit einer Liste aus
+    // nur off/on waere das im VIS ein unbekannter Zustand gewesen.
+    swing: {
+        kanal: 'control', type: 'string', role: 'level.mode.swing', w: true,
+        states: {
+            off: 'aus', on: 'ein', V: 'senkrecht', H: 'waagerecht',
+            'H+V': 'beide', C: 'Komfort',
+        },
+        name: { en: 'Swing', de: 'Luftverteilung' },
+    },
+    swingv: { kanal: 'control', type: 'boolean', role: 'switch', w: true, name: { en: 'Swing vertical', de: 'Lamellen senkrecht' } },
+    swingh: { kanal: 'control', type: 'boolean', role: 'switch', w: true, name: { en: 'Swing horizontal', de: 'Lamellen waagerecht' } },
+    preset: {
+        kanal: 'control', type: 'string', role: 'level.mode.preset', w: true,
+        states: liste(['home', 'eco', 'boost']), name: { en: 'Preset', de: 'Voreinstellung' },
+    },
+    // Kein `states`: Das Geraet fuehrt demand als Schieber 30..100 in 5er-Schritten
+    // (addslider(NULL, "Demand", "demand", 30, 100, "5") in Faikout.c). Eine Zustandsliste
+    // machte daraus eine Auswahlliste - und weil ihre Texte "30 %" lauteten, haengte ioBroker
+    // die Einheit ein zweites Mal an ("100 % %"). `step` sagt dasselbe ohne beide Nachteile.
+    demand: {
+        kanal: 'control', type: 'number', role: 'level', unit: '%', w: true,
+        min: 30, max: 100, step: 5,
+        name: { en: 'Demand control', de: 'Leistungsbegrenzung' },
+    },
+    econo: { kanal: 'control', type: 'boolean', role: 'switch', w: true, name: { en: 'Econo mode', de: 'Sparbetrieb' } },
+    powerful: { kanal: 'control', type: 'boolean', role: 'switch', w: true, name: { en: 'Powerful', de: 'Turbo' } },
+    comfort: { kanal: 'control', type: 'boolean', role: 'switch', w: true, name: { en: 'Comfort mode', de: 'Komfortbetrieb' } },
+    streamer: { kanal: 'control', type: 'boolean', role: 'switch', w: true, name: { en: 'Streamer', de: 'Luftreinigung' } },
+    sensor: { kanal: 'control', type: 'boolean', role: 'switch', w: true, name: { en: 'Sensor mode', de: 'Anwesenheitssensor' } },
+    led: { kanal: 'control', type: 'boolean', role: 'switch', w: true, name: { en: 'LED', de: 'Anzeige-LED' } },
+    quiet: { kanal: 'control', type: 'boolean', role: 'switch', w: true, name: { en: 'Quiet outdoor', de: 'Leiser Aussenbetrieb' } },
+    humidify: { kanal: 'control', type: 'string', role: 'level.mode.humidity', w: true, name: { en: 'Humidify', de: 'Befeuchtung' } },
+
+    // ---------------------------------------------------------------- Messwerte
+    // Zwei Raumtemperaturen, die man nicht verwechseln darf:
+    //   `temp`   = der Wert, mit dem das Modul REGELT. Reihenfolge im Quellcode
+    //              (revk_state_extra): env (externer Referenzsensor), sonst home (Sensor der
+    //              Anlage), sonst inlet (Ansaugtemperatur). Ohne externen Sensor ist er
+    //              deckungsgleich mit achome - sobald einer eingebunden ist, laufen sie
+    //              auseinander.
+    //   `achome` = IMMER der Sensor in der Klimaanlage selbst, ohne Ersatz.
+    temp: {
+        kanal: 'status', type: 'number', role: 'value.temperature', unit: '°C',
+        name: {
+            en: 'Room temperature (external sensor if present)',
+            de: 'Raumtemperatur (externer Sensor falls vorhanden)',
+        },
+    },
+    achome: {
+        kanal: 'status', type: 'number', role: 'value.temperature', unit: '°C',
+        name: {
+            en: "Room temperature (unit's own sensor)",
+            de: 'Raumtemperatur (Sensor in der Klimaanlage)',
+        },
+    },
+    inlet: { kanal: 'status', type: 'number', role: 'value.temperature', unit: '°C', name: { en: 'Inlet temperature', de: 'Ansaugtemperatur' } },
+    outside: { kanal: 'status', type: 'number', role: 'value.temperature', unit: '°C', name: { en: 'Outside temperature', de: 'Aussentemperatur' } },
+    liquid: { kanal: 'status', type: 'number', role: 'value.temperature', unit: '°C', name: { en: 'Refrigerant temperature', de: 'Kältemitteltemperatur' } },
+    env: { kanal: 'status', type: 'number', role: 'value.temperature', unit: '°C', name: { en: 'External reference temperature', de: 'Externe Referenztemperatur' } },
+    hum: { kanal: 'status', type: 'number', role: 'value.humidity', unit: '%', name: { en: 'Indoor humidity', de: 'Luftfeuchte innen' } },
+    // Der Sollwert, wie ihn die Anlage selbst fuehrt. Deckt sich normalerweise mit `target`;
+    // im Faikout-Automatikbetrieb weicht er ab, weil dann ein Regelziel vorgegeben wird.
+    actarget: { kanal: 'status', type: 'number', role: 'value.temperature', unit: '°C', name: { en: 'Unit setpoint', de: 'Sollwert der Anlage' } },
+    comp: { kanal: 'status', type: 'number', role: 'value', unit: 'rpm', name: { en: 'Compressor speed', de: 'Verdichterdrehzahl' } },
+    fanfreq: { kanal: 'status', type: 'number', role: 'value', unit: 'rpm', name: { en: 'Fan speed', de: 'Lüfterdrehzahl' } },
+    fanrpm: { kanal: 'status', type: 'number', role: 'value', unit: 'rpm', name: { en: 'Fan speed', de: 'Lüfterdrehzahl' } },
+    anglev: { kanal: 'status', type: 'number', role: 'value', unit: '°', name: { en: 'Louvre angle', de: 'Lamellenwinkel' } },
+    consumption: { kanal: 'status', type: 'number', role: 'value.power', unit: 'W', name: { en: 'Power consumption', de: 'Momentanleistung' } },
+    // Das Geraet zaehlt in Wh; der Adapter rechnet in kWh um (siehe umrechnen()).
+    energy: { kanal: 'status', type: 'number', role: 'value.energy', unit: 'kWh', wh: true, name: { en: 'Lifetime energy', de: 'Energie gesamt' } },
+    energyheat: { kanal: 'status', type: 'number', role: 'value.energy', unit: 'kWh', wh: true, name: { en: 'Lifetime heating energy', de: 'Energie Heizen' } },
+    energycool: { kanal: 'status', type: 'number', role: 'value.energy', unit: 'kWh', wh: true, name: { en: 'Lifetime cooling energy', de: 'Energie Kühlen' } },
+    heat: { kanal: 'status', type: 'boolean', role: 'indicator', name: { en: 'Heating', de: 'Heizt' } },
+    slave: { kanal: 'status', type: 'boolean', role: 'indicator', name: { en: 'Controlled by other unit', de: 'Von anderer Einheit gesteuert' } },
+    antifreeze: { kanal: 'status', type: 'boolean', role: 'indicator', name: { en: 'Anti-freeze active', de: 'Frostschutz aktiv' } },
+    flap: { kanal: 'status', type: 'boolean', role: 'indicator', name: { en: 'Flap', de: 'Klappe' } },
+    control: { kanal: 'status', type: 'boolean', role: 'indicator', name: { en: 'Automatic control', de: 'Automatiksteuerung' } },
+    model: { kanal: 'status', type: 'string', role: 'info.name', name: { en: 'Model', de: 'Modell' } },
+    protocol: { kanal: 'status', type: 'string', role: 'info', name: { en: 'Protocol', de: 'Protokoll' } },
+
+    // ---------------------------------------------------------------- Faikout-Automatik
+    // Eine eigene Schaltautomatik IM MODUL, unabhaengig von der Klimaanlage. `autoe` ist der
+    // Hauptschalter dafuer; er erlaubt zweierlei: Ein-/Ausschalten zu festen Uhrzeiten
+    // (auto1/auto0) und Ein-/Ausschalten nach Temperatur (autop mit autot ± autor).
+    //
+    // ACHTUNG, Bedeutungswechsel: Sind `autoe` UND `autor` gesetzt (autor > 0), regelt das
+    // Modul selbst. Dann meldet `target` nicht mehr den Sollwert der Anlage, sondern das
+    // Regelziel des Moduls (autot) - und ein Schreibbefehl auf command/<Name>/temp setzt
+    // ebenfalls autot statt des Anlagen-Sollwerts (siehe Faikout.c, Zeilen 1679 und 3197).
+    // Solange autor = 0 ist, verhaelt sich alles wie gewohnt.
+    autoe: {
+        kanal: 'status', type: 'boolean', role: 'switch', w: true,
+        name: {
+            en: 'Faikout automation (timed and temperature switching)',
+            de: 'Faikout-Automatik (Zeit- und Temperaturschaltung)',
+        },
+    },
+    autop: {
+        kanal: 'status', type: 'boolean', role: 'indicator',
+        name: {
+            en: 'Automation: switch by temperature',
+            de: 'Automatik: Schalten nach Temperatur',
+        },
+    },
+    autor: {
+        kanal: 'status', type: 'number', role: 'value.temperature', unit: '°C',
+        name: {
+            en: 'Automation: tolerance around target (0 = module does not control)',
+            de: 'Automatik: Toleranz um das Ziel (0 = Modul regelt nicht)',
+        },
+    },
+    autot: {
+        kanal: 'status', type: 'number', role: 'value.temperature', unit: '°C',
+        name: { en: 'Automation: target temperature', de: 'Automatik: Zieltemperatur' },
+    },
+    auto0: {
+        kanal: 'status', type: 'string', role: 'text',
+        name: { en: 'Automation: switch-off time (HHMM)', de: 'Automatik: Ausschaltzeit (HHMM)' },
+    },
+    auto1: {
+        kanal: 'status', type: 'string', role: 'text',
+        name: { en: 'Automation: switch-on time (HHMM)', de: 'Automatik: Einschaltzeit (HHMM)' },
+    },
+
+    // ---------------------------------------------------------------- Geraetediagnose
+    online: { kanal: 'info', type: 'boolean', role: 'indicator.reachable', name: { en: 'Air conditioner online', de: 'Klimaanlage erreichbar' } },
+    ipv4: { kanal: 'info', type: 'string', role: 'info.ip', name: { en: 'IP address', de: 'IP-Adresse' } },
+    rssi: { kanal: 'info', type: 'number', role: 'value.rssi', unit: 'dBm', name: { en: 'WiFi signal', de: 'WLAN-Signal' } },
+    ssid: { kanal: 'info', type: 'string', role: 'info', name: { en: 'WiFi network', de: 'WLAN-Netz' } },
+    bssid: { kanal: 'info', type: 'string', role: 'info', name: { en: 'WiFi BSSID', de: 'WLAN-BSSID' } },
+    chan: { kanal: 'info', type: 'number', role: 'value', name: { en: 'WiFi channel', de: 'WLAN-Kanal' } },
+    uptime: { kanal: 'info', type: 'number', role: 'value', unit: 's', name: { en: 'Uptime', de: 'Laufzeit' } },
+    'mqtt-up': { kanal: 'info', type: 'number', role: 'value', unit: 's', id: 'mqttUp', name: { en: 'MQTT uptime', de: 'MQTT-Laufzeit' } },
+    version: { kanal: 'info', type: 'string', role: 'info.firmware', name: { en: 'Firmware version', de: 'Firmware-Version' } },
+    build: { kanal: 'info', type: 'string', role: 'info', name: { en: 'Firmware build', de: 'Firmware-Stand' } },
+    'build-suffix': { kanal: 'info', type: 'string', role: 'info', id: 'buildSuffix', name: { en: 'Hardware variant', de: 'Hardware-Variante' } },
+    app: { kanal: 'info', type: 'string', role: 'info', name: { en: 'Application', de: 'Anwendung' } },
+    id: { kanal: 'info', type: 'string', role: 'info.mac', name: { en: 'Device ID', de: 'Geräte-ID' } },
+    mem: { kanal: 'info', type: 'number', role: 'value', unit: 'B', name: { en: 'Free memory', de: 'Freier Speicher' } },
+    spi: { kanal: 'info', type: 'number', role: 'value', unit: 'B', name: { en: 'Free SPI RAM', de: 'Freier SPI-Speicher' } },
+    flash: { kanal: 'info', type: 'number', role: 'value', unit: 'B', name: { en: 'Flash size', de: 'Flash-Größe' } },
+    rst: { kanal: 'info', type: 'number', role: 'value', name: { en: 'Reset reason', de: 'Neustartgrund' } },
+    up: { kanal: 'info', type: 'boolean', role: 'indicator.reachable', name: { en: 'Module online', de: 'Modul erreichbar' } },
+    ts: { kanal: 'info', type: 'string', role: 'date', name: { en: 'Last message', de: 'Letzte Meldung' } },
+};
+
+/** Felder, die der Adapter nie als Datenpunkt anlegt (Struktur statt Wert). */
+const UEBERSPRINGEN = new Set(['ble']);
+
+/**
+ * Beschreibung eines Feldes - bekannt aus [FELDER], sonst aus dem Wert abgeleitet.
+ * Damit landet auch ein Feld im Baum, das eine kuenftige Firmware neu einfuehrt.
+ */
+function beschreibe(feld, wert) {
+    const bekannt = FELDER[feld];
+    if (bekannt) return bekannt;
+    const type = typeof wert === 'boolean' ? 'boolean' : typeof wert === 'number' ? 'number' : 'string';
+    return {
+        kanal: 'status',
+        type,
+        role: type === 'boolean' ? 'indicator' : type === 'number' ? 'value' : 'text',
+        name: { en: feld, de: feld },
+        unbekannt: true,
+    };
+}
+
+/** Wh -> kWh, wo die Beschreibung es verlangt. Alles andere unveraendert. */
+function umrechnen(def, wert) {
+    if (def && def.wh && typeof wert === 'number') return Math.round(wert / 10) / 100;
+    return wert;
+}
+
+/**
+ * Platzhalterwert der Luftfeuchte.
+ *
+ * Anlagen ohne Feuchtesensor melden dauerhaft `hum: 50` - das ist kein Messwert, sondern der
+ * Ersatzwert. Ein blindes Uebernehmen taeuscht eine Messung vor, die es nicht gibt (am
+ * Wohnzimmer-Geraet des Nutzers genau so aufgetreten).
+ */
+const FEUCHTE_PLATZHALTER = 50;
+
+/**
+ * Entscheidet, ob ein Feuchtewert echt ist.
+ *
+ * Solange nur 50 kommt, gilt er als Platzhalter und wird verworfen. Sobald das Geraet EINMAL
+ * etwas anderes gemeldet hat, ist ein Sensor da - ab dann zaehlt auch die 50 als gueltiger
+ * Messwert. Der Merker muss deshalb dauerhaft am Geraet haengen, nicht nur zur Laufzeit.
+ *
+ * @param {number} wert       gemeldete Luftfeuchte
+ * @param {boolean} bekannt   hat dieses Geraet frueher schon einen anderen Wert als 50 gemeldet?
+ * @returns {{nehmen: boolean, echtAbJetzt: boolean}}
+ */
+function feuchteBewerten(wert, bekannt) {
+    if (bekannt) return { nehmen: true, echtAbJetzt: true };
+    const echt = typeof wert === 'number' && wert !== FEUCHTE_PLATZHALTER;
+    return { nehmen: echt, echtAbJetzt: echt };
+}
+
+/** Objekt-ID eines Feldes; Bindestriche taugen nicht als ioBroker-ID-Bestandteil. */
+function objektId(feld) {
+    const def = FELDER[feld];
+    if (def && def.id) return def.id;
+    return feld.replace(/-/g, '_');
+}
+
+module.exports = {
+    FELDER, MODES, FAN_MODES, UEBERSPRINGEN, FEUCHTE_PLATZHALTER,
+    beschreibe, umrechnen, objektId, feuchteBewerten,
+};