node-red-contrib-ccu 4.2.0 → 4.3.0

package/nodes/ccu-connection.js

@@ -9,6 +9,7 @@ const {castValue, castSysvar} = require('./lib/cast.js');
 const {combinedParameterValue} = require('./lib/combined.js');
 const {createMessage} = require('./lib/message.js');
 const {topicReplace} = require('./lib/topic.js');
+const {isLocalCcu} = require('./lib/localccu.js');
 const {bestMatch} = require('./lib/similarity.js');
 const nextport = require('./lib/nextport.js');
 const hmDiscover = require('./lib/discover.js');
@@ -407,15 +408,13 @@ module.exports = function (RED) {
 
             this.checkDuplicateConfig(config);
 
-            this.isLocal = false;
-            if (config.host.startsWith('127.') || config.host === 'localhost') {
-                try {
-                    const rfdConf = fs.readFileSync('/etc/lighttpd/conf.d/proxy.conf').toString();
-                    if (rfdConf.match(/"port"\s+=>\s+32001/)) {
-                        this.logger.info('local connection on ccu >= v3.41 detected');
-                        this.isLocal = true;
-                    }
-                } catch {}
+            // B-4: this used to grep /etc/lighttpd/conf.d/proxy.conf for the
+            // direct port. That file is a bare include on current firmware, so
+            // the check never matched and every local install went through the
+            // proxy. Ask the kernel for a listener instead.
+            this.isLocal = isLocalCcu(config.host);
+            if (this.isLocal) {
+                this.logger.info('local connection on ccu >= v3.41 detected');
             }
 
             this.ifaceTypes = {
@@ -529,6 +528,10 @@ module.exports = function (RED) {
             this.rpcBinPort = Number.parseInt(config.rpcBinPort, 10);
             this.rpcXmlPort = Number.parseInt(config.rpcXmlPort, 10);
             this.rpcPingTimeout = Number.parseInt(config.rpcPingTimeout, 10) || 60;
+            // #44: opt out of the periodic ping/timeout supervision. Off means
+            // no pings and no timeout-triggered re-init for this connection -
+            // reconnecting after a CCU restart is then up to the CCU.
+            this.rpcPingEnabled = config.rpcPing === undefined ? true : Boolean(config.rpcPing);
             this.rpcPingTimer = {};
             this.ifaceStatus = {};
             this.serverError = {};
@@ -539,6 +542,10 @@ module.exports = function (RED) {
 
             this.regaEnabled = config.regaEnabled;
             this.regaPollEnabled = config.regaPoll;
+            // #167: minutes between re-reads of channel names, rooms and
+            // functions. 0 switches it off.
+            this.regaMetaInterval =
+                config.regaMetaInterval === undefined ? 15 : Number.parseInt(config.regaMetaInterval, 10) || 0;
             this.regaInterval = Number.parseInt(config.regaInterval, 10);
             this.hadTimeout = new Set();
 
@@ -632,6 +639,7 @@ module.exports = function (RED) {
             });
 
             if (config.regaEnabled) {
+                this.lastRegaDataRefresh = now();
                 this.getRegaData().then(() => {
                     this.regaPoll();
                     this.initIfaces(config);
@@ -1084,7 +1092,14 @@ module.exports = function (RED) {
                             const ts = dp.ts;
                             const [iface, channel, datapoint] = dp.name.split('.');
                             if (this.enabledIfaces.includes(iface) && datapoint) {
-                                if (['RSSI_DEVICE', 'RSSI_PEER'].includes(datapoint)) {
+                                if (
+                                    ['RSSI_DEVICE', 'RSSI_PEER'].includes(datapoint) &&
+                                    typeof dp.value === 'number' &&
+                                    dp.value > 127
+                                ) {
+                                    // the ReGa reports the unsigned byte; without
+                                    // the guard an already-signed value or the 0
+                                    // for "never received" became -318 / -256 (#183)
                                     dp.value -= 256;
                                 }
 
@@ -1320,7 +1335,12 @@ module.exports = function (RED) {
         regaPoll() {
             //this.logger.trace('regaPoll');
             if (this.regaPollPending) {
-                this.logger.warn('rega poll already pending');
+                // #166: writing several variables at once used to lose all but
+                // the first immediate re-poll, so their new values only showed
+                // up at the next scheduled one (30 s by default). Remember the
+                // request and run exactly one more poll afterwards.
+                this.logger.debug('rega poll already pending, will repeat');
+                this.regaPollAgain = true;
             } else {
                 this.regaPollPending = true;
                 clearTimeout(this.regaPollTimeout);
@@ -1342,6 +1362,14 @@ module.exports = function (RED) {
 
                         this.firstRegaPollDone = true;
                         this.regaPollPending = false;
+
+                        if (this.regaPollAgain && !this.cancelRegaPoll) {
+                            this.regaPollAgain = false;
+                            this.regaPoll();
+                        } else {
+                            this.regaPollAgain = false;
+                            this.refreshRegaDataIfDue();
+                        }
                     });
             }
         }
@@ -1481,6 +1509,35 @@ module.exports = function (RED) {
          * Poll ReGaHSS variables and call subscription callbacks
          * @returns {Promise}
          */
+        /**
+         * Re-read the ReGa metadata that only ever got fetched once, in the
+         * constructor: channel names, rooms and functions. A room or function
+         * added in the CCU WebUI was invisible until the flow was redeployed
+         * (#167). Cheap enough for a slow schedule - three small scripts.
+         * @returns {Promise<any>}
+         */
+        refreshRegaData() {
+            this.lastRegaDataRefresh = now();
+            this.logger.debug('refreshRegaData');
+            return this.getRegaChannels()
+                .then(() => this.getRegaRooms())
+                .then(() => this.getRegaFunctions())
+                .then(() => this.saveRegadata())
+                .catch((error) => this.logger.error('refreshRegaData', error));
+        }
+
+        /** Runs refreshRegaData() when the configured interval has elapsed. */
+        refreshRegaDataIfDue() {
+            if (!this.regaMetaInterval || this.cancelRegaPoll) {
+                return;
+            }
+
+            const elapsed = now() - (this.lastRegaDataRefresh || 0);
+            if (elapsed >= this.regaMetaInterval * 60000) {
+                this.refreshRegaData();
+            }
+        }
+
         getRegaVariables() {
             return new Promise((resolve, reject) => {
                 this.logger.debug('getRegaVariables');
@@ -1766,6 +1823,10 @@ module.exports = function (RED) {
          * @param iface
          */
         rpcCheckInit(iface) {
+            if (!this.rpcPingEnabled) {
+                return;
+            }
+
             if (!this.metadata.devices[iface] || !Object.keys(this.metadata.devices[iface]).length > 0) {
                 return;
             }
@@ -2509,6 +2570,7 @@ module.exports = function (RED) {
                 'change',
                 'cache',
                 'stable',
+                'uncertain',
                 'iface',
                 'device',
                 'deviceType',
@@ -2714,6 +2776,15 @@ module.exports = function (RED) {
             let matchChange;
             let matchStable;
 
+            // Checked before the attribute loop below: that loop may break
+            // early for a whitelisted datapoint, and this decision has to be
+            // made for every message regardless of key order. Only present in
+            // the filter when a node opted in, so existing subscriptions keep
+            // receiving values the ReGa could not timestamp (#96).
+            if (filter && filter.uncertain === false && message.uncertain) {
+                return false;
+            }
+
             if (filter) {
                 const arrayAttr = Object.keys(filter);
 
@@ -2753,6 +2824,11 @@ module.exports = function (RED) {
                         continue;
                     }
 
+                    if (attr === 'uncertain') {
+                        // already decided above, and not a value to compare
+                        continue;
+                    }
+
                     if (this.callbackWhitelists[message.datapointName].has(id)) {
                         if (matchCache && matchChange && matchStable) {
                             break;

package/nodes/ccu-display.js

@@ -1,6 +1,19 @@
 const path = require('path');
 
 const statusHelper = require(path.join(__dirname, '/lib/status.js'));
+const {effectiveConfig} = require(path.join(__dirname, '/lib/dynconfig.js'));
+
+/** Everything a message may override through msg.config (B-2, #80 #185). */
+const DYNAMIC_KEYS = [
+    'iface',
+    'channel',
+    'channelType',
+    'sound',
+    'repeat',
+    'pause',
+    'signal',
+    ...[1, 2, 3, 4, 5, 6].flatMap((i) => ['line' + i, 'color' + i, 'icon' + i, 'disable' + i]),
+];
 
 module.exports = function (RED) {
     class CcuDisplay {
@@ -143,43 +156,46 @@ module.exports = function (RED) {
             }
 
             this.on('input', (message, send, done) => {
+                // msg.line1 & co. keep working as before; msg.config
+                // additionally reaches the channel and the EP-WM55 settings
+                const {config: effective} = effectiveConfig(config, message, DYNAMIC_KEYS);
                 let payload = '0x02';
 
                 let countLines = 6; // HM-Dis-WM55
-                if (config.channelType === 'HM-Dis-EP-WM55') {
+                if (effective.channelType === 'HM-Dis-EP-WM55') {
                     payload += ',0x0A';
                     countLines = 3;
                 }
 
                 for (let i = 1; i <= countLines; i++) {
-                    if (!message['disable' + i] && !config['disable' + i]) {
-                        payload += convertString(message['line' + i] || config['line' + i]);
-                        if (config.channelType === 'HM-Dis-WM55') {
-                            payload += convertColor(message['color' + i] || config['color' + i]);
+                    if (!message['disable' + i] && !effective['disable' + i]) {
+                        payload += convertString(message['line' + i] || effective['line' + i]);
+                        if (effective.channelType === 'HM-Dis-WM55') {
+                            payload += convertColor(message['color' + i] || effective['color' + i]);
                         }
 
-                        payload += convertIcon(message['icon' + i] || config['icon' + i]);
+                        payload += convertIcon(message['icon' + i] || effective['icon' + i]);
                     }
 
                     payload += ',0x0A';
                 }
 
-                if (config.channelType === 'HM-Dis-EP-WM55') {
-                    if (config.sound) {
-                        payload += ',0x14,' + config.sound + ',0x1C';
+                if (effective.channelType === 'HM-Dis-EP-WM55') {
+                    if (effective.sound) {
+                        payload += ',0x14,' + effective.sound + ',0x1C';
                     }
 
-                    payload += ',' + config.repeat + ',0x1D,' + config.pause + ',0x16';
+                    payload += ',' + effective.repeat + ',0x1D,' + effective.pause + ',0x16';
 
-                    if (config.signal) {
-                        payload += ',' + config.signal;
+                    if (effective.signal) {
+                        payload += ',' + effective.signal;
                     }
                 }
 
                 payload += ',0x03';
 
                 this.ccu
-                    .setValue(config.iface, config.channel, 'SUBMIT', payload)
+                    .setValue(effective.iface, effective.channel, 'SUBMIT', payload)
                     .then(() => {
                         done();
                     })

package/nodes/ccu-get-value.html

@@ -195,7 +195,9 @@
                     arr.sort((a, b) => a.localeCompare(b));
                     $nodeInputChannel.autocomplete('option', 'source', arr);
 
-                    if (!data[$nodeInputChannel.val().split(' ')[0]]) {
+                    // ${ENV} placeholders are substituted by Node-RED before the node is
+                    // constructed (subflow parameters, #158) - do not clear them
+                    if (!/^\$\{[^}]+\}$/.test($nodeInputChannel.val()) && !data[$nodeInputChannel.val().split(' ')[0]]) {
                         $nodeInputChannel.val('');
                         $nodeInputDatapoint.val('');
                     }

package/nodes/ccu-mqtt.html

@@ -10,6 +10,7 @@
 
             topicOutputEvent: {value: 'hm/status/${channelName}/${datapoint}'},  
             topicInputSetValue: {value: 'hm/set/${channelNameOrAddress}/${datapoint}'},  
+            topicInputGet: {value: 'hm/get/${channelNameOrAddress}/${datapoint}'},  
 
             topicOutputSysvar: {value: 'hm/status/${name}'},  
             topicInputSysvar: {value: 'hm/set/${name}'},  
@@ -17,7 +18,7 @@
             topicInputPutParam: {value: 'hm/paramset/${channelNameOrAddress}/${paramset}/${param}'},  
             topicInputPutParamset: {value: 'hm/paramset/${channelNameOrAddress}/${paramset}'},  
 
-            topicInputRpc: {value: 'hm/rpc/${iface}/${method}/${command}/${callid}'},  
+            topicInputRpc: {value: 'hm/rpc/${iface}/${method}/${callid}'},  
             topicOutputRpc: {value: 'hm/response/${callid}'},  
 
             topicCounters: {value: 'hm/status/counter/${iface}/${rxtx}'},  
@@ -36,6 +37,20 @@
         labelStyle() {
             return this.name ? 'node_label_italic' : '';
         },
+        oneditprepare() {
+            // The RPC command was never implemented, so its topic template
+            // carried a meaningless ${command} segment. Nothing can have
+            // depended on it - migrate nodes that still hold the old default.
+            if (this.topicInputRpc === 'hm/rpc/${iface}/${method}/${command}/${callid}') {
+                this.topicInputRpc = 'hm/rpc/${iface}/${method}/${callid}';
+                $('#node-input-topicInputRpc').val(this.topicInputRpc);
+            }
+
+            if (typeof this.topicInputGet === 'undefined') {
+                this.topicInputGet = 'hm/get/${channelNameOrAddress}/${datapoint}';
+                $('#node-input-topicInputGet').val(this.topicInputGet);
+            }
+        },
         oneditsave() {
         }
     });
@@ -84,6 +99,10 @@
         <label for="node-input-topicInputSetValue">setValue</label>
         <input type="text" id="node-input-topicInputSetValue">
     </div>
+    <div class="form-row">
+        <label for="node-input-topicInputGet">get</label>
+        <input type="text" id="node-input-topicInputGet">
+    </div>
     <div class="form-row">
         <label for="node-input-topicOutputSysvar">Sysvar/Program Change</label>
         <input type="text" id="node-input-topicOutputSysvar">
@@ -100,16 +119,14 @@
         <label for="node-input-topicInputPutParamset">putParamset</label>
         <input type="text" id="node-input-topicInputPutParamset">
     </div>
-    <!--
     <div class="form-row">
         <label for="node-input-topicInputRpc">RPC</label>
         <input type="text" id="node-input-topicInputRpc">
     </div>
     <div class="form-row">
-        <label for="node-input-topicInputRpc">RPC Response</label>
+        <label for="node-input-topicOutputRpc">RPC Response</label>
         <input type="text" id="node-input-topicOutputRpc">
     </div>
-    -->
     <div class="form-row">
         <label for="node-input-topicCounters">Message Counters</label>
         <input type="text" id="node-input-topicCounters">

package/nodes/ccu-mqtt.js

@@ -2,6 +2,7 @@ const path = require('path');
 const mw = require('mqtt-wildcard');
 
 const statusHelper = require(path.join(__dirname, '/lib/status.js'));
+const {castValue} = require(path.join(__dirname, '/lib/cast.js'));
 
 /** HM thermostats: CONTROL_MODE is read-only, the modes are set through actions */
 const HM_MODES = {
@@ -35,7 +36,10 @@ module.exports = function (RED) {
             this.topicInputPutParam = config.topicInputPutParam;
             this.topicInputPutParamset = config.topicInputPutParamset;
 
+            this.topicInputGet = config.topicInputGet;
+
             this.topicInputRpc = config.topicInputRpc;
+            this.topicOutputRpc = config.topicOutputRpc;
 
             this.topicCounters = config.topicCounters;
             this.rxCounters = {};
@@ -179,6 +183,7 @@ module.exports = function (RED) {
             this.debug('input ' + topic + ' ' + JSON.stringify(payload).slice(0, 40));
 
             const topicList = {
+                get: this.topicInputGet,
                 setValue: this.topicInputSetValue,
                 sysvar: this.topicInputSysvar,
                 putParam: this.topicInputPutParam,
@@ -189,7 +194,8 @@ module.exports = function (RED) {
             let command;
             let filter;
             Object.keys(topicList).forEach((key) => {
-                if (!command) {
+                // a topic left empty in the editor disables that command
+                if (!command && topicList[key]) {
                     const parts = topicList[key].split('/');
                     const patternArray = [];
                     const placeholders = [];
@@ -220,29 +226,129 @@ module.exports = function (RED) {
             }
         }
 
-        setValue(filter, payload) {
+        /**
+         * Resolve `channelNameOrAddress` to a channel address and its
+         * interface, reporting the same errors the commands used to report
+         * inline.
+         * @param {object} filter parsed from the topic; `channel` is filled in
+         * @param {boolean} [exact] pass through to findChannel
+         * @returns {string|null} the interface, or null when unresolvable
+         */
+        resolveChannel(filter, exact) {
             if (filter.channelNameOrAddress) {
                 if (this.ccu.channelNames[filter.channelNameOrAddress]) {
                     filter.channel = filter.channelNameOrAddress;
                 } else {
-                    filter.channel = this.ccu.findChannel(filter.channelNameOrAddress, true);
+                    filter.channel = this.ccu.findChannel(filter.channelNameOrAddress, exact);
                 }
 
                 if (!filter.channel) {
                     this.error('channel ' + filter.channelNameOrAddress + ' not found');
-                    return;
+                    return null;
                 }
             }
 
             if (!filter.channel) {
                 this.error('channel undefined');
-                return;
+                return null;
             }
 
             const iface = this.ccu.findIface(filter.channel);
 
             if (!iface) {
                 this.error('no interface found for channel ' + filter.channel);
+                return null;
+            }
+
+            return iface;
+        }
+
+        /**
+         * Republish the last known value of a datapoint on its status topic,
+         * so a flow can ask for a refresh over MQTT instead of waiting for the
+         * next event (#115). An empty datapoint republishes the whole channel.
+         * @param {object} filter
+         */
+        get(filter) {
+            const iface = this.resolveChannel(filter, true);
+            if (!iface) {
+                return;
+            }
+
+            const prefix = iface + '.' + filter.channel + '.';
+            const names = filter.datapoint
+                ? [prefix + filter.datapoint]
+                : Object.keys(this.ccu.values).filter((name) => name.startsWith(prefix));
+
+            if (names.length === 0) {
+                this.error('unknown datapoint ' + prefix + (filter.datapoint || '#'));
+                return;
+            }
+
+            names.forEach((name) => {
+                const value = this.ccu.values[name];
+                if (value) {
+                    this.event({...value});
+                } else {
+                    this.error('unknown datapoint ' + name);
+                }
+            });
+        }
+
+        /**
+         * Call an arbitrary RPC method on an interface and publish the result
+         * (#22). The topic supplies interface, method and a caller-chosen id
+         * that the response topic echoes; the payload is the parameter array
+         * (a single value is accepted and wrapped).
+         * @param {object} filter
+         * @param {*} payload
+         */
+        rpc(filter, payload) {
+            if (!filter.iface) {
+                this.error('interface undefined');
+                return;
+            }
+
+            if (!filter.method) {
+                this.error('method undefined');
+                return;
+            }
+
+            let parameters = payload;
+            if (parameters === undefined || parameters === null || parameters === '') {
+                parameters = [];
+            } else if (!Array.isArray(parameters)) {
+                parameters = [parameters];
+            }
+
+            const respond = (result, error) => {
+                if (!this.topicOutputRpc) {
+                    return;
+                }
+
+                this.send({
+                    topic: this.ccu.topicReplace(this.topicOutputRpc, {
+                        iface: filter.iface,
+                        method: filter.method,
+                        callid: filter.callid,
+                    }),
+                    payload: error ? {error: error.message} : {result},
+                    retain: false,
+                });
+            };
+
+            this.ccu
+                .methodCall(filter.iface, filter.method, parameters)
+                .then((result) => respond(result))
+                .catch((error) => {
+                    this.error(error.message);
+                    respond(undefined, error);
+                });
+        }
+
+        setValue(filter, payload) {
+            const iface = this.resolveChannel(filter, true);
+            if (!iface) {
                 return;
             }
 
@@ -313,28 +419,8 @@ module.exports = function (RED) {
         }
 
         putParam(filter, payload) {
-            if (filter.channelNameOrAddress) {
-                if (this.ccu.channelNames[filter.channelNameOrAddress]) {
-                    filter.channel = filter.channelNameOrAddress;
-                } else {
-                    filter.channel = this.ccu.findChannel(filter.channelNameOrAddress);
-                }
-
-                if (!filter.channel) {
-                    this.error('channel ' + filter.channelNameOrAddress + ' not found');
-                    return;
-                }
-            }
-
-            if (!filter.channel) {
-                this.error('channel undefined');
-                return;
-            }
-
-            const iface = this.ccu.findIface(filter.channel);
-
+            const iface = this.resolveChannel(filter);
             if (!iface) {
-                this.error('no interface found for channel ' + filter.channel);
                 return;
             }
 
@@ -345,11 +431,14 @@ module.exports = function (RED) {
             );
             const paramsetDescription = this.ccu.paramsetDescriptions[psName];
             if (paramsetDescription && paramsetDescription[filter.param]) {
-                if (!paramsetDescription[filter.param].OPERATIONS && 2) {
+                // was `!(OPERATIONS) && 2`, which is always false - the check
+                // never fired and the write went out regardless (B-3)
+                if (!(paramsetDescription[filter.param].OPERATIONS & 2)) {
                     this.error('param ' + filter.param + ' not writeable');
+                    return;
                 }
 
-                payload = this.paramCast(payload, paramsetDescription[filter.param]);
+                payload = castValue(payload, paramsetDescription[filter.param], {clamp: true});
             } else {
                 this.warn('unknown paramset/param ' + filter.paramset + ' ' + filter.param);
             }
@@ -368,28 +457,8 @@ module.exports = function (RED) {
                 return;
             }
 
-            if (filter.channelNameOrAddress) {
-                if (this.ccu.channelNames[filter.channelNameOrAddress]) {
-                    filter.channel = filter.channelNameOrAddress;
-                } else {
-                    filter.channel = this.ccu.findChannel(filter.channelNameOrAddress);
-                }
-
-                if (!filter.channel) {
-                    this.error('channel ' + filter.channelNameOrAddress + ' not found');
-                    return;
-                }
-            }
-
-            if (!filter.channel) {
-                this.error('channel undefined');
-                return;
-            }
-
-            const iface = this.ccu.findIface(filter.channel);
-
+            const iface = this.resolveChannel(filter);
             if (!iface) {
-                this.error('no interface found for channel ' + filter.channel);
                 return;
             }
 
@@ -404,11 +473,17 @@ module.exports = function (RED) {
 
             Object.keys(payload).forEach((parameter) => {
                 if (paramsetDescription && paramsetDescription[parameter]) {
-                    if (!paramsetDescription[parameter].OPERATIONS && 2) {
+                    // was `!(OPERATIONS) && 2` (always false), and the cast
+                    // used paramsetDescription[filter.param], which is
+                    // undefined here - so every value went out uncast (B-3)
+                    if (!(paramsetDescription[parameter].OPERATIONS & 2)) {
                         this.error('param ' + parameter + ' not writeable');
+                        return;
                     }
 
-                    paramset[parameter] = this.paramCast(payload[parameter], paramsetDescription[filter.param]);
+                    paramset[parameter] = castValue(payload[parameter], paramsetDescription[parameter], {
+                        clamp: true,
+                    });
                 } else {
                     this.warn('unknown paramset/param ' + filter.paramset + ' ' + parameter);
                     paramset[parameter] = payload[parameter];
@@ -419,57 +494,6 @@ module.exports = function (RED) {
                 .methodCall(iface, 'putParamset', [filter.channel, filter.paramset, paramset])
                 .catch((error) => this.error(error.message));
         }
-
-        paramCast(value, paramset) {
-            switch (paramset && paramset.TYPE) {
-                case 'BOOL':
-                // Fallthrough by intention
-                case 'ACTION':
-                    // OMG this is so ugly...
-                    if (value === 'false') {
-                        value = false;
-                    } else if (!isNaN(value)) {
-                        // Make sure that the string "0" gets casted to boolean false
-                        value = Number(value);
-                    }
-
-                    value = Boolean(value);
-                    break;
-                case 'FLOAT':
-                    value = Number.parseFloat(value);
-                    if (value < paramset.MIN) {
-                        value = paramset.MIN;
-                    } else if (value > paramset.MAX) {
-                        value = paramset.MAX;
-                    }
-
-                    value = {explicitDouble: value};
-                    break;
-                case 'ENUM':
-                    if (typeof value === 'string') {
-                        if (paramset.ENUM && paramset.ENUM.includes(value)) {
-                            value = paramset.ENUM.indexOf(value);
-                        }
-                    }
-
-                // Fallthrough by intention
-                case 'INTEGER':
-                    value = Number.parseInt(value, 10);
-                    if (value < paramset.MIN) {
-                        value = paramset.MIN;
-                    } else if (value > paramset.MAX) {
-                        value = paramset.MAX;
-                    }
-
-                    break;
-                case 'STRING':
-                    value = String(value);
-                    break;
-                default:
-            }
-
-            return value;
-        }
     }
 
     RED.nodes.registerType('ccu-mqtt', CcuMqttNode);