node-red-contrib-ccu 4.1.0 → 4.3.0

package/nodes/lib/haroles.js

@@ -0,0 +1,193 @@
+/* Semantic roles of channels and the Home Assistant facts of datapoints.
+   Ported from hm2mqtt.js lib/roles.js (same author) for B-16.
+
+   hm2mqtt derives the role from the CONTROL hint eQ-3 puts on every VALUES
+   parameter. In the paramset cache shipped with this package (and therefore
+   in the persisted cache of existing installs) only about half of the VALUES
+   descriptions carry CONTROL fields — the older contributed user dumps were
+   stripped of them — so here the channel TYPE is the primary key and CONTROL
+   only refines where the description has it. Pure functions and tables, no I/O. */
+
+/** CONTROL hint of a channel's primary datapoint → role; checked in this order */
+const ROLE_BY_CONTROL = [
+    ['LOCK.STATE', 'lock'],
+    ['HEATING_CONTROL_HMIP.SETPOINT', 'climate_hmip'],
+    ['HEATING_CONTROL.SETPOINT', 'climate_hm'],
+    ['BLIND.LEVEL', 'cover'],
+    ['BLIND_VIRTUAL_RECEIVER.LEVEL', 'cover'],
+    ['SHUTTER_VIRTUAL_RECEIVER.LEVEL', 'cover'],
+    ['BLIND_TRANSMITTER.LEVEL', 'cover_state'],
+    ['SHUTTER_TRANSMITTER.LEVEL', 'cover_state'],
+    ['DIMMER.LEVEL', 'dimmer'],
+    ['DIMMER_REAL.LEVEL', 'dimmer_state'],
+    ['SWITCH.STATE', 'switch'],
+    ['SWITCH_TRANSMITTER.STATE', 'switch_state'],
+    ['DANGER.STATE', 'smoke'],
+    ['DOOR_SENSOR.STATE', 'contact'],
+    ['RHS.STATE', 'rotary_handle'],
+    ['MOTIONDETECTOR_TRANSCEIVER.MOTION_DETECTION_STATE', 'motion'],
+    ['POWERMETER.POWER', 'energy'],
+    ['POWERMETER_PSM.POWER', 'energy'],
+    ['WEATHER_TRANSMIT.ACTUAL_TEMPERATURE', 'weather'],
+    ['BUTTON.SHORT', 'key'],
+    ['BUTTON_NO_FUNCTION.SHORT', 'key'],
+];
+
+/** channel type → role (HM classic, HmIP and the CCU's own channels) */
+const ROLE_BY_TYPE = {
+    MAINTENANCE: 'maintenance',
+
+    // HM classic actuators
+    SWITCH: 'switch',
+    DIMMER: 'dimmer',
+    VIRTUAL_DIMMER: 'dimmer',
+    BLIND: 'cover',
+    KEYMATIC: 'lock',
+
+    // HmIP actuators: one *_TRANSMITTER (state) followed by *_VIRTUAL_RECEIVER channels (control)
+    SWITCH_VIRTUAL_RECEIVER: 'switch',
+    SWITCH_TRANSMITTER: 'switch_state',
+    DIMMER_VIRTUAL_RECEIVER: 'dimmer',
+    DIMMER_TRANSMITTER: 'dimmer_state',
+    BLIND_VIRTUAL_RECEIVER: 'cover',
+    SHUTTER_VIRTUAL_RECEIVER: 'cover',
+    BLIND_TRANSMITTER: 'cover_state',
+    SHUTTER_TRANSMITTER: 'cover_state',
+
+    // thermostats
+    HEATING_CLIMATECONTROL_TRANSCEIVER: 'climate_hmip',
+    CLIMATECONTROL_RT_TRANSCEIVER: 'climate_hm',
+    THERMALCONTROL_TRANSMIT: 'climate_hm',
+
+    // sensors
+    SHUTTER_CONTACT: 'contact',
+    SHUTTER_CONTACT_TRANSCEIVER: 'contact',
+    MULTI_MODE_INPUT_TRANSMITTER: 'contact',
+    TILT_SENSOR: 'contact',
+    ROTARY_HANDLE_SENSOR: 'rotary_handle',
+    ROTARY_HANDLE_TRANSCEIVER: 'rotary_handle',
+    MOTION_DETECTOR: 'motion',
+    MOTIONDETECTOR_TRANSCEIVER: 'motion',
+    PRESENCEDETECTOR_TRANSCEIVER: 'presence',
+    WEATHER: 'weather',
+    WEATHER_TRANSMIT: 'weather',
+    WATERDETECTIONSENSOR: 'water',
+    WATER_DETECTION_TRANSMITTER: 'water',
+    SMOKE_DETECTOR: 'smoke',
+    SMOKE_DETECTOR_TEAM: 'smoke',
+    SMOKE_DETECTOR_TEAM_V2: 'smoke',
+    POWERMETER: 'energy',
+    ENERGIE_METER_TRANSMITTER: 'energy',
+
+    // keys
+    KEY: 'key',
+    VIRTUAL_KEY: 'key',
+    KEY_TRANSCEIVER: 'key',
+    CENTRAL_KEY: 'key',
+};
+
+/**
+ * @param {string} channelType
+ * @param {object} [description] VALUES paramset description of the channel
+ * @returns {string | null}
+ */
+function channelRole(channelType, description) {
+    if (ROLE_BY_TYPE[channelType] === 'maintenance') {
+        return 'maintenance';
+    }
+
+    if (description) {
+        const controls = new Set(Object.values(description).map((d) => d && d.CONTROL));
+        for (const [control, role] of ROLE_BY_CONTROL) {
+            if (controls.has(control)) {
+                return role;
+            }
+        }
+    }
+
+    return ROLE_BY_TYPE[channelType] || null;
+}
+
+/** units as the interface processes send them → Home Assistant */
+function haUnit(unit) {
+    if (!unit || unit === '""') {
+        return undefined;
+    }
+
+    const u = String(unit).replace(/�|°/g, '°');
+    return (
+        {
+            '100%': '%',
+            '% rF': '%',
+            Lux: 'lx',
+            degree: '°',
+            '°': '°',
+            min: 'min',
+            s: 's',
+            mA: 'mA',
+        }[u] || u
+    );
+}
+
+/** `100%` values are 0..1 on the wire */
+function isFraction(description) {
+    return Boolean(description && description.UNIT === '100%');
+}
+
+/**
+ * Home Assistant facts of a datapoint by name: device class, state class, unit override,
+ * entity category, enabled by default. Anything not listed is a plain sensor / binary_sensor,
+ * disabled by default.
+ */
+const PARAMETERS = {
+    ACTUAL_TEMPERATURE: {dev_cla: 'temperature', stat_cla: 'measurement', unit: '°C', enabled: true},
+    TEMPERATURE: {dev_cla: 'temperature', stat_cla: 'measurement', unit: '°C', enabled: true},
+    SET_POINT_TEMPERATURE: {dev_cla: 'temperature', unit: '°C'},
+    SET_TEMPERATURE: {dev_cla: 'temperature', unit: '°C'},
+    HUMIDITY: {dev_cla: 'humidity', stat_cla: 'measurement', unit: '%', enabled: true},
+    ACTUAL_HUMIDITY: {dev_cla: 'humidity', stat_cla: 'measurement', unit: '%', enabled: true},
+    ILLUMINATION: {dev_cla: 'illuminance', stat_cla: 'measurement', unit: 'lx', enabled: true},
+    CURRENT_ILLUMINATION: {dev_cla: 'illuminance', stat_cla: 'measurement', unit: 'lx'},
+    AVERAGE_ILLUMINATION: {dev_cla: 'illuminance', stat_cla: 'measurement', unit: 'lx'},
+    BRIGHTNESS: {stat_cla: 'measurement', enabled: true},
+    POWER: {dev_cla: 'power', stat_cla: 'measurement', unit: 'W', enabled: true},
+    CURRENT: {dev_cla: 'current', stat_cla: 'measurement', unit: 'mA', enabled: true},
+    VOLTAGE: {dev_cla: 'voltage', stat_cla: 'measurement', unit: 'V', enabled: true},
+    FREQUENCY: {dev_cla: 'frequency', stat_cla: 'measurement', unit: 'Hz'},
+    ENERGY_COUNTER: {dev_cla: 'energy', stat_cla: 'total_increasing', unit: 'Wh', enabled: true},
+    RAIN_COUNTER: {dev_cla: 'precipitation', stat_cla: 'total_increasing', unit: 'mm', enabled: true},
+    RAINING: {dev_cla: 'moisture', enabled: true},
+    WIND_SPEED: {dev_cla: 'wind_speed', stat_cla: 'measurement', unit: 'km/h', enabled: true},
+    WIND_DIRECTION: {stat_cla: 'measurement', unit: '°', enabled: true},
+    WIND_DIR: {stat_cla: 'measurement', unit: '°', enabled: true},
+    SUNSHINEDURATION: {stat_cla: 'total_increasing', enabled: true},
+    AIR_PRESSURE: {dev_cla: 'atmospheric_pressure', stat_cla: 'measurement', unit: 'hPa', enabled: true},
+    VALVE_STATE: {stat_cla: 'measurement', unit: '%', enabled: true},
+    LEVEL: {stat_cla: 'measurement', unit: '%'},
+    BOOST_STATE: {unit: 'min'},
+    LOW_BAT: {dev_cla: 'battery', ent_cat: 'diagnostic', enabled: true},
+    LOWBAT: {dev_cla: 'battery', ent_cat: 'diagnostic', enabled: true},
+    UNREACH: {dev_cla: 'connectivity', ent_cat: 'diagnostic', inverted: true},
+    STICKY_UNREACH: {dev_cla: 'problem', ent_cat: 'diagnostic'},
+    CONFIG_PENDING: {ent_cat: 'diagnostic'},
+    UPDATE_PENDING: {dev_cla: 'update', ent_cat: 'diagnostic'},
+    DUTY_CYCLE: {dev_cla: 'problem', ent_cat: 'diagnostic'},
+    DUTYCYCLE: {dev_cla: 'problem', ent_cat: 'diagnostic'},
+    SABOTAGE: {dev_cla: 'tamper', ent_cat: 'diagnostic'},
+    ERROR_SABOTAGE: {dev_cla: 'tamper', ent_cat: 'diagnostic'},
+    RSSI_DEVICE: {dev_cla: 'signal_strength', stat_cla: 'measurement', unit: 'dBm', ent_cat: 'diagnostic'},
+    RSSI_PEER: {dev_cla: 'signal_strength', stat_cla: 'measurement', unit: 'dBm', ent_cat: 'diagnostic'},
+    OPERATING_VOLTAGE: {dev_cla: 'voltage', stat_cla: 'measurement', unit: 'V', ent_cat: 'diagnostic'},
+    ERROR_CODE: {ent_cat: 'diagnostic'},
+    WORKING: {dev_cla: 'running'},
+    PROCESS: {dev_cla: 'running'},
+    MOTION: {dev_cla: 'motion', enabled: true},
+    PRESENCE_DETECTION_STATE: {dev_cla: 'occupancy', enabled: true},
+    ALARMSTATE: {dev_cla: 'safety', enabled: true},
+    MOISTURE_DETECTED: {dev_cla: 'moisture', enabled: true},
+    WATERLEVEL_DETECTED: {dev_cla: 'moisture', enabled: true},
+    ON_TIME: {ent_cat: 'config', unit: 's'},
+    RAMP_TIME: {ent_cat: 'config', unit: 's'},
+};
+
+module.exports = {ROLE_BY_CONTROL, ROLE_BY_TYPE, channelRole, haUnit, isFraction, PARAMETERS};

package/nodes/lib/localccu.js

@@ -0,0 +1,81 @@
+/* Detecting "Node-RED runs on the CCU itself" (B-4).
+
+   When it does, the interface processes can be reached directly on their
+   3xxxx ports (BINRPC where available) instead of going through the CCU's
+   lighttpd proxy on 1999/2000/2001/2010/9292 - fewer hops, and BINRPC
+   instead of XML-RPC for BidCos.
+
+   The old test grepped /etc/lighttpd/conf.d/proxy.conf for
+   `"port" => 32001`. On current firmware that file is a one-line
+   `include "/var/etc/lighttpd_proxy.conf"`, which itself only includes
+   proxy_normal.conf - the port markers are two levels down, so the regex
+   has not matched since (verified on CCU3 firmware 3.89.8, where 31999,
+   32001, 32010 and 39292 are all listening while proxy.conf says nothing
+   about them). Every local install has silently been running through the
+   proxy.
+
+   Rather than chasing lighttpd's include chain, ask the kernel: a
+   listener on the direct port is exactly the condition that makes using
+   it correct. /proc/net/tcp is a plain file, so this stays synchronous -
+   the interface table is built in the connection node's constructor. */
+
+const fs = require('fs');
+
+/** rfd's direct BINRPC port on firmware >= 3.41; the marker for "on the CCU". */
+const LOCAL_PROBE_PORTS = [32001, 31999];
+
+const PROC_NET_TCP = ['/proc/net/tcp', '/proc/net/tcp6'];
+
+/** /proc/net/tcp connection state 0A = TCP_LISTEN. */
+const TCP_LISTEN = '0A';
+
+/**
+ * The TCP ports something is listening on, from /proc/net/tcp{,6}.
+ * @param {string[]} [files] override, for tests
+ * @returns {Set<number>} empty when /proc is unavailable (non-Linux)
+ */
+function listeningPorts(files) {
+    const ports = new Set();
+
+    (files || PROC_NET_TCP).forEach((file) => {
+        let content;
+        try {
+            content = fs.readFileSync(file, 'utf8');
+        } catch {
+            return;
+        }
+
+        content.split('\n').forEach((line) => {
+            // sl  local_address rem_address st ...
+            const columns = line.trim().split(/\s+/);
+            if (columns.length < 4 || columns[3] !== TCP_LISTEN) {
+                return;
+            }
+
+            const port = Number.parseInt(String(columns[1]).split(':')[1], 16);
+            if (Number.isInteger(port)) {
+                ports.add(port);
+            }
+        });
+    });
+
+    return ports;
+}
+
+/**
+ * Are we talking to a CCU we are running on, with the direct ports open?
+ * @param {string} host the configured CCU host
+ * @param {object} [options]
+ * @param {string[]} [options.files] /proc files to read, for tests
+ * @returns {boolean}
+ */
+function isLocalCcu(host, options) {
+    if (!host || !(String(host).startsWith('127.') || host === 'localhost' || host === '::1')) {
+        return false;
+    }
+
+    const ports = listeningPorts(options && options.files);
+    return LOCAL_PROBE_PORTS.some((port) => ports.has(port));
+}
+
+module.exports = {isLocalCcu, listeningPorts, LOCAL_PROBE_PORTS};

package/nodes/lib/message.js

@@ -18,6 +18,8 @@
  * @param {object} [additions] merged into the message (cache, working, uncertain, ts, lc, ...)
  * @returns {object} the message
  */
+const {enumList} = require('./cast.js');
+
 function createMessage(ccu, iface, channel, datapoint, payload, additions) {
     const datapointName = iface + '.' + channel + '.' + datapoint;
     if (!ccu.values[datapointName]) {
@@ -73,12 +75,14 @@ function createMessage(ccu, iface, channel, datapoint, payload, additions) {
         datapointType: description.TYPE,
         datapointMin: description.MIN,
         datapointMax: description.MAX,
-        datapointEnum: description.ENUM,
+        // the CCU sends the names in VALUE_LIST; reading description.ENUM
+        // meant both of these were always undefined (B-3, ROADMAP 8.2)
+        datapointEnum: enumList(description),
         datapointDefault: description.DEFAULT,
         datapointControl: description.CONTROL,
         value: payload,
         valuePrevious: ccu.values[datapointName].value,
-        valueEnum: description.ENUM ? description.ENUM[Number(payload)] : undefined,
+        valueEnum: enumList(description) ? enumList(description)[Number(payload)] : undefined,
         valueStable,
         rooms: ccu.channelRooms[channel] || [],
         room:

package/nodes/lib/valuestatus.js

@@ -0,0 +1,145 @@
+/* Node status line showing the last known value and how old it is
+   (B-5, issues #54 and #52).
+
+   The data was always there - the connection keeps value, ts and lc for
+   every datapoint and system variable - the nodes just never showed it,
+   and the sysvar node only showed anything at all when "emit value on
+   start" was enabled. The age is re-rendered on a timer so the line does
+   not silently become stale between events. */
+
+/** Node-RED status lines are narrow - keep them readable. */
+const MAX_TEXT = 45;
+
+const MINUTE = 60;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+
+/** How often the age is re-rendered, matched to the resolution shown. */
+function refreshInterval(seconds) {
+    if (seconds < MINUTE) {
+        return 5000;
+    }
+
+    if (seconds < HOUR) {
+        return 30000;
+    }
+
+    return 300000;
+}
+
+/**
+ * Compact age of a timestamp, in the style Node-RED status lines use.
+ * @param {number} ts epoch milliseconds
+ * @param {number} now epoch milliseconds
+ * @returns {string} e.g. '5s', '12m', '3h', '2d'
+ */
+function relativeTime(ts, now) {
+    const seconds = Math.max(0, Math.round((now - ts) / 1000));
+    if (seconds < MINUTE) {
+        return seconds + 's';
+    }
+
+    if (seconds < HOUR) {
+        return Math.floor(seconds / MINUTE) + 'm';
+    }
+
+    if (seconds < DAY) {
+        return Math.floor(seconds / HOUR) + 'h';
+    }
+
+    return Math.floor(seconds / DAY) + 'd';
+}
+
+/**
+ * The status text for a value with a timestamp.
+ * @param {*} value
+ * @param {number} [ts] epoch milliseconds; omitted renders the value alone
+ * @param {number} now epoch milliseconds
+ * @returns {string}
+ */
+function formatValueStatus(value, ts, now) {
+    let text = String(value);
+    if (text.length > MAX_TEXT) {
+        text = text.slice(0, MAX_TEXT - 1) + '…';
+    }
+
+    if (!ts) {
+        return text;
+    }
+
+    return text + ' (' + relativeTime(ts, now) + ')';
+}
+
+/**
+ * Keeps a node's status line showing the last value and its age.
+ *
+ * @param {object} node the Node-RED node (needs .status())
+ * @param {object} [options]
+ * @param {Function} [options.now] clock, for tests
+ * @returns {{set: Function, clear: Function, stop: Function}}
+ */
+function valueStatus(node, options) {
+    const now = (options && options.now) || Date.now;
+    let timer = null;
+    let current = null;
+
+    function render() {
+        if (!current) {
+            return;
+        }
+
+        node.status({
+            fill: 'green',
+            shape: 'ring',
+            text: formatValueStatus(current.value, current.ts, now()),
+        });
+    }
+
+    function schedule() {
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+
+        if (!current || !current.ts) {
+            return;
+        }
+
+        const interval = refreshInterval(Math.round((now() - current.ts) / 1000));
+        timer = setInterval(() => {
+            render();
+            // the resolution coarsens as the value ages - re-arm accordingly
+            schedule();
+        }, interval);
+        if (typeof timer.unref === 'function') {
+            timer.unref();
+        }
+    }
+
+    return {
+        /**
+         * @param {*} value
+         * @param {number} [ts] epoch milliseconds
+         */
+        set(value, ts) {
+            current = {value, ts};
+            render();
+            schedule();
+        },
+        clear() {
+            current = null;
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+        stop() {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+        },
+    };
+}
+
+module.exports = {valueStatus, formatValueStatus, relativeTime};

package/nodes/locales/de/ccu-display.html

@@ -4,4 +4,21 @@
     als Nachricht übergeben werden diese
     anstelle der Konfiguration genutzt.</p>
     <p>Mit <code>msg.disbleX</code> kann explizit gesetzt werden, dass keine Daten für die Zeile übertragen werden.</p>
+
+    <h3>Dynamische Konfiguration</h3>
+    <p><code>msg.config</code> ist ein Objekt, dessen Eigenschaften die Konfiguration dieses Nodes für genau diese Nachricht überschreiben. Die gespeicherte Konfiguration bleibt unverändert.</p>
+    <ul>
+        <li><code>iface</code></li>
+        <li><code>channel</code></li>
+        <li><code>channelType</code></li>
+        <li><code>sound</code></li>
+        <li><code>repeat</code></li>
+        <li><code>pause</code></li>
+        <li><code>signal</code></li>
+        <li><code>line1 ... line6</code></li>
+        <li><code>color1 ... color6</code></li>
+        <li><code>icon1 ... icon6</code></li>
+        <li><code>disable1 ... disable6</code></li>
+    </ul>
+    <p><code>msg.line1</code> usw. funktionieren unverändert weiter.</p>
 </script>

package/nodes/locales/de/ccu-rpc-event.json

@@ -4,5 +4,6 @@
     "change": "Nur geänderte Werte ausgeben",
     "cache": "Beim Start letzten bekannten Wert ausgeben",
     "working": "Während WORKING keine Werte ausgeben",
+    "certainOnly": "Unsichere Werte verwerfen"
   }
 }

package/nodes/locales/de/ccu-sysvar.json

@@ -2,6 +2,7 @@
   "ccu-sysvar": {
     "tip": "Wird keine Variable ausgewählt kann der Variablen-Name über msg.topic übergeben werden.",
     "change": "Nur geänderte Werte ausgeben",
-    "cache": "Beim Start aktuellen Wert ausgeben"
+    "cache": "Beim Start aktuellen Wert ausgeben",
+    "property": "Wert aus"
   }
-}
+}

package/nodes/locales/de/ccu-value.json

@@ -8,6 +8,7 @@
     "change": "Nur geänderte Werte ausgeben",
     "cache": "Beim Start letzten bekannten Wert ausgeben",
     "working": "Während WORKING keine Werte ausgeben",
-    "queue": "Queue"
+    "queue": "Queue",
+    "certainOnly": "Unsichere Werte verwerfen"
   }
 }

package/nodes/locales/en-US/ccu-display.html

@@ -3,4 +3,21 @@
     <p>If <code>msg.lineX</code>, <code>msg.iconX</code> or <code>msg.colorX</code>
     are set in the message these are used instead of the configuration.</p>
     <p> With <code>msg.disbleX</code> you can explicitly set that no data is transferred for the line.</p>
+
+    <h3>Dynamic configuration</h3>
+    <p><code>msg.config</code> is an object whose properties override this node's configuration for that one message. The stored configuration is never modified.</p>
+    <ul>
+        <li><code>iface</code></li>
+        <li><code>channel</code></li>
+        <li><code>channelType</code></li>
+        <li><code>sound</code></li>
+        <li><code>repeat</code></li>
+        <li><code>pause</code></li>
+        <li><code>signal</code></li>
+        <li><code>line1 ... line6</code></li>
+        <li><code>color1 ... color6</code></li>
+        <li><code>icon1 ... icon6</code></li>
+        <li><code>disable1 ... disable6</code></li>
+    </ul>
+    <p><code>msg.line1</code> and friends keep working unchanged.</p>
 </script>

package/nodes/locales/en-US/ccu-rpc-event.json

@@ -3,6 +3,7 @@
     "tip": "Tip: ",
     "change": "Emit only changed values",
     "cache": "Emit cached value on start",
-    "working": "Don't emit values while actuator is in WORKING state"
+    "working": "Don't emit values while actuator is in WORKING state",
+    "certainOnly": "Discard uncertain values"
   }
-}
+}

package/nodes/locales/en-US/ccu-switch.html

@@ -0,0 +1,12 @@
+<script type="text/html" data-help-name="ccu-switch">
+    <h3>Dynamic configuration</h3>
+    <p><code>msg.config</code> is an object whose properties override this node's configuration for that one message. The stored configuration is never modified.</p>
+    <ul>
+        <li><code>iface</code></li>
+        <li><code>channel</code></li>
+        <li><code>datapoint</code></li>
+        <li><code>datapointProperty</code></li>
+        <li><code>sysvar</code></li>
+        <li><code>sysvarProperty</code></li>
+    </ul>
+</script>

package/nodes/locales/en-US/ccu-sysvar.json

@@ -2,6 +2,7 @@
   "ccu-sysvar": {
     "tip": "Omit the variable name to supply it via msg.payload",
     "change": "Emit changed values only",
-    "cache": "Emit value on start"
+    "cache": "Emit value on start",
+    "property": "Value from"
   }
-}
+}

package/nodes/locales/en-US/ccu-value.json

@@ -8,6 +8,7 @@
     "change": "Emit changed values only",
     "cache": "Emit cached value on start",
     "working": "Don't emit values while actuator is in WORKING state",
-    "queue": "Queue Commands"
+    "queue": "Queue Commands",
+    "certainOnly": "Discard uncertain values"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-ccu",
-  "version": "4.1.0",
+  "version": "4.3.0",
   "license": "MIT",
   "main": "none",
   "keywords": [
@@ -99,6 +99,7 @@
       "ccu-get-value": "nodes/ccu-get-value.js",
       "ccu-switch": "nodes/ccu-switch.js",
       "ccu-hm2mqtt": "nodes/ccu-mqtt.js",
+      "ccu-homeassistant": "nodes/ccu-homeassistant.js",
       "ccu-alexa": "nodes/ccu-alexa.js"
     }
   },

package/patch-certainonly.py

@@ -0,0 +1,51 @@
+import io
+import json
+
+# --- editors: certainOnly checkbox (#96) -----------------------------------
+for name, default_anchor in (
+    ("ccu-value", "            cache: {value: false},\n"),
+    ("ccu-rpc-event", "            cache: {value: false},\n"),
+):
+    p = "nodes/%s.html" % name
+    s = io.open(p, encoding="utf-8").read()
+
+    assert default_anchor in s, "defaults anchor in " + p
+    s = s.replace(default_anchor, default_anchor + "            certainOnly: {value: false},\n", 1)
+
+    old = """            <label class="ccu-checkbox">
+                <input type="checkbox" id="node-input-cache">
+                <span data-i18n="%s.cache"></span>
+            </label>
+        </div>
+    </div>""" % name
+    new = """            <label class="ccu-checkbox">
+                <input type="checkbox" id="node-input-cache">
+                <span data-i18n="%s.cache"></span>
+            </label>
+
+            <label class="ccu-checkbox">
+                <input type="checkbox" id="node-input-certainOnly">
+                <span data-i18n="%s.certainOnly"></span>
+            </label>
+        </div>
+    </div>""" % (name, name)
+    assert old in s, "checkbox block in " + p
+    s = s.replace(old, new, 1)
+
+    io.open(p, "w", encoding="utf-8", newline="\n").write(s)
+    print("patched", p)
+
+# --- locales ---------------------------------------------------------------
+LABELS = {
+    "de": "Unsichere Werte verwerfen",
+    "en-US": "Discard uncertain values",
+}
+for loc, label in LABELS.items():
+    for name in ("ccu-value", "ccu-rpc-event"):
+        p = "nodes/locales/%s/%s.json" % (loc, name)
+        d = json.load(io.open(p, encoding="utf-8"))
+        d[name]["certainOnly"] = label
+        io.open(p, "w", encoding="utf-8", newline="\n").write(
+            json.dumps(d, indent=2, ensure_ascii=False) + "\n"
+        )
+        print("locale", p)