node-red-contrib-ccu 4.1.0 → 4.3.0

package/nodes/ccu-homeassistant.html

@@ -0,0 +1,334 @@
+<script type="text/javascript">
+    RED.nodes.registerType('ccu-homeassistant', {
+        category: 'ccu',
+        defaults: {
+            name: {value: ''},
+            ccuConfig: {value: 'localhost', type: 'ccu-connection', required: true},
+            mqttNode: {value: '', required: true},
+            prefix: {value: 'homeassistant'},
+            generic: {value: true},
+            devices: {value: {}},
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: 'ccu.png',
+        color: '#c2d5e4',
+        paletteLabel: 'home assistant',
+        align: 'right',
+        label() {
+            return this.name || 'home assistant';
+        },
+        labelStyle() {
+            return this.name ? 'node_label_italic' : '';
+        },
+        oneditprepare() {
+            const that = this;
+            if (!this.devices) {
+                this.devices = {};
+            }
+
+            const $ccuConfig = $('#node-input-ccuConfig');
+            const $mqttNode = $('#node-input-mqttNode');
+            const $devices = $('#ha-devices');
+            const $filter = $('#ha-filter');
+            const $spinner = $('#ha-spinner');
+            const $message = $('#ha-message');
+
+            function escape(text) {
+                return $('<div>')
+                    .text(String(text === undefined || text === null ? '' : text))
+                    .html();
+            }
+
+            // the ccu-mqtt nodes of the flows whose topics this node reuses
+            function loadMqttNodes() {
+                const config = $ccuConfig.val();
+                const wanted = $mqttNode.val() || that.mqttNode;
+                $mqttNode.empty();
+                RED.nodes.eachNode((n) => {
+                    if (n.type !== 'ccu-mqtt') {
+                        return;
+                    }
+
+                    if (config && config !== '_ADD_' && n.ccuConfig !== config) {
+                        return;
+                    }
+
+                    const label = (n.name || 'mqtt') + '  (' + (n.topicOutputEvent || '') + ')';
+                    $mqttNode.append($('<option>').val(n.id).text(label));
+                });
+                if ($mqttNode.children().length === 0) {
+                    $mqttNode.append($('<option>').val('').text('— no ccu-mqtt node for this CCU —'));
+                }
+
+                if (wanted && $mqttNode.find('option[value="' + wanted + '"]').length > 0) {
+                    $mqttNode.val(wanted);
+                }
+            }
+
+            function applyFilter() {
+                const needle = String($filter.val() || '').toLowerCase();
+                $devices.find('tr.ha-device-row').each(function () {
+                    const $row = $(this);
+                    const haystack = $row.data('search');
+                    $row.toggle(!needle || haystack.indexOf(needle) !== -1);
+                });
+            }
+
+            function renderDevices(data) {
+                $devices.empty();
+                const addresses = Object.keys(data).sort((a, b) => {
+                    const na = data[a].name || a;
+                    const nb = data[b].name || b;
+                    return na.localeCompare(nb);
+                });
+                if (addresses.length === 0) {
+                    $message.text('No devices known yet — is the CCU connection deployed and initialized?').show();
+                    return;
+                }
+
+                addresses.forEach((addr) => {
+                    const dev = data[addr];
+                    const entry = that.devices[addr];
+                    const checked = Boolean(entry && entry.enabled === true);
+                    const search = [dev.name, addr, dev.type, dev.iface].join(' ').toLowerCase();
+                    const $row = $(
+                        '<tr class="ha-device-row">' +
+                            '<td class="ha-enabled"><input type="checkbox" class="ha-device" data-addr="' +
+                            escape(addr) +
+                            '"' +
+                            (checked ? ' checked' : '') +
+                            '></td>' +
+                            '<td class="ha-text" title="' +
+                            escape(dev.name) +
+                            '">' +
+                            escape(dev.name || addr) +
+                            '</td>' +
+                            '<td class="ha-text ha-small">' +
+                            escape(addr) +
+                            '</td>' +
+                            '<td class="ha-text ha-small">' +
+                            escape(dev.type) +
+                            '</td>' +
+                            '<td class="ha-text ha-small">' +
+                            escape(dev.iface) +
+                            '</td>' +
+                            '</tr>',
+                    );
+                    $row.data('search', search);
+                    $devices.append($row);
+                });
+                applyFilter();
+            }
+
+            let loading = false;
+            function loadDevices() {
+                const config = $ccuConfig.val();
+                $message.hide();
+                if (!config || config === '_ADD_') {
+                    $devices.empty();
+                    $message.text('Select a CCU connection first.').show();
+                    return;
+                }
+
+                if (loading) {
+                    return;
+                }
+
+                loading = true;
+                $spinner.show();
+                $.getJSON('ccu?config=' + config + '&type=devices')
+                    .done((data) => {
+                        renderDevices(data || {});
+                    })
+                    .fail(() => {
+                        $devices.empty();
+                        $message.text('CCU connection not ready — deploy the CCU config node first, then reopen.').show();
+                    })
+                    .always(() => {
+                        loading = false;
+                        $spinner.hide();
+                    });
+            }
+
+            $ccuConfig.on('change', () => {
+                loadMqttNodes();
+                loadDevices();
+            });
+            $filter.on('input keyup', applyFilter);
+            $('#ha-enable-all').on('click', () => {
+                $devices.find('tr.ha-device-row:visible input.ha-device').prop('checked', true);
+            });
+            $('#ha-disable-all').on('click', () => {
+                $devices.find('tr.ha-device-row:visible input.ha-device').prop('checked', false);
+            });
+
+            loadMqttNodes();
+            loadDevices();
+        },
+        oneditsave() {
+            const previous = this.devices || {};
+            const devices = {};
+            $('#ha-devices input.ha-device').each(function () {
+                const addr = $(this).data('addr');
+                if ($(this).is(':checked')) {
+                    devices[addr] = {enabled: true};
+                } else if (previous[addr]) {
+                    // was known before → publish a removal so Home Assistant forgets it
+                    devices[addr] = {enabled: false};
+                }
+            });
+            // keep entries of devices that were not listed this time (interface
+            // temporarily down) instead of dropping them
+            Object.keys(previous).forEach((addr) => {
+                if (!(addr in devices)) {
+                    devices[addr] = previous[addr];
+                }
+            });
+            this.devices = devices;
+        },
+    });
+</script>
+
+<script type="text/x-red" data-template-name="ccu-homeassistant">
+    <style>
+        label.ccu-checkbox {
+            display: block !important;
+            width: auto !important;
+        }
+        label.ccu-checkbox input {
+            width: auto !important;
+            margin-top: -3px !important;
+        }
+        #ha-devices {
+            width: 100%;
+            border-collapse: collapse;
+        }
+        #ha-devices td {
+            padding: 1px 4px;
+            border-bottom: 1px solid #eee;
+        }
+        #ha-devices td.ha-text {
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            max-width: 220px;
+        }
+        #ha-devices td.ha-small {
+            font-size: 10px;
+            color: #666;
+            max-width: 120px;
+        }
+        #ha-devices td.ha-enabled {
+            width: 20px;
+        }
+        #ha-devices input.ha-device {
+            width: auto !important;
+            margin: 0 !important;
+        }
+        #ha-toolbar {
+            display: flex;
+            gap: 8px;
+            align-items: center;
+            margin-bottom: 6px;
+        }
+        #ha-toolbar input {
+            flex: 1;
+            width: auto !important;
+        }
+        #ha-message {
+            display: none;
+            color: #888;
+            font-style: italic;
+        }
+    </style>
+    <div class="form-row">
+        <label for="node-input-name"><i class="icon-bookmark"></i> Name</label>
+        <input type="text" id="node-input-name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-ccuConfig"><i class="icon-global"></i> CCU</label>
+        <input type="text" id="node-input-ccuConfig">
+    </div>
+    <div class="form-row">
+        <label for="node-input-mqttNode"><i class="fa fa-exchange"></i> MQTT node</label>
+        <select id="node-input-mqttNode" style="width: 70%"></select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-prefix"><i class="fa fa-home"></i> Prefix</label>
+        <input type="text" id="node-input-prefix" placeholder="homeassistant">
+    </div>
+    <div class="form-row">
+        <label for="node-input-generic"></label>
+        <div style="width: 70%; display: inline-block; vertical-align: text-top;">
+            <label class="ccu-checkbox">
+                <input type="checkbox" id="node-input-generic">
+                <span>Also create (disabled) entities for all other datapoints</span>
+            </label>
+        </div>
+    </div>
+
+    <div class="form-row">
+        <b>Devices published to Home Assistant</b>
+    </div>
+    <div class="form-row">
+        <div id="ha-toolbar">
+            <input type="text" id="ha-filter" placeholder="filter by name, address, type">
+            <button type="button" class="red-ui-button red-ui-button-small" id="ha-enable-all">check all</button>
+            <button type="button" class="red-ui-button red-ui-button-small" id="ha-disable-all">uncheck all</button>
+            <img id="ha-spinner" src="red/images/spin.svg" style="display: none; height: 16px;">
+        </div>
+        <div id="ha-message"></div>
+        <div style="max-height: 320px; overflow-y: auto;">
+            <table id="ha-devices"></table>
+        </div>
+    </div>
+</script>
+
+<script type="text/x-red" data-help-name="ccu-homeassistant" lang="de-DE">
+    <p>Veröffentlicht Home-Assistant-MQTT-Discovery-Konfigurationen für ausgewählte Geräte.</p>
+    <p>Der Node ist ein Begleiter zum <b>ccu-mqtt</b>-Node: er übernimmt dessen Topic-Vorlagen und
+    Payload-Format, so dass die Discovery-Konfigurationen auf die Topics zeigen, die ccu-mqtt bereits
+    veröffentlicht bzw. entgegennimmt. Status und Befehle laufen weiterhin über ccu-mqtt.</p>
+    <h3>Verkabelung</h3>
+    <p>Den Ausgang mit demselben <b>mqtt out</b>-Node verbinden wie den ccu-mqtt-Node. Der Node sendet
+    <code>msg.topic</code>, <code>msg.payload</code> und <code>msg.retain</code>.</p>
+    <h3>Geräteauswahl</h3>
+    <p>Nur angehakte Geräte werden an Home Assistant gemeldet (ein HA-Gerät pro Homematic-Gerät).
+    Wird ein zuvor angehaktes Gerät abgehakt, sendet der Node beim nächsten Deploy eine leere
+    Konfiguration, die das Gerät in Home Assistant entfernt.</p>
+    <h3>Entitäten</h3>
+    <p>Schalter, Dimmer (light), Rollladen/Jalousie (cover), Thermostate (climate), Kontakte/Bewegung/
+    Rauch/Wasser (binary_sensor), Tasten (event), KeyMatic (lock), Energie/Wetter (sensor). Mit der
+    Option <i>weitere Datenpunkte</i> werden alle übrigen Datenpunkte als standardmäßig deaktivierte
+    Entitäten mitgeliefert.</p>
+    <h3>Eingang</h3>
+    <p>Jede eingehende Nachricht veröffentlicht die Discovery-Konfigurationen erneut.</p>
+    <h3>Voraussetzungen</h3>
+    <p>Home Assistant ≥ 2024.11 (gerätebasierte Discovery). Die Verfügbarkeit der Geräte wird aus dem
+    UNREACH-Datenpunkt des Wartungskanals abgeleitet.</p>
+</script>
+
+<script type="text/x-red" data-help-name="ccu-homeassistant" lang="en-US">
+    <p>Publishes Home Assistant MQTT discovery configurations for selected devices.</p>
+    <p>The node is a companion to the <b>ccu-mqtt</b> node: it reuses that node's topic templates and
+    payload format, so the discovery configs point at the topics ccu-mqtt already publishes and
+    consumes. State and commands keep flowing through ccu-mqtt.</p>
+    <h3>Wiring</h3>
+    <p>Connect the output to the same <b>mqtt out</b> node as the ccu-mqtt node. The node sends
+    <code>msg.topic</code>, <code>msg.payload</code> and <code>msg.retain</code>.</p>
+    <h3>Device selection</h3>
+    <p>Only checked devices are announced to Home Assistant (one HA device per Homematic device).
+    Unchecking a previously checked device publishes an empty config on the next deploy, which
+    removes the device from Home Assistant.</p>
+    <h3>Entities</h3>
+    <p>Switches, dimmers (light), blinds/shutters (cover), thermostats (climate), contacts/motion/
+    smoke/water (binary_sensor), keys (event), KeyMatic (lock), energy/weather (sensor). With the
+    <i>other datapoints</i> option every remaining datapoint is included as an entity that is
+    disabled by default.</p>
+    <h3>Input</h3>
+    <p>Any incoming message republishes the discovery configs.</p>
+    <h3>Requirements</h3>
+    <p>Home Assistant ≥ 2024.11 (device-based discovery). Device availability is derived from the
+    UNREACH datapoint of the maintenance channel.</p>
+</script>

package/nodes/ccu-homeassistant.js

@@ -0,0 +1,272 @@
+const path = require('path');
+
+const statusHelper = require(path.join(__dirname, '/lib/status.js'));
+const {topicReplace} = require('./lib/topic.js');
+const {discoveryMessages, removalMessage} = require('./lib/hadiscovery.js');
+
+const pkg = require(path.join(__dirname, '..', 'package.json'));
+
+const READY_INTERVAL = 5000;
+const READY_ATTEMPTS = 60;
+
+/**
+ * Home Assistant MQTT auto-discovery for a checkbox-selected set of devices (B-16).
+ *
+ * Companion to a ccu-mqtt node: reuses its topic templates and payload format, so
+ * the discovery configs point at the topics ccu-mqtt already publishes/consumes.
+ * The node itself only emits (a) the retained discovery configs — wire its output
+ * to the same mqtt-out node as the ccu-mqtt node — and (b) the aggregate PRESS
+ * event Home Assistant's event entities need.
+ */
+module.exports = function (RED) {
+    class CcuHomeAssistantNode {
+        constructor(config) {
+            RED.nodes.createNode(this, config);
+
+            this.ccu = RED.nodes.getNode(config.ccuConfig);
+
+            if (!this.ccu) {
+                return;
+            }
+
+            this.mqttNodeId = config.mqttNode;
+            this.prefix = String(config.prefix || 'homeassistant').replace(/\/+$/, '');
+            this.generic = config.generic !== false;
+            this.devices = config.devices || {};
+            this.selected = Object.keys(this.devices).filter(
+                (a) => this.devices[a] && this.devices[a].enabled === true,
+            );
+            this.removed = Object.keys(this.devices).filter(
+                (a) => this.devices[a] && this.devices[a].enabled === false,
+            );
+            this.selectedSet = new Set(this.selected);
+
+            this.ccu.register(this);
+
+            this.on('input', (message, send, done) => {
+                // any message republishes the discovery configs
+                this.publish(true);
+                if (done) {
+                    done();
+                }
+            });
+
+            this.idEventSubscription = this.ccu.subscribe({cache: false}, (message) => {
+                this.event(message);
+            });
+
+            this.on('close', (done) => {
+                this._destructor(done);
+            });
+
+            this.attempts = 0;
+            this.showStatus({fill: 'grey', shape: 'ring', text: 'waiting for CCU'});
+            this.readyTimer = setTimeout(() => this.whenReady(), 1000);
+        }
+
+        _destructor(done) {
+            this.trace('ccu-homeassistant close');
+            clearTimeout(this.readyTimer);
+            this.ccu.unsubscribe(this.idEventSubscription);
+            this.ccu.deregister(this, done);
+        }
+
+        /** connection status pushed by ccu-connection: only override while disconnected */
+        setStatus(data) {
+            const ifaceStatus = (data && data.ifaceStatus) || {};
+            const connected = Object.keys(ifaceStatus).some((iface) => ifaceStatus[iface]);
+            if (connected) {
+                this.status(this.ownStatus || {fill: 'grey', shape: 'ring', text: 'waiting for CCU'});
+            } else {
+                statusHelper(this, data);
+            }
+        }
+
+        /** the node's own status (device count etc.), restored after reconnects */
+        showStatus(status) {
+            this.ownStatus = status;
+            this.status(status);
+        }
+
+        /** the referenced ccu-mqtt node, or null with a red status */
+        mqtt() {
+            const node = this.mqttNodeId && RED.nodes.getNode(this.mqttNodeId);
+            if (!node || node.type !== 'ccu-mqtt') {
+                this.showStatus({fill: 'red', shape: 'ring', text: 'ccu-mqtt node not found'});
+                return null;
+            }
+
+            if (node.ccu !== this.ccu) {
+                this.showStatus({fill: 'red', shape: 'ring', text: 'ccu-mqtt node uses another CCU'});
+                return null;
+            }
+
+            return node;
+        }
+
+        /** metadata, names and descriptions of every selected device are there */
+        ready() {
+            const {ccu} = this;
+            if (!ccu.metadata || !ccu.metadata.devices || !ccu.channelNames) {
+                return false;
+            }
+
+            if (Object.keys(ccu.channelNames).length === 0) {
+                return false;
+            }
+
+            return this.selected.every((address) => {
+                const iface = ccu.findIface(address);
+                const device = iface && ccu.metadata.devices[iface] && ccu.metadata.devices[iface][address];
+                if (!device) {
+                    // not (yet) known — do not wait forever for an unpaired device
+                    return true;
+                }
+
+                return (device.CHILDREN || []).every((ch) => {
+                    const channel = ccu.metadata.devices[iface][ch];
+                    if (!channel) {
+                        return true;
+                    }
+
+                    // cached = key present; a legitimately empty VALUES paramset ({}) counts as
+                    // cached, only a missing key means the fetch is still pending
+                    const key = ccu.paramsetName(iface, channel, 'VALUES');
+                    if (ccu.paramsetDescriptions[key] !== undefined) {
+                        return true;
+                    }
+
+                    ccu.getParamsetDescription(iface, channel, 'VALUES'); // queues the fetch
+                    return false;
+                });
+            });
+        }
+
+        whenReady() {
+            this.attempts += 1;
+            if (this.ready() || this.attempts >= READY_ATTEMPTS) {
+                if (!this.ready()) {
+                    this.warn(
+                        'CCU metadata still incomplete after ' + this.attempts + ' attempts, publishing what is there',
+                    );
+                }
+
+                this.publish(false);
+                return;
+            }
+
+            this.readyTimer = setTimeout(() => this.whenReady(), READY_INTERVAL);
+        }
+
+        /** the message-shaped object the ccu-mqtt topic templates are rendered against */
+        topicMessage(iface, channel, datapoint) {
+            const {ccu} = this;
+            const devices = (ccu.metadata && ccu.metadata.devices && ccu.metadata.devices[iface]) || {};
+            const channelMeta = devices[channel] || {};
+            const device = channelMeta.PARENT || String(channel).split(':')[0];
+            return {
+                ccu: ccu.host,
+                iface,
+                device,
+                deviceName: ccu.channelNames[device],
+                deviceType: devices[device] && devices[device].TYPE,
+                channel,
+                // same fallback as ccu-mqtt: unnamed channels use their address
+                channelName: ccu.channelNames[channel] || channel,
+                channelNameOrAddress: channel,
+                channelType: channelMeta.TYPE,
+                channelIndex: Number.parseInt(String(channel).split(':')[1], 10),
+                datapoint,
+                datapointName: iface + '.' + channel + '.' + datapoint,
+            };
+        }
+
+        publish(manual) {
+            const mqtt = this.mqtt();
+            if (!mqtt) {
+                return;
+            }
+
+            const {ccu} = this;
+            const ctx = {
+                prefix: this.prefix,
+                origin: {name: pkg.name, sw: pkg.version, url: pkg.homepage},
+                jsonPayloads: mqtt.payloadOutput !== 'plain',
+                generic: this.generic,
+                devices: ccu.metadata.devices,
+                selected: this.selected,
+                description: (iface, address) => {
+                    const device = ccu.metadata.devices[iface] && ccu.metadata.devices[iface][address];
+                    return device && ccu.getParamsetDescription(iface, device, 'VALUES');
+                },
+                channelName: (address) => ccu.channelNames[address],
+                rooms: (address) => ccu.channelRooms && ccu.channelRooms[address],
+                statusTopicFor: (iface, address, dp) =>
+                    topicReplace(mqtt.topicOutputEvent, this.topicMessage(iface, address, dp)),
+                setTopicFor: (iface, address, dp) =>
+                    topicReplace(mqtt.topicInputSetValue, this.topicMessage(iface, address, dp)),
+            };
+
+            const {messages, missing, empty} = discoveryMessages(ctx);
+
+            for (const address of this.removed) {
+                const {topic, payload} = removalMessage(this.prefix, address);
+                this.send({topic, payload, retain: true});
+            }
+
+            for (const {topic, payload} of messages) {
+                this.send({topic, payload, retain: true});
+            }
+
+            if (missing.length > 0) {
+                this.warn('selected devices not found on the CCU: ' + missing.join(', '));
+            }
+
+            if (empty.length > 0) {
+                this.debug('selected devices without any Home Assistant entity: ' + empty.join(', '));
+            }
+
+            this.log(
+                (manual ? 're' : '') +
+                    'published discovery for ' +
+                    messages.length +
+                    ' devices' +
+                    (this.removed.length > 0 ? ', removed ' + this.removed.length : ''),
+            );
+            this.showStatus({
+                fill: missing.length > 0 ? 'yellow' : 'green',
+                shape: 'dot',
+                text: messages.length + ' devices' + (missing.length > 0 ? ', ' + missing.length + ' missing' : ''),
+            });
+        }
+
+        /** key presses: Home Assistant's event entity wants one topic per key → <channel>/PRESS */
+        event(message) {
+            if (!message.datapoint || !message.datapoint.startsWith('PRESS_') || !message.payload) {
+                return;
+            }
+
+            if (!this.selectedSet.has(message.device)) {
+                return;
+            }
+
+            const mqtt = this.mqttNodeId && RED.nodes.getNode(this.mqttNodeId);
+            if (!mqtt || typeof mqtt.output !== 'function') {
+                return;
+            }
+
+            const press = RED.util.cloneMessage(message);
+            press.payload = message.datapoint;
+            press.value = message.datapoint;
+            press.datapoint = 'PRESS';
+            press.datapointName = String(message.datapointName || '').replace(/PRESS_\w+$/, 'PRESS');
+            if (!press.channelName) {
+                press.channelName = press.channel;
+            }
+
+            this.send({topic: topicReplace(mqtt.topicOutputEvent, press), payload: mqtt.output(press), retain: false});
+        }
+    }
+
+    RED.nodes.registerType('ccu-homeassistant', CcuHomeAssistantNode);
+};

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">