hm2mqtt 2.5.0 → 3.1.0

package/index.js

@@ -1,1084 +1,726 @@
 #!/usr/bin/env node
 
-/* eslint-disable prefer-destructuring */
-
-const fs = require('fs');
-const path = require('path');
-const pjson = require('persist-json')('hm2mqtt');
-const async = require('async');
-const log = require('yalm');
-const request = require('request');
-const Mqtt = require('mqtt');
-const xmlrpc = require('homematic-xmlrpc');
-const binrpc = require('binrpc');
-const discover = require('./discover.js');
-const pkg = require('./package.json');
-const config = require('./config.js');
-
-log.setLevel(config.verbosity);
-log.info(pkg.name + ' ' + pkg.version + ' starting');
-
-const rpcClient = {};
-const rpcServer = {};
-const ifaceConnected = {};
-let ifaceAllConnected = false;
-const values = {};
-const changes = {};
-const working = {};
-const workingTimeout = {};
-let names = {};
-const addresses = {};
-function reverseNames() {
-    Object.keys(names).forEach(address => {
-        addresses[names[address]] = address;
-    });
+/**
+ * hm2mqtt — Homematic CCU to MQTT. A drop-in replacement for the node-red-contrib-ccu
+ * `ccu-mqtt` flow on mqtt-interfaces-core; see ROADMAP.md for the decisions (H-n).
+ */
+
+import dns from 'node:dns/promises';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {createAdapter} from 'mqtt-interfaces-core';
+import {Rega} from 'homematic-rega';
+import config from './config.js';
+import pkg from './package.json' with {type: 'json'};
+import {handle as handleInstall} from './lib/install.js';
+import {parseInterfaces, probeInterfaces, interfaceConfig} from './lib/interfaces.js';
+import {RpcServers, RpcConnection} from './lib/rpc.js';
+import {Metadata} from './lib/metadata.js';
+import {ValueStore, hmBlock, isEvent} from './lib/values.js';
+import {RegaSync} from './lib/rega.js';
+import {castValue, isWriteable} from './lib/cast.js';
+import {sanitizeName, resolveSet, resolveParamset, plainValue, compileTemplate, ItemIndex} from './lib/topics.js';
+
+handleInstall(config);
+
+const COUNTER_INTERVAL_MS = 30000;
+const VALUES_SAVE_MS = 300000;
+const SET_THROTTLE_MS = 500;
+const DEVICES_WAIT_MS = 10000;
+const STOP_TIMEOUT_MS = 1500;
+const RESOLVE_RETRY_MS = 10000;
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+/** the configured CCU address (the `ccu` field of every payload); connections use the resolved ip */
+const host = config.ccuAddress;
+let ccuIp = host;
+
+/** Resolves the CCU once (this host's resolver proved flaky under parallel lookups); retries forever. */
+async function resolveCcu() {
+    for (;;) {
+        try {
+            const {address} = await dns.lookup(host, {family: 4});
+            if (address !== host) {
+                log.info('ccu', host, 'resolves to', address);
+            }
+            return address;
+        } catch (err) {
+            log.warn('cannot resolve', host, '(' + err.message + ') - retrying in', RESOLVE_RETRY_MS / 1000, 's');
+            await new Promise((resolve) => setTimeout(resolve, RESOLVE_RETRY_MS));
+        }
+    }
 }
 
-const devices = {};
-log.debug('loading', 'paramsetDescriptions_' + fileName());
-const paramsetDescriptions = pjson.load('paramsetDescriptions_' + fileName()) || {};
-const getParamsetTimeout = {};
-const paramsetQueue = {};
-const lastEvent = {};
+function firstIp() {
+    for (const list of Object.values(os.networkInterfaces())) {
+        for (const addr of list) {
+            if (addr.family === 'IPv4' && !addr.internal) {
+                return addr.address;
+            }
+        }
+    }
+    return '0.0.0.0';
+}
 
-const programs = {};
-const programNames = {};
-const variables = {};
-const variableNames = {};
-const variableType = {
-    2: 'BOOL',
-    4: 'FLOAT',
-    16: 'INTEGER',
-    20: 'STRING'
-};
+/*
+ * state
+ */
 
-let mqttConnected;
+// the option's default is $STATE_DIRECTORY only, so --install does not freeze this fallback into the env file
+config.stateDir = config.stateDir || path.join(os.homedir(), '.hm2mqtt');
+fs.mkdirSync(config.stateDir, {recursive: true});
 
-log.info('mqtt trying to connect', config.mqttUrl);
+let nameFile = {};
+if (config.nameFile) {
+    nameFile = JSON.parse(fs.readFileSync(path.resolve(config.nameFile), 'utf8'));
+}
 
-const mqtt = Mqtt.connect(config.mqttUrl, {
-    clientId: config.name + '_' + Math.random().toString(16).substr(2, 8),
-    will: {topic: config.name + '/connected', payload: '0', retain: (config.mqttRetain)},
-    rejectUnauthorized: !config.insecure
+/*
+ * payload format (node-red-contrib-ccu's mqsh-extended / mqsh-basic / plain)
+ */
+let payloadFormat = config.payload;
+if (config.hmPayload === false && payloadFormat === 'mqsh-extended') {
+    payloadFormat = 'mqsh-basic';
+}
+if (!config.jsonPayloads) {
+    payloadFormat = 'plain';
+}
+config.jsonPayloads = payloadFormat !== 'plain';
+const withHm = payloadFormat === 'mqsh-extended';
+/** the value as published: plain format uses node-red's 0/1 for booleans */
+const outValue = (value) => (payloadFormat === 'plain' ? plainValue(value) : value);
+
+const adapter = createAdapter({
+    pkg,
+    config,
+    deviceLabel: 'ccu',
+    info: () => ({
+        ccu: host,
+        interfaces: enabled,
+        devices: metadata.count(),
+        rega: Boolean(regaSync),
+        payload: payloadFormat,
+    }),
+    onSet: handleSet,
+    subscriptions: {
+        'paramset/#': handleParamset,
+        ...(config.rpcTopics ? {'rpc/+/+/+': handleRpc} : {}),
+    },
+    onShutdown: shutdown,
 });
+const {log, pubStatus} = adapter;
+
+const metadata = new Metadata({stateDir: config.stateDir, seedFile: path.join(here, 'paramsets.json'), log});
+metadata.load();
+
+let regaSync = null;
+if (config.rega) {
+    const rega = new Rega({
+        host: ccuIp,
+        tls: config.ccuTls,
+        insecure: config.ccuInsecure,
+        username: config.ccuUsername,
+        password: config.ccuPassword,
+        timeZone: config.ccuTimezone,
+    });
+    regaSync = new RegaSync({rega, host, metadata, stateDir: config.stateDir, nameFile, log});
+    regaSync.load();
+}
 
-mqtt.on('connect', () => {
-    mqttConnected = true;
-
-    log.info('mqtt connected', config.mqttUrl);
-    mqtt.publish(config.name + '/connected', ifaceAllConnected ? '2' : '1', {retain: (config.mqttRetain)});
-
-    log.info('mqtt subscribe', config.name + '/set/#');
-    mqtt.subscribe(config.name + '/set/#');
-
-    log.info('mqtt subscribe', config.name + '/param/#');
-    mqtt.subscribe(config.name + '/param/#');
+const channelName = (address) => (regaSync ? regaSync.channelName(address) : nameFile[address]);
 
-    log.info('mqtt subscribe', config.name + '/paramset/#');
-    mqtt.subscribe(config.name + '/paramset/#');
+const values = new ValueStore({
+    host,
+    context: {
+        device: (iface, address) => metadata.device(iface, address),
+        valueDescription: (iface, address, datapoint) => metadata.valueDescription(iface, address, datapoint),
+        channelName,
+        rooms: (address) => (regaSync ? regaSync.rooms(address) : undefined),
+        functions: (address) => (regaSync ? regaSync.functions(address) : undefined),
+    },
+    stateDir: config.stateDir,
+    log,
+});
+values.load();
+
+const renderItem = compileTemplate(config.itemTemplate);
+const renderSysvarItem = compileTemplate(config.sysvarItemTemplate);
+const renderProgramItem = compileTemplate(config.programItemTemplate);
+const itemIndex = new ItemIndex();
+let indexTimer = null;
+
+let enabled = [];
+const connections = {};
+let servers = null;
+let regaOk = false;
+const timers = [];
+const warnedNames = new Set();
+const publishedCounters = {};
+let fetchChain = Promise.resolve();
+
+/*
+ * publishing
+ */
+
+function itemOf(name) {
+    const {name: item, changed} = sanitizeName(name);
+    if (changed && !warnedNames.has(name)) {
+        warnedNames.add(name);
+        log.warn('name', JSON.stringify(name), 'is not usable as topic, publishing as', JSON.stringify(item));
+    }
+    return item;
+}
 
-    log.info('mqtt subscribe', config.name + '/rega/#');
-    mqtt.subscribe(config.name + '/rega/#');
+function rendered(render, fields, label) {
+    const {name: item, changed} = render(fields);
+    if (changed && !warnedNames.has(label)) {
+        warnedNames.add(label);
+        log.warn('item of', label, 'rendered with replacements as', JSON.stringify(item));
+    }
+    return item;
+}
 
-    log.info('mqtt subscribe', config.name + '/rpc/#');
-    mqtt.subscribe(config.name + '/rpc/#');
+/**
+ * Rebuilds the reverse map item → target for set topics: every VALUES parameter of every known
+ * channel rendered with the item template (plus its address form), variables and programs.
+ */
+function rebuildIndex() {
+    indexTimer = null;
+    itemIndex.clear('datapoint');
+    itemIndex.collisions.clear();
+    for (const iface of Object.keys(metadata.devices)) {
+        for (const [address, device] of Object.entries(metadata.devices[iface])) {
+            if (!device.PARENT) {
+                continue;
+            }
+            const description = metadata.description(iface, address, 'VALUES');
+            if (!description) {
+                continue;
+            }
+            for (const datapoint of Object.keys(description)) {
+                const target = {kind: 'datapoint', address, datapoint};
+                itemIndex.add(renderItem(values.fields(iface, address, datapoint)).name, target);
+                itemIndex.add(`${address}/${datapoint}`, target);
+            }
+        }
+    }
+    if (itemIndex.collisions.size > 0) {
+        const list = [...itemIndex.collisions.keys()];
+        log.warn(
+            'items shared by several channels (the first one wins on set):',
+            list.slice(0, 10).join(', '),
+            list.length > 10 ? `… ${list.length - 10} more` : '',
+        );
+    }
+    log.debug('item index rebuilt:', itemIndex.size, 'items');
+}
 
-    log.info('mqtt subscribe', config.name + '/command/#');
-    mqtt.subscribe(config.name + '/command/#');
-});
+function scheduleIndex() {
+    if (indexTimer) {
+        return;
+    }
+    indexTimer = setTimeout(rebuildIndex, 2000);
+    indexTimer.unref();
+}
 
-mqtt.on('close', () => {
-    if (mqttConnected) {
-        mqttConnected = false;
-        log.error('mqtt closed ' + config.mqttUrl);
+function publishPlain(item, value, retain) {
+    if (config.plainTree) {
+        adapter.publish(adapter.topic(config.plainTree, item), plainValue(value), {retain});
     }
-});
+}
 
-mqtt.on('error', err => {
-    log.error('mqtt', err);
-});
+function publishMessage(message, {retain = true} = {}) {
+    const item = rendered(renderItem, message, message.datapointName);
+    const extra = withHm ? {hm: hmBlock(message)} : undefined;
+    pubStatus(item, outValue(message.value), {retain, extra, ts: message.ts, lc: message.lc});
+    publishPlain(item, message.value, retain);
+}
 
-mqtt.on('close', () => {
-    log.warn('mqtt close');
-});
+function publishRega(message) {
+    const render = message.type === 'PROGRAM' ? renderProgramItem : renderSysvarItem;
+    const item = rendered(render, message, `${message.type} ${message.name}`);
+    itemIndex.add(item, {kind: message.type === 'PROGRAM' ? 'program' : 'sysvar', name: message.name});
+    const extra = withHm ? {hm: hmBlock(message)} : undefined;
+    pubStatus(item, outValue(message.value), {retain: true, extra, ts: message.ts, lc: message.lc});
+    publishPlain(item, message.value, true);
+}
 
-mqtt.on('offline', () => {
-    log.warn('mqtt offline');
-});
+function publishItem(item, value, {retain = true} = {}) {
+    pubStatus(item, outValue(value), {retain});
+    publishPlain(item, value, retain);
+}
 
-mqtt.on('reconnect', () => {
-    log.info('mqtt reconnect');
-});
+function updateConnected() {
+    const all = enabled.every((iface) => connections[iface] && connections[iface].connected) && (!regaSync || regaOk);
+    adapter.setDeviceConnected(all);
+}
 
-function mqttPublish(topic, payload, options) {
-    if (typeof payload === 'object') {
-        payload = JSON.stringify(payload);
-    } else if (payload) {
-        payload = String(payload);
-    } else {
-        payload = '';
+function publishCounters() {
+    if (!config.publishCounters) {
+        return;
     }
-    mqtt.publish(topic, payload, options, err => {
-        if (err) {
-            log.error('mqtt publish', err);
-        } else {
-            log.debug('mqtt >', topic, payload);
+    for (const iface of enabled) {
+        const conn = connections[iface];
+        for (const dir of ['rx', 'tx']) {
+            const key = `${iface}/${dir}`;
+            const value = conn ? conn.counters[dir] : 0;
+            if (publishedCounters[key] !== value) {
+                publishedCounters[key] = value;
+                publishItem(`counter/${key}`, value);
+            }
         }
-    });
+    }
 }
 
-mqtt.on('message', (topic, payload) => {
-    payload = payload.toString();
-    log.debug('mqtt <', topic, payload);
-    const parts = topic.split('/');
-    if (parts.length >= 4 && parts[1] === 'set') {
-        // Topic <name>/set/<channel>/<datapoint>
-        const channel = parts.slice(2, parts.length - 1).join('/');
-        const datapoint = parts[parts.length - 1];
-        rpcSet(channel, 'VALUES', datapoint, payload);
-    } else if (parts.length >= 5 && parts[1] === 'param') {
-        // Topic <name>/param/<channel>/<paramset>/<datapoint>
-        const channel = parts.slice(2, parts.length - 2).join('/');
-        const paramset = parts[parts.length - 2];
-        const datapoint = parts[parts.length - 1];
-        rpcPutParam(channel, paramset, datapoint, payload);
-    } else if (parts.length >= 4 && parts[1] === 'paramset') {
-        // Topic <name>/paramset/<channel>/<paramset>
-        const channel = parts.slice(2, parts.length - 1).join('/');
-        const paramset = parts[parts.length - 1];
-        rpcPutParamset(channel, paramset, payload);
-    } else if (parts.length === 5 && parts[1] === 'rpc') {
-        // Topic <name>/rpc/<interface>/<command>/<call_id> - Answer: <name>/response/<call_id>
-        const [, , iface, command, callid] = parts;
-        rpc(iface, command, callid, payload);
-    } else if (parts.length >= 3 && parts[1] === 'rega') {
-        // Topic <name>/rega/<variableOrProgramName>
-        const name = parts.slice(2, parts.length);
-        if (variables[name]) {
-            setVar(variables[name], payload);
-        } else if (programs[name]) {
-            setProgram(programs[name], payload);
-        } else {
-            log.error('unknown variable/program', name);
-        }
-    } else if (parts[1] === 'command') {
-        switch (parts[2]) {
-            case 'regasync':
-                getRegaDeviceNames();
-                break;
-            default:
-                log.error('mqtt < unknown command', parts[2]);
+async function pollDutyCycle() {
+    for (const iface of enabled) {
+        const conn = connections[iface];
+        if (!conn || !conn.connected || !interfaceConfig(iface, config).dutyCycle) {
+            continue;
         }
-    } else {
-        log.error('mqtt <', topic, payload);
-    }
-});
-
-function setVar(variable, payload) {
-    let val;
-    if (payload.indexOf('{') === 0) {
         try {
-            val = JSON.parse(payload).val;
-        } catch (err) {
-            val = payload;
-        }
-    } else {
-        val = payload;
-    }
-
-    switch (variable.type) {
-        case 'BOOL':
-            // OMG this is so ugly...
-            if (val === 'false') {
-                val = false;
-            } else if (!isNaN(val)) { // Make sure that the string "0" gets casted to boolean false
-                val = Number(val);
+            const list = await conn.methodCall('listBidcosInterfaces', []);
+            if (!Array.isArray(list)) {
+                continue;
             }
-            val = Boolean(val);
-            break;
-        case 'FLOAT':
-            val = parseFloat(val) || 0;
-            break;
-        case 'INTEGER':
-            if (typeof val === 'string') {
-                if (variable.enum && (variable.enum.indexOf(val) !== -1)) {
-                    val = variable.enum.indexOf(val);
+            for (const entry of list) {
+                if (!entry || typeof entry.ADDRESS !== 'string') {
+                    continue;
+                }
+                const item = itemOf(entry.ADDRESS);
+                if (typeof entry.DUTY_CYCLE === 'number') {
+                    publishItem(`${item}/DUTY_CYCLE`, entry.DUTY_CYCLE);
+                }
+                if (typeof entry.CARRIER_SENSE_LEVEL === 'number') {
+                    publishItem(`${item}/CARRIER_SENSE_LEVEL`, entry.CARRIER_SENSE_LEVEL);
+                }
+                if (typeof entry.CONNECTED === 'boolean') {
+                    publishItem(`${item}/CONNECTED`, entry.CONNECTED);
                 }
             }
-            val = parseInt(val, 10) || 0;
-            break;
-        case 'STRING':
-            val = '"' + String(val) + '"';
-            break;
-        default:
-    }
-    const script = 'dom.GetObject(' + variable.id + ').State(' + val + ');';
-    log.debug('rega >', script);
-    rega(script, err => {
-        if (err) {
-            log.error(err);
-        }
-    });
-}
-
-function setProgram(program, payload) {
-    log.debug(program, payload);
-    let val;
-    let script;
-    if (payload.indexOf('{') === 0) {
-        try {
-            val = JSON.parse(payload).val;
         } catch (err) {
-            val = payload;
+            log.debug('rpc', iface, 'listBidcosInterfaces failed:', err.message);
         }
-    } else {
-        val = payload;
     }
-    if (val === 'start') {
-        script = 'dom.GetObject(' + program.id + ').ProgramExecute();';
-    } else {
-        if (val === 'false') {
-            val = false;
+}
+
+/*
+ * incoming: set / paramset / rpc
+ */
+
+const lookup = {
+    channelAddress: (name, devices = false) => {
+        if (regaSync) {
+            return regaSync.channelAddress(name, devices);
         }
-        val = Boolean(val);
-        script = 'dom.GetObject(' + program.id + ').Active(' + val + ');';
-    }
-    log.debug('rega >', script);
-    rega(script, err => {
-        if (err) {
-            log.error(err);
+        const address = Object.entries(nameFile).find(([, n]) => n === name)?.[0] || name;
+        if (!metadata.findIface(address)) {
+            return undefined;
         }
-    });
-}
+        return devices || address.includes(':') ? address : undefined;
+    },
+    isSysvar: (name) => Boolean(regaSync && regaSync.hasVariable(name)),
+    isProgram: (name) => Boolean(regaSync && regaSync.hasProgram(name)),
+};
 
-function rpc(iface, command, callid, payload) {
-    if (rpcClient[iface]) {
-        let params;
-        if (payload.indexOf('[') === 0) {
-            try {
-                params = JSON.parse(payload);
-            } catch (err) {
-                log.error(err);
-            }
-        } else if (params) {
-            params = [params];
-        } else {
-            params = [];
+const setTimers = new Map();
+
+/** node-red-contrib-ccu's setValue throttle: one call per datapoint per 500 ms, the last value wins. */
+function throttled(id, fn) {
+    const pending = setTimers.get(id);
+    if (pending) {
+        if (pending.deferred) {
+            pending.deferred.resolve();
         }
-        log.debug('rpc', iface, '>', command, params);
-        rpcClient[iface].methodCall(command, params, (err, res) => {
-            if (err) {
-                log.error(err);
-            } else {
-                const topic = config.name + '/response/' + callid;
-                const payload = JSON.stringify(res);
-                mqttPublish(topic, payload);
-            }
+        return new Promise((resolve, reject) => {
+            pending.deferred = {fn, resolve, reject};
         });
     }
+    const entry = {deferred: null};
+    entry.timer = setTimeout(() => {
+        setTimers.delete(id);
+        if (entry.deferred) {
+            const {fn: deferredFn, resolve, reject} = entry.deferred;
+            log.debug('deferred set', id);
+            deferredFn().then(resolve, reject);
+        }
+    }, SET_THROTTLE_MS);
+    setTimers.set(id, entry);
+    return fn();
 }
 
-function rpcType(payload, paramset) {
-    let val;
-    if (payload.indexOf('{') === 0) {
-        try {
-            val = JSON.parse(payload).val;
-        } catch (err) {
-            val = payload;
-        }
-    } else {
-        val = payload;
+function connectionOf(address) {
+    const iface = metadata.findIface(address);
+    if (!iface) {
+        throw new Error(`unknown device ${address}`);
     }
-
-    switch (paramset && paramset.TYPE) {
-        case 'BOOL':
-        // eslint-disable-line no-fallthrough
-        case 'ACTION':
-            // OMG this is so ugly...
-            if (val === 'false') {
-                val = false;
-            } else if (!isNaN(val)) { // Make sure that the string "0" gets casted to boolean false
-                val = Number(val);
-            }
-            val = Boolean(val);
-            break;
-        case 'FLOAT':
-            val = parseFloat(val);
-            if (val < paramset.MIN) {
-                val = paramset.MIN;
-            } else if (val > paramset.MAX) {
-                val = paramset.MAX;
-            }
-            val = {explicitDouble: val};
-            break;
-        case 'ENUM':
-            if (typeof val === 'string') {
-                if (paramset.ENUM && (paramset.ENUM.indexOf(val) !== -1)) {
-                    val = paramset.ENUM.indexOf(val);
-                }
-            }
-        // eslint-disable-line no-fallthrough
-        case 'INTEGER':
-            val = parseInt(val, 10);
-            if (val < paramset.MIN) {
-                val = paramset.MIN;
-            } else if (val > paramset.MAX) {
-                val = paramset.MAX;
-            }
-            break;
-        case 'STRING':
-            val = String(val);
-            break;
-        default:
+    const conn = connections[iface];
+    if (!conn) {
+        throw new Error(`interface ${iface} of ${address} is not enabled`);
     }
-
-    return val;
+    return {iface, conn};
 }
 
-function findIface(address) {
-    let iface = null;
-    Object.keys(devices).forEach(i => {
-        if (devices[i] && devices[i][address]) {
-            iface = i;
-        }
-    });
-    return iface;
+async function setValue(address, datapoint, value) {
+    const {iface, conn} = connectionOf(address);
+    const description = metadata.valueDescription(iface, address, datapoint);
+    if (!isWriteable(description)) {
+        throw new Error(`${address} ${datapoint} is not writeable`);
+    }
+    if (!description) {
+        log.debug('no paramset description for', iface, address, datapoint);
+    }
+    const cast = castValue(value, description);
+    return throttled(`${iface}.${address}.${datapoint}`, () => conn.methodCall('setValue', [address, datapoint, cast]));
 }
 
-function rpcPutParam(name, paramsetKey, datapoint, payload) {
-    const address = addresses[name] || name;
-    const iface = findIface(address);
-    if (!iface) {
-        log.error('unknown device', address);
+async function handleSet(parts, value, topic) {
+    if (value === undefined) {
+        log.warn('mqtt ignoring empty payload on', topic);
         return;
     }
-    const psName = paramsetName(devices[iface][address]);
-    let ps = paramsetDescriptions[psName];
-    ps = ps && ps[paramsetKey] && ps[paramsetKey][datapoint];
-    if (!ps) {
-        log.warn('unknown paramset', paramsetName(devices[iface][address]) + '.' + paramsetKey + '.' + datapoint);
+    // exact item first (rendered template, address form, variables, programs), then the positional form
+    const target = itemIndex.get(parts.join('/')) || resolveSet(parts, lookup);
+    if (!target) {
+        throw new Error('unknown channel, variable or program');
     }
-
-    if (ps && !(ps.OPERATIONS & 2)) {
-        log.error(iface, address, paramsetKey, datapoint, 'not writeable');
-        return;
+    switch (target.kind) {
+        case 'datapoint':
+            return setValue(target.address, target.datapoint, value);
+        case 'sysvar':
+            return regaSync.setVariable(target.name, value);
+        case 'program':
+            return typeof value === 'boolean'
+                ? regaSync.programActive(target.name, value)
+                : regaSync.programExecute(target.name);
+        case 'command':
+            if (target.command === 'sync' && regaSync) {
+                return regaSync.syncNames();
+            }
+            throw new Error('unknown command ' + target.command);
+        default:
+            throw new Error('unhandled target ' + target.kind);
     }
+}
 
-    const val = rpcType(payload, ps);
-
+async function handleParamset(parts, value) {
+    const whole = value && typeof value === 'object' && !Array.isArray(value);
+    const target = resolveParamset(parts, lookup, {single: !whole});
+    if (!target) {
+        throw new Error(
+            whole
+                ? 'unknown channel/device or paramset'
+                : 'unknown channel/device, paramset or parameter (object payloads set a whole paramset)',
+        );
+    }
+    const {iface, conn} = connectionOf(target.address);
+    const description =
+        (await metadata.fetchDescription(iface, target.address, target.paramset, (m, p) => conn.methodCall(m, p))) ||
+        {};
     const paramset = {};
-    paramset[datapoint] = val;
-    log.debug('rpc', iface, '> putParamset', [address, paramsetKey, paramset]);
-
-    rpcClient[iface].methodCall('putParamset', [address, paramsetKey, paramset], err => {
-        if (err) {
-            log.error(err);
+    const entries = whole ? Object.entries(value) : [[target.param, value]];
+    for (const [param, v] of entries) {
+        const d = description[param];
+        if (!isWriteable(d)) {
+            throw new Error(`${target.address} ${target.paramset} ${param} is not writeable`);
         }
-    });
+        if (!d) {
+            log.debug('no paramset description for', iface, target.address, target.paramset, param);
+        }
+        paramset[param] = castValue(v, d);
+    }
+    await conn.methodCall('putParamset', [target.address, target.paramset, paramset]);
 }
 
-function rpcPutParamset(name, paramsetKey, payload) {
-    const address = addresses[name] || name;
-    const iface = findIface(address);
-    if (!iface) {
-        log.error('unknown device', address);
-        return;
+async function handleRpc(parts, value) {
+    const [ifaceName, method, callId] = parts;
+    const iface = enabled.find((n) => n.toLowerCase() === String(ifaceName).toLowerCase());
+    const conn = iface && connections[iface];
+    const respond = (payload) => adapter.publish(adapter.topic('response', callId), payload, {retain: false});
+    if (!conn) {
+        respond({error: `unknown interface ${ifaceName}`});
+        throw new Error(`unknown interface ${ifaceName}`);
     }
-    const psName = paramsetName(devices[iface][address]);
-    let ps = paramsetDescriptions[psName];
-    ps = ps && ps[paramsetKey];
-    if (!ps) {
-        log.warn('unknown paramset', paramsetName(devices[iface][address]) + '.' + paramsetKey);
-    }
-
-    const paramset = {};
-
+    const params = Array.isArray(value) ? value : value === undefined ? [] : [value];
     try {
-        payload = JSON.parse(payload);
-        if (typeof payload !== 'object') {
-            throw new TypeError('invalid payload type', typeof payload);
-        }
-        Object.keys(payload).forEach(datapoint => {
-            if (ps[datapoint] && !(ps[datapoint].OPERATIONS & 2)) {
-                log.error(iface, address, paramsetKey, datapoint, 'not writeable');
-                return;
-            }
-            paramset[datapoint] = rpcType(String(payload[datapoint]), ps[datapoint]);
-        });
+        respond(await conn.methodCall(method, params));
     } catch (err) {
-        log.error(err);
-        return;
+        respond({error: err.message});
+        throw err;
     }
+}
+
+/*
+ * interfaces
+ */
+
+function fetchDescriptions(iface, addresses) {
+    const conn = connections[iface];
+    fetchChain = fetchChain
+        .then(() => metadata.fetchDescriptions(iface, (method, params) => conn.methodCall(method, params), {addresses}))
+        .catch((err) => log.warn(iface, 'fetching paramset descriptions failed:', err.message))
+        .then(scheduleIndex);
+    return fetchChain;
+}
 
-    log.debug('rpc', iface, '> putParamset', [address, paramsetKey, paramset]);
+/**
+ * Right after init() the CCU pushes events before it announces its devices (newDevices). On a
+ * first start (empty state) those events would lack device/channel/datapoint fields, so they
+ * are held per interface until the devices are known (or 10 s passed).
+ */
+const heldEvents = {};
 
-    rpcClient[iface].methodCall('putParamset', [address, paramsetKey, paramset], err => {
-        if (err) {
-            log.error(err);
-        }
-    });
+function holdEvent(iface, event) {
+    if (!heldEvents[iface]) {
+        return false;
+    }
+    heldEvents[iface].push(event);
+    return true;
 }
 
-function rpcSet(name, paramset, datapoint, payload) {
-    const address = addresses[name] || name;
-    const iface = findIface(address);
-    if (!iface) {
-        log.error('unknown device', address);
+function releaseEvents(iface) {
+    const held = heldEvents[iface];
+    if (!held) {
         return;
     }
-    const psName = paramsetName(devices[iface][address]);
-    let ps = paramsetDescriptions[psName];
-    ps = ps && ps[paramset] && ps[paramset][datapoint];
-    if (!ps) {
-        log.warn('unknown paramset', paramsetName(devices[iface][address]) + '.' + paramset + '.' + datapoint);
+    delete heldEvents[iface];
+    if (held.length > 0) {
+        log.debug(iface, 'releasing', held.length, 'events held until the devices were known');
+    }
+    for (const event of held) {
+        onEvent(iface, event);
     }
+}
 
-    if (ps && !(ps.OPERATIONS & 2)) {
-        log.error(iface, address, paramset, datapoint, 'not writeable');
+function onEvent(iface, event) {
+    if (holdEvent(iface, event)) {
         return;
     }
-
-    const val = rpcType(payload, ps);
-
-    log.debug('rpc', iface, '> setValue', [address, datapoint, val]);
-    rpcClient[iface].methodCall('setValue', [address, datapoint, val], err => {
-        if (err) {
-            log.error(err);
+    if (config.regaPollTrigger && regaSync && `${event.channel}.${event.datapoint}` === config.regaPollTrigger) {
+        regaSync.poll().catch((err) => log.warn('rega poll failed:', err.message));
+    }
+    values.event({iface, ...event}, (message) => {
+        const description = metadata.valueDescription(iface, event.channel, event.datapoint);
+        if (!metadata.device(iface, event.channel)) {
+            log.debug(iface, 'event of unknown channel', event.channel);
+        } else if (!description) {
+            log.debug(iface, 'no description for', event.channel, event.datapoint);
+        }
+        publishMessage(message, {retain: !isEvent(event.datapoint, description)});
+        const notWorking = values.notWorking(message);
+        if (notWorking) {
+            publishMessage(notWorking);
         }
     });
 }
 
-function rega(script, callback) {
-    const url = 'http://' + config.ccuAddress + ':8181/rega.exe';
-    log.debug('sending script to', url);
-    request({
-        method: 'POST',
-        url,
-        body: script,
-        headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            'Content-Length': script.length
-        }
-    }, (err, res, body) => {
-        if (!err && body) {
-            const end = body.indexOf('<xml>');
-            const data = body.substr(0, end);
-            callback(null, data);
-        } else {
-            callback(err);
-        }
+function createConnection(iface) {
+    const ic = interfaceConfig(iface, {tls: config.ccuTls, bidcosBinrpc: config.bidcosBinrpc});
+    const conn = new RpcConnection({
+        name: iface,
+        host: ccuIp,
+        protocol: ic.protocol,
+        port: ic.port,
+        path: ic.path,
+        tls: config.ccuTls,
+        insecure: config.ccuInsecure,
+        username: config.ccuUsername,
+        password: config.ccuPassword,
+        init: ic.init,
+        ping: ic.ping,
+        pingTimeout: ic.pingTimeout || config.pingTimeout,
+        servers,
+        initId: `hm2mqtt_${config.name}_${iface}`,
+        listDevices: () => metadata.listDevicesAnswer(iface),
+        log,
     });
-}
-
-function regaJson(file, callback) {
-    const filepath = path.join(__dirname, 'regascripts', file);
-    const script = fs.readFileSync(filepath).toString();
-    rega(script, (err, res) => {
-        if (err) {
-            log.error(err);
-        } else {
-            try {
-                callback(null, JSON.parse(unescape(res)));
-            } catch (err) {
-                callback(err);
+    conn.on('connected', (connected) => {
+        publishItem(`interface/${iface}/connected`, connected);
+        updateConnected();
+        if (connected) {
+            if (metadata.count(iface) === 0 && !heldEvents[iface]) {
+                heldEvents[iface] = [];
+                setTimeout(() => releaseEvents(iface), DEVICES_WAIT_MS).unref();
             }
+            fetchDescriptions(iface);
         }
     });
-}
-
-function getRegaDeviceNames(cb) {
-    regaJson('devices.fn', (err, res) => {
-        if (err) {
-            log.error(err);
+    conn.on('event', (event) => onEvent(iface, event));
+    conn.on('newDevices', (devices) => {
+        const added = metadata.addDevices(iface, devices);
+        log.info(
+            iface,
+            'newDevices:',
+            devices.length,
+            'announced,',
+            added.length,
+            'new (',
+            metadata.count(iface),
+            'known )',
+        );
+        if (added.length > 0) {
+            fetchDescriptions(iface, added).then(() => releaseEvents(iface));
+            adapter.publishInfo();
         } else {
-            names = res;
-            reverseNames();
-            log.info('got', Object.keys(names).length, 'names from rega. saving', 'names_' + fileName());
-            pjson.save('names_' + fileName(), names);
-            if (typeof cb === 'function') {
-                cb();
-            }
+            releaseEvents(iface);
         }
     });
-}
-
-if (config.jsonNameTable) {
-    log.info('loading name table', config.jsonNameTable);
-    names = require(config.jsonNameTable);
-    reverseNames();
-} else if (!config.disableRega) {
-    log.info('loading', 'names_' + fileName());
-    names = pjson.load('names_' + fileName()) || {};
-    getRegaDeviceNames(() => {
-        if (config.regaPollInterval || config.regaPollTrigger) {
-            getPrograms(() => {
-                getVariables();
-            });
-        }
-        if (config.regaPollInterval > 0) {
-            log.debug('rega poll interval', config.regaPollInterval);
-            setInterval(() => {
-                getPrograms(() => {
-                    getVariables();
-                });
-            }, config.regaPollInterval * 1000);
-        }
+    conn.on('deleteDevices', (addresses) => {
+        const deleted = metadata.deleteDevices(iface, addresses);
+        log.info(iface, 'deleteDevices:', deleted.length, 'removed');
+        adapter.publishInfo();
+        scheduleIndex();
     });
+    return conn;
 }
 
-function parseDateISOString(s) {
-    const ds = s.split(/\D/).map(s => parseInt(s, 10));
-    ds[1] -= 1;
-    return new Date(...ds);
-}
+/*
+ * rega
+ */
 
-function getVariables() {
-    regaJson('variables.fn', (err, res) => {
-        if (err) {
-            log.error(err);
-        } else {
-            Object.keys(res).forEach(id => {
-                const varName = res[id].name;
-                let change = false;
-                if (!variables[varName] || (res[id].val !== variables[varName].val) || (res[id].ts !== variables[varName].ts)) {
-                    change = true;
-                }
-                variables[varName] = {
-                    id: Number(id),
-                    val: res[id].val,
-                    min: res[id].min,
-                    max: res[id].max,
-                    unit: res[id].unit,
-                    ts: res[id].ts,
-                    type: variableType[res[id].type],
-                    enum: res[id].enum ? res[id].enum.split(';') : undefined
-                };
-                variableNames[Number(id)] = varName;
-                if (change) {
-                    const ts = res[id].ts ? parseDateISOString(res[id].ts).getTime() : 0;
-                    const topic = config.name + '/status/' + varName;
-                    let enumIndex = res[id].val;
-                    if (enumIndex === false) {
-                        enumIndex = 0;
-                    } else if (enumIndex === true) {
-                        enumIndex = 1;
-                    }
-                    let payload = {
-                        val: res[id].val,
-                        ts,
-                        hm: {
-                            id: Number(id),
-                            UNIT: res[id].unit,
-                            MIN: res[id].min,
-                            MAX: res[id].max,
-                            ENUM: res[id].enum ? res[id].enum.split(';')[enumIndex] : undefined
-                        }
-                    };
-                    payload = JSON.stringify(payload);
-                    mqttPublish(topic, payload, {retain: (config.mqttRetain)});
-                }
-            });
-            log.debug('rega got', Object.keys(variables).length, 'variables');
+async function startRega() {
+    try {
+        await regaSync.syncNames();
+    } catch (err) {
+        log.warn(
+            'rega: names not available (' + err.message + '), using',
+            Object.keys(regaSync.channelNames).length,
+            'cached names',
+        );
+    }
+    const duplicates = Object.entries(
+        Object.values(regaSync.channelNames).reduce((acc, name) => ((acc[name] = (acc[name] || 0) + 1), acc), {}),
+    )
+        .filter(([, n]) => n > 1)
+        .map(([name]) => name);
+    if (duplicates.length > 0) {
+        log.warn(
+            'duplicate channel names share a topic:',
+            duplicates.slice(0, 20).join(', '),
+            duplicates.length > 20 ? '…' : '',
+        );
+    }
+    regaSync.on('names', scheduleIndex);
+    regaSync.on('sysvar', publishRega);
+    regaSync.on('program', publishRega);
+    regaSync.on('polled', () => {
+        if (!regaOk) {
+            regaOk = true;
+            log.info('rega connected');
+            updateConnected();
         }
     });
-}
-
-function getPrograms(cb) {
-    regaJson('programs.fn', (err, res) => {
-        if (err) {
-            log.error(err);
-            cb(err);
-        } else {
-            Object.keys(res).forEach(id => {
-                const programName = res[id].name;
-                let change = false;
-                if (!programs[programName] || (res[id].val !== programs[programName].val) || (res[id].ts !== programs[programName].ts)) {
-                    change = true;
-                }
-                programs[programName] = {
-                    id: Number(id),
-                    active: res[id].active,
-                    ts: res[id].ts
-                };
-                programNames[Number(id)] = programName;
-                if (change) {
-                    const ts = res[id].ts ? parseDateISOString(res[id].ts).getTime() : 0;
-                    const topic = config.name + '/status/' + programName;
-                    let payload = {
-                        val: res[id].active,
-                        ts,
-                        hm: {
-                            id: Number(id)
-                        }
-                    };
-                    payload = JSON.stringify(payload);
-                    mqttPublish(topic, payload, {retain: (config.mqttRetain)});
-                }
-            });
-            log.debug('rega got', Object.keys(programs).length, 'programs');
-            cb(null);
+    regaSync.on('error', () => {
+        if (regaOk) {
+            regaOk = false;
+            log.warn('rega disconnected');
+            updateConnected();
         }
     });
+    regaSync.startPolling(config.regaPollInterval);
+    loadCache().catch((err) => log.warn('rega getValues failed:', err.message));
+    if (config.regaNamesInterval > 0) {
+        timers.push(
+            setInterval(
+                () => regaSync.syncNames().catch((err) => log.warn('rega names re-sync failed:', err.message)),
+                config.regaNamesInterval * 1000,
+            ),
+        );
+    }
 }
 
-log.debug('discover interfaces');
-discover(config.ccuAddress, {
-    // Todo... cuxd: {port: 8701, protocol: 'binrpc'},
-    rfd: {port: 2001, protocol: 'binrpc'},
-    hs485d: {port: 2000, protocol: 'binrpc'},
-    hmip: {port: 2010, protocol: 'xmlrpc'}
-}, interfaces => {
-    Object.keys(interfaces).forEach(iface => {
-        createIface(iface, interfaces[iface].protocol, interfaces[iface].port);
-        if (iface === 'hmip' && config.hmipReconnectInterval) {
-            setInterval(() => {
-                checkInit(iface, interfaces[iface].protocol);
-            }, config.hmipReconnectInterval * 1000);
-        } else if (iface === 'cuxd') {
-            // TODO
-        } else if (config.pingInterval) {
-            setInterval(() => {
-                checkInit(iface, interfaces[iface].protocol);
-            }, config.pingInterval * 1000);
+/** The ReGa's copy of every datapoint value: seeds the value store, published with --publish-cache. */
+async function loadCache() {
+    const list = await regaSync.rega.getValues();
+    let published = 0;
+    for (const dp of list) {
+        const iface = String(dp.name).split('.')[0];
+        if (!enabled.includes(iface)) {
+            continue;
         }
-    });
-});
-
-function fileName(name) {
-    return config.ccuAddress + (name ? '_' + name : '');
-}
-
-function checkInit(iface, protocol) {
-    const now = (new Date()).getTime();
-    const elapsed = Math.ceil((now - (lastEvent[iface] || 0)) / 1000);
-    log.debug(iface, 'elapsed since lastevent:', elapsed + 's');
-    if (iface === 'hmip' && config.hmipReconnectInterval) {
-        if (elapsed >= config.hmipReconnectInterval) {
-            ifaceConnected[iface] = false;
-            initIface(iface, protocol);
+        const message = values.cached(dp);
+        if (!message) {
+            continue;
         }
-    } else if (iface === 'cuxd') {
-        // TODO cuxd reconnect? ping possible?
-    } else if (elapsed >= (config.pingInterval * 2)) {
-        ifaceConnected[iface] = false;
-        initIface(iface, protocol);
-    } else if (elapsed >= config.pingInterval) {
-        log.debug('rpc', iface, '> ping');
-        rpcClient[iface].methodCall('ping', ['hm2mqtt'], err => {
-            if (err) {
-                log.error(err);
-            }
-        });
-    }
-    checkIfaceAll();
-}
-
-function checkIfaceAll() {
-    const current = ifaceAllConnected;
-    ifaceAllConnected = true;
-    Object.keys(ifaceConnected).forEach(i => {
-        if (!ifaceConnected[i]) {
-            ifaceAllConnected = false;
+        if (config.publishCache && !message.datapoint.startsWith('PRESS_')) {
+            const description = metadata.valueDescription(iface, message.channel, message.datapoint);
+            publishMessage(message, {retain: !isEvent(message.datapoint, description)});
+            published += 1;
         }
-    });
-    log.debug('ifaceAllConnected', ifaceAllConnected);
-    if (current !== ifaceAllConnected) {
-        mqtt.publish(config.name + '/connected', ifaceAllConnected ? '2' : '1', {retain: (config.mqttRetain)});
     }
+    log.info('rega getValues:', list.length, 'values cached', config.publishCache ? `, ${published} published` : '');
 }
 
-function createIface(name, protocol, port) {
-    log.debug('loading', 'devices_' + fileName(name));
-    devices[name] = pjson.load('devices_' + fileName(name));
-    log.debug('createIface', name, protocol, port);
-    if (!rpcServer[protocol]) {
-        rpcServer[protocol] = createServer(protocol);
-    }
-    rpcClient[name] = createClient(protocol, port);
-    initIface(name, protocol, port);
-    if (config.dutyCyclePollInterval && (name === 'hmip' || name === 'rfd')) {
-        setInterval(() => {
-            pollDutyCylce(name);
-        }, config.dutyCyclePollInterval * 1000);
+/*
+ * lifecycle
+ */
+
+async function start() {
+    adapter.start();
+    ccuIp = await resolveCcu();
+    if (regaSync) {
+        regaSync.rega.host = ccuIp;
+        regaSync.rega.url = regaSync.rega.url.replace(host, ccuIp);
+        regaSync.rega.webUrl = regaSync.rega.webUrl.replace(host, ccuIp);
     }
-}
-
-const stopIface = {};
-function stop() {
-    const cmdQueue = [];
-    Object.keys(stopIface).forEach(iface => {
-        cmdQueue.push(stopIface[iface]);
-    });
-    async.parallel(cmdQueue, () => {
-        process.exit(0);
-    });
-    setTimeout(() => {
-        process.exit(1);
-    }, 2500);
-}
-
-process.on('SIGINT', stop);
-process.on('SIGTERM', stop);
-
-function initIface(name, protocol) {
-    let url;
-    if (protocol === 'binrpc') {
-        url = 'xmlrpc_bin://' + (config.initAddress || config.listenAddress) + ':' + config.binrpcListenPort;
-    } else {
-        url = 'http://' + (config.initAddress || config.listenAddress) + ':' + config.listenPort;
+    enabled = parseInterfaces(config.interfaces) || (await probeInterfaces(ccuIp, {tls: config.ccuTls}));
+    if (enabled.length === 0) {
+        log.error('no interface found on', host, '- check --ccu-address / --interfaces');
     }
-    const params = [url, 'hm2mqtt_' + name];
-    log.info('rpc', name, '> init', params);
-    lastEvent[name] = (new Date()).getTime();
-    rpcClient[name].methodCall('init', params, (err, res) => {
-        if (err) {
-            log.error(err);
-        } else {
-            log.debug('rpc', name, '< init', JSON.stringify(res));
-            ifaceConnected[name] = true;
-            checkIfaceAll();
-        }
-        stopIface[name] = cb => {
-            const stopParams = [url, ''];
-            log.info('rpc', name, '> init', stopParams);
-            rpcClient[name].methodCall('init', stopParams, (err, res) => {
-                log.debug('rpc', name, '< init', err, JSON.stringify(res));
-                ifaceConnected[name] = false;
-                checkIfaceAll();
-                cb();
-            });
-        };
+    log.info('interfaces:', enabled.join(', ') || '(none)');
+    const listenAddress = config.listenAddress || firstIp();
+    servers = new RpcServers({
+        listenAddress,
+        initAddress: config.initAddress,
+        xmlrpcPort: config.xmlrpcPort,
+        binrpcPort: config.binrpcPort,
+        log,
     });
-}
-
-function createClient(protocol, port) {
-    let client;
-    const options = {
-        host: config.ccuAddress,
-        port,
-        path: '/'
-    };
-    if (protocol === 'binrpc') {
-        client = binrpc.createClient(options);
-    } else {
-        client = xmlrpc.createClient(options);
+    for (const iface of enabled) {
+        connections[iface] = createConnection(iface);
+        publishItem(`interface/${iface}/connected`, false);
     }
-    return client;
-}
-
-function paramsetName(dev) {
-    return dev.PARENT_TYPE + '/' + dev.VERSION + '/' + dev.TYPE;
-}
-
-function publishMeta(name) {
-    log.info('publish meta data', name);
-    Object.keys(devices[name]).forEach(address => {
-        const dev = devices[name][address];
-        const psDesc = paramsetDescriptions[paramsetName(dev)];
-        const obj = {
-            name: names[address] || address,
-            type: dev.PARENT_TYPE ? 'channel' : 'device',
-            interface: 'homematic',
-            native: dev
-        };
-        obj.native.PARAMSET_DESCRIPTIONS = psDesc;
-        mqttPublish('db/extend/' + config.name + '/' + address, obj);
-    });
-}
-
-function createParamsetQueue(name) {
-    name = ifaceName(name);
-    if (!devices[name]) {
-        log.error('createParamsetQueue called for unknown devices', name);
-        return;
+    publishCounters();
+    if (regaSync) {
+        await startRega();
     }
-    log.info(name, 'got', Object.keys(devices[name]).length, 'devices and channels');
-
-    log.debug('createParamsetQueue', name);
-    if (!paramsetQueue[name]) {
-        paramsetQueue[name] = [];
+    rebuildIndex();
+    await Promise.all(enabled.map((iface) => connections[iface].start()));
+    updateConnected();
+    adapter.publishInfo();
+
+    timers.push(setInterval(publishCounters, COUNTER_INTERVAL_MS));
+    if (config.dutyCycleInterval > 0) {
+        timers.push(setInterval(() => pollDutyCycle(), config.dutyCycleInterval * 1000));
+        setTimeout(() => pollDutyCycle(), 5000);
     }
-
-    Object.keys(devices[name]).forEach(address => {
-        const dev = devices[name][address];
-        if (!dev.PARENT_TYPE) {
-            return;
-        }
-        if (!paramsetDescriptions[paramsetName(dev)]) {
-            log.debug('unknown', paramsetName(dev), dev.PARAMSETS);
-            paramsetDescriptions[paramsetName(dev)] = {};
-            dev.PARAMSETS.forEach(ps => {
-                paramsetQueue[name].push({ADDRESS: dev.ADDRESS, PARAMSET: ps, name: paramsetName(dev)});
-            });
-        }
-    });
-    getParamset(name);
+    timers.push(setInterval(() => values.save(), VALUES_SAVE_MS));
 }
 
-function getParamset(name) {
-    if (paramsetQueue[name].length > 0) {
-        const obj = paramsetQueue[name].shift();
-        log.debug('rpc', name, '> getParamsetDescription', [obj.ADDRESS, obj.PARAMSET], obj.name);
-        rpcClient[name].methodCall('getParamsetDescription', [obj.ADDRESS, obj.PARAMSET], (err, res) => {
-            if (!err) {
-                paramsetDescriptions[obj.name][obj.PARAMSET] = res;
-            }
-            setTimeout(() => {
-                getParamset(name);
-            }, 500);
-        });
-    } else {
-        log.debug('getParamsetDescriptions', name, 'done');
-        log.info('got', Object.keys(paramsetDescriptions).length, 'paramsetDescriptions');
-        log.debug('saving', 'paramsetDescriptions_' + fileName());
-        pjson.save('paramsetDescriptions_' + fileName(), paramsetDescriptions);
-        if (config.publishMetadata) {
-            publishMeta(name);
-        }
+async function shutdown() {
+    for (const timer of timers) {
+        clearInterval(timer);
     }
-}
-
-function ifaceName(id) {
-    return id.replace(/^hm2mqtt_/, '');
-}
-
-const rpcMethods = {
-    notFound: method => {
-        log.debug('rpc < Method ' + method + ' does not exist');
-    },
-    'system.multicall': (err, params, callback) => {
-        if (err) {
-            log.error(err);
-            return;
-        }
-        const res = [];
-        params[0].forEach(c => {
-            if (rpcMethods[c.methodName]) {
-                rpcMethods[c.methodName](err, c.params);
-            } else {
-                rpcMethods.notFound(c.methodName, c.params);
-            }
-            res.push('');
-        });
-        callback(null, res);
-    },
-    'system.listMethods': (err, params, callback) => {
-        if (err) {
-            log.error(err);
-            return;
-        }
-        log.debug('rpc < system.listMethods', params);
-        callback(null, Object.keys(rpcMethods));
-    },
-    event: (err, params, callback) => {
-        if (err) {
-            log.error(err);
-            return;
-        }
-        log.debug('rpc < event', JSON.stringify(params));
-
-        const ts = (new Date()).getTime();
-        lastEvent[ifaceName(params[0])] = ts;
-
-        if (params[1] === 'CENTRAL' && params[2] === 'PONG') {
-            if (typeof callback === 'function') {
-                callback(null, '');
-            }
-            return;
-        }
-
-        if (params[2] === 'WORKING' || params[2] === 'DIRECTION') {
-            working[params[1]] = Boolean(params[3]);
-        }
-
-        if (config.regaPollTrigger) {
-            const [regaPollTriggerChannel, regaPollTriggerDatapoint] = config.regaPollTrigger.split('.');
-            if (params[1] === regaPollTriggerChannel && params[2] === regaPollTriggerDatapoint) {
-                getPrograms(() => {
-                    getVariables();
-                });
-            }
-        }
-
-        const key = params[1] + '/' + params[2];
-
-        if (values[key] !== params[3]) {
-            changes[key] = ts;
-            values[key] = params[3];
-        }
-
-        const dev = devices[ifaceName(params[0])] && devices[ifaceName(params[0])][params[1]];
-        if (!dev) {
-            log.error('unknown device', params[0], params[1]);
-            return;
-        }
-        let ps = paramsetDescriptions[paramsetName(dev)];
-        if (!ps) {
-            log.error('unknown paramsetDescription', paramsetName(dev));
-        } else if (!ps.VALUES) {
-            log.error('missing VALUES in paramsetDescription', paramsetName(dev));
-        } else if (!ps.VALUES[params[2]]) {
-            log.error('missing VALUE', params[2], 'in paramsetDescription', paramsetName(dev));
-        }
-        ps = (ps && ps.VALUES && ps.VALUES[params[2]]) || {};
-
-        const topic = config.name + '/status/' + (names[params[1]] || params[1]) + '/' + params[2];
-
-        let payload = {val: params[3], ts, lc: changes[key], hm: {ADDRESS: params[1]}};
-        if (ps.UNIT && ps.UNIT !== '""') {
-            if (ps.UNIT === '�C') {
-                payload.hm.UNIT = '°C';
-            } else {
-                payload.hm.UNIT = ps.UNIT;
-            }
-        }
-        if (ps.TYPE === 'ENUM') {
-            payload.hm.ENUM = ps.VALUE_LIST[params[3]];
-        }
-        payload = JSON.stringify(payload);
-
-        const retain = (config.mqttRetain) && (ps.TYPE !== 'ACTION');
-
-        mqttPublish(topic, payload, {retain});
-
-        if (typeof working[params[1]] !== 'undefined' && (params[2] === 'LEVEL' || params[2] === 'STATE')) {
-            clearTimeout(workingTimeout[params[1]]);
-            workingTimeout[params[1]] = setTimeout(() => {
-                if (!working[params[1]]) {
-                    mqttPublish(topic + '_NOTWORKING', payload, {retain});
-                }
-            }, 500);
-        }
-
-        if (typeof callback === 'function') {
-            callback(null, '');
-        }
-    },
-    listDevices: (err, params, callback) => {
-        if (err) {
-            log.error(err);
-            return;
-        }
-        log.debug('rpc < listDevices', params);
-        const name = ifaceName(params[0]);
-        const ret = [];
-        const test = [];
-        if (devices[name]) {
-            Object.keys(devices[name]).forEach(address => {
-                test.push(devices[name][address]);
-                /* Todo This does not work: https://github.com/eq-3/occu/issues/45
-                if (name === 'hmip') {
-                    ret.push({
-                        ADDRESS: address,
-                        VERSION: devices[name][address].VERSION,
-                        AES_ACTIVE: devices[name][address].AES_ACTIVE,
-                        CHILDREN: devices[name][address].CHILDREN,
-                        DIRECTION: devices[name][address].DIRECTION,
-                        FIRMWARE: devices[name][address].FIRMWARE,
-                        FLAGS: devices[name][address].FLAGS,
-                        GROUP: devices[name][address].GROUP,
-                        INDEX: devices[name][address].INDEX,
-                        INTERFACE: devices[name][address].INTERFACE,
-                        LINK_SOURCE_ROLES: devices[name][address].LINK_SOURCE_ROLES,
-                        LINK_TARGET_ROLES: devices[name][address].LINK_TARGET_ROLES,
-                        PARAMSETS: devices[name][address].PARAMSETS,
-                        PARENT: devices[name][address].PARENT,
-                        PARENT_TYPE: devices[name][address].PARENT_TYPE,
-                        RF_ADDRESS: devices[name][address].RF_ADDRESS,
-                        ROAMING: devices[name][address].ROAMING,
-                        RX_MODE: devices[name][address].RX_MODE,
-                        TEAM: devices[name][address].TEAM,
-                        TEAM_CHANNELS: devices[name][address].TEAM_CHANNELS,
-                        TEAM_TAG: devices[name][address].TEAM_TAG,
-                        TYPE: devices[name][address].TYPE
-                    });
-                } else {
-                    ret.push({
-                        ADDRESS: address,
-                        VERSION: devices[name][address].VERSION
-                    });
-                }
-                 */
-                ret.push({
-                    ADDRESS: address,
-                    VERSION: devices[name][address].VERSION
-                });
-            });
-        }
-        log.debug('>', ret.length);
-        callback(null, ret);
-        getParamsetTimeout[params[0]] = setTimeout(() => {
-            createParamsetQueue(params[0]);
-        }, 5000);
-    },
-    deleteDevices: (err, params, callback) => {
-        if (err) {
-            log.error(err);
-            return;
-        }
-        clearTimeout(getParamsetTimeout[params[0]]);
-        log.debug('rpc < deleteDevices', params[1].length);
-        const name = ifaceName(params[0]);
-        params[1].forEach(dev => {
-            delete devices[name][dev];
-        });
-        log.debug('saving', 'devices_' + fileName(name), '(' + Object.keys(devices[name]).length + ')');
-        pjson.save('devices_' + fileName(name), devices[name]);
-        callback(null, '');
-        getParamsetTimeout[params[0]] = setTimeout(() => {
-            createParamsetQueue(params[0]);
-        }, 5000);
-    },
-    newDevices: (err, params, callback) => {
-        if (err) {
-            log.error(err);
-            return;
-        }
-        clearTimeout(getParamsetTimeout[params[0]]);
-        log.debug('rpc < newDevices', params[1].length);
-        const name = ifaceName(params[0]);
-        const devs = devices[name] || {};
-        params[1].forEach(dev => {
-            devs[dev.ADDRESS] = dev;
-        });
-        devices[name] = devs;
-        log.debug('saving', 'devices_' + fileName(name), '(' + Object.keys(devices[name]).length + ')');
-        pjson.save('devices_' + fileName(name), devs);
-        callback(null, '');
-        getParamsetTimeout[params[0]] = setTimeout(() => {
-            createParamsetQueue(params[0]);
-        }, 5000);
+    for (const entry of setTimers.values()) {
+        clearTimeout(entry.timer);
     }
-};
-
-rpcMethods.NotFound = rpcMethods.notFound;
-
-function createServer(protocol) {
-    let server;
-    if (protocol === 'binrpc') {
-        server = binrpc.createServer({host: config.listenAddress, port: config.binrpcListenPort});
-    } else {
-        server = xmlrpc.createServer({host: config.listenAddress, port: config.listenPort});
+    values.stop();
+    if (regaSync) {
+        regaSync.stopPolling();
+    }
+    // state first: the core gives onShutdown two seconds, the de-init may not answer
+    values.save();
+    metadata.save();
+    const stopAll = Promise.all(Object.values(connections).map((conn) => conn.stop()));
+    await Promise.race([stopAll, new Promise((resolve) => setTimeout(resolve, STOP_TIMEOUT_MS))]);
+    if (servers) {
+        await Promise.race([servers.close(), new Promise((resolve) => setTimeout(resolve, 300))]);
     }
-    Object.keys(rpcMethods).forEach(method => {
-        server.on(method, rpcMethods[method]);
-    });
-    return server;
 }
 
-function pollDutyCylce(iface) {
-    rpcClient[iface].methodCall('listBidcosInterfaces', [], (err, res) => {
-        if (err) {
-            log.error(err);
-        } else if (res && res.forEach) {
-            res.forEach(data => {
-                const topic = config.name + '/status/' + data.ADDRESS + '/DUTY_CYCLE';
-                const payload = {
-                    val: data.DUTY_CYCLE,
-                    ts: (new Date()).getTime()
-                };
-                mqttPublish(topic, payload, {retain: (config.mqttRetain)});
-            });
-        }
-    });
-}
+start().catch((err) => {
+    log.error('start failed:', err.message);
+    adapter.shutdown('start failed', 1);
+});