node-red-contrib-velbus-2026 0.8.1

package/nodes/velbus-sensor/velbus-sensor.js

@@ -0,0 +1,259 @@
+'use strict';
+
+const { pkt, parsePkt } = require('../../lib/velbus-utils');
+const { SENSOR_TYPES, SENSOR_TYPE_IDS } = require('../../lib/sensor-types');
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+function activeFromBitmask(byte) {
+  const active = [];
+  for (let i = 0; i < 8; i++) {
+    if (byte & (1 << i)) active.push(i + 1);
+  }
+  return active;
+}
+
+function decodeNameBitmask(byte) {
+  // Returns the channel number (1-8) for a single-bit bitmask
+  for (let i = 0; i < 8; i++) {
+    if (byte === (1 << i)) return i + 1;
+  }
+  return null;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Node
+// ─────────────────────────────────────────────────────────────────────────────
+
+module.exports = function(RED) {
+
+  function VelbusSensorNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.bridge    = RED.nodes.getNode(config.bridge);
+    node.address   = typeof config.address === 'number'
+      ? config.address  // legacy saves stored decimal numbers
+      : (parseInt(config.address, 16) || 0);  // editor stores hex strings
+    node.moduleName = config.moduleName || '';
+    node.typeId    = config.typeId ? parseInt(config.typeId) : null;
+
+    if (!node.bridge) {
+      node.status({ fill: 'red', shape: 'ring', text: 'no bridge' });
+      node.error('velbus-sensor: no bridge configured');
+      return;
+    }
+    if (!node.address || node.address < 1 || node.address > 254) {
+      node.status({ fill: 'red', shape: 'ring', text: 'invalid address' });
+      node.error('velbus-sensor: invalid address ' + node.address);
+      return;
+    }
+
+    const typeDesc   = node.typeId !== null ? (SENSOR_TYPES[node.typeId] || null) : null;
+    const hasCounter = typeDesc ? typeDesc.hasCounter : false;
+    const isVMB4AN   = node.typeId === 0x32;
+
+    const _addrHex = '0x' + node.address.toString(16).padStart(2, '0').toUpperCase();
+    const _label = () => node.moduleName
+      ? node.moduleName + ' (' + _addrHex + ')'
+      : (typeDesc ? typeDesc.name : 'sensor') + ' ' + _addrHex;
+
+    function setStatus(text, fill, shape) {
+      node.status({ fill: fill || 'green', shape: shape || 'dot',
+        text: _label() + ' ' + text });
+    }
+
+    // Channel name store — keyed by channel number (1-8)
+    const _channelNames = {};
+    const _nameParts    = {};  // keyed by channel number, then part 0/1/2
+
+    function assembleName(ch) {
+      const parts = _nameParts[ch];
+      if (!parts) return;
+      const bytes = [
+        ...(parts[0] || []),
+        ...(parts[1] || []),
+        ...(parts[2] || []),
+      ].filter(b => b !== 0 && b !== 0xFF);
+      const name = String.fromCharCode(...bytes).trim();
+      if (name) _channelNames[ch] = name;
+    }
+
+    // ── Packet handler ────────────────────────────────────────────────────
+
+    function onPacket(raw) {
+      const p = parsePkt(raw);
+      if (!p || p.rtr) return;
+      // Note: no address re-check here. The bridge routes frames to this
+      // listener, including subaddress frames mapped to the primary address
+      // (e.g. GPO-20 thermostat status from subaddress 0x34).
+
+      const { cmd, body } = p;
+
+      switch (cmd) {
+
+        // ── 0x00  Channel events ──────────────────────────────────────────
+        case 0x00: {
+          if (body.length < 4) return;
+          // body[0]=cmd, body[1]=pressed, body[2]=released, body[3]=longPressed
+          const pressed     = activeFromBitmask(body[1]);
+          const released    = activeFromBitmask(body[2]);
+          const longPressed = activeFromBitmask(body[3]);
+          const on = pressed.length > 0 || longPressed.length > 0;
+
+          const payload = { type: 'channel', on, pressed, released, longPressed };
+          if (pressed.length) setStatus('ch' + pressed.join(',') + ' on');
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xED  Module status ───────────────────────────────────────────
+        case 0xED: {
+          // VMB7IN: PDF says DLC=5 but lists 7 fields — treat as 7 data bytes
+          if (body.length < 7) return;
+          // body[0]=0xED, body[1]=channel status, body[2]=enabled/disabled,
+          // body[3]=normal/inverted, body[4]=locked, body[5]=prog-disabled,
+          // body[6]=alarm&program
+          const on = body[1] !== 0;
+          const progByte = body[6];
+          const program = ['none', 'summer', 'winter', 'holiday'][progByte & 0x03];
+          const alarm1Active   = !!(progByte & 0x04);
+          const alarm2Active   = !!(progByte & 0x10);
+          const sunriseEnabled = !!(progByte & 0x40);
+          const sunsetEnabled  = !!(progByte & 0x80);
+
+          const payload = {
+            type:          'status',
+            on,
+            channels:      activeFromBitmask(body[1]),
+            enabled:       activeFromBitmask(body[2]),
+            normal:        activeFromBitmask(body[3]),
+            locked:        activeFromBitmask(body[4]),
+            progDisabled:  activeFromBitmask(body[5]),
+            program,
+            alarms: { alarm1Active, alarm2Active },
+            sunrise: sunriseEnabled,
+            sunset:  sunsetEnabled,
+          };
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xBE  Pulse counter status (VMB7IN channels 1-4) ─────────────
+        case 0xBE: {
+          if (!hasCounter) return;
+          if (body.length < 8) return;
+          // body[0]=0xBE
+          // body[1]: bits0-1=channel(0-3), bits2-7=pulses-per-unit scaling
+          // body[2-5]: 32-bit pulse count (MSB first)
+          // body[6-7]: 16-bit period in ms between last 2 pulses (0xFFFF=overflow)
+          const channelIndex = body[1] & 0x03;       // 0-3
+          const channel = channelIndex + 1;           // 1-4
+          const scalingBits = (body[1] >> 2) & 0x3F; // bits 2-7
+          // scaling encodes pulses per unit * 100 (e.g. 0x01=100, 0x0A=1000)
+          const pulsesPerUnit = scalingBits * 100;
+
+          const count = ((body[2] << 24) | (body[3] << 16) | (body[4] << 8) | body[5]) >>> 0;
+          const periodMs = (body[6] << 8) | body[7];
+          const overflow = periodMs === 0xFFFF;
+
+          const payload = {
+            type:         'counter',
+            channel,
+            count,
+            pulsesPerUnit,
+            periodMs:     overflow ? null : periodMs,
+            overflow,
+          };
+
+          node.send([null, { payload }]);
+          break;
+        }
+
+        // ── 0xF0/F1/F2  Channel name parts ───────────────────────────────
+        case 0xF0:
+        case 0xF1:
+        case 0xF2: {
+          // body[0]=cmd, body[1]=channel bitmask, body[2..]=chars
+          const mask = body[1];
+          const ch   = decodeNameBitmask(mask);
+          if (!ch) break;
+          const part = cmd - 0xF0;
+          if (!_nameParts[ch]) _nameParts[ch] = {};
+          _nameParts[ch][part] = Array.from(body).slice(2);
+          if (part === 2) assembleName(ch);
+          break;
+        }
+
+        default:
+          break;
+      }
+    }
+
+    node.bridge.register(node.address, onPacket);
+
+    // ── Input commands ────────────────────────────────────────────────────
+
+    node.on('input', function(msg) {
+      const cmd = msg.payload && msg.payload.cmd;
+      if (!cmd) return;
+
+      if (cmd === 'get_status') {
+        node.bridge.send(pkt(0xFB, node.address, [0xFA, 0x00]));
+        return;
+      }
+
+      // Request counter status — DB2=channel bitmask (bits 0-3 = ch 1-4), DB3=interval
+      if (cmd === 'get_counter') {
+        if (!hasCounter) { node.warn('velbus-sensor: this module has no pulse counter'); return; }
+        const chMask = parseInt(msg.payload.channels) || 0x0F; // default all 4
+        const interval = parseInt(msg.payload.interval) || 0;
+        node.bridge.send(pkt(0xF8, node.address, [0xBD, chMask, interval]));
+        return;
+      }
+
+      // Reset counter — DB2=channel number (0-3)
+      if (cmd === 'reset_counter') {
+        if (!hasCounter) { node.warn('velbus-sensor: this module has no pulse counter'); return; }
+        const ch = (parseInt(msg.payload.channel) || 1) - 1; // 0-indexed
+        node.bridge.send(pkt(0xF8, node.address, [0xAD, ch]));
+        return;
+      }
+
+      // Load counter — DB2=channel number (0-3), DB3=don't care, DB4-7=32-bit value
+      if (cmd === 'load_counter') {
+        if (!hasCounter) { node.warn('velbus-sensor: this module has no pulse counter'); return; }
+        const ch    = (parseInt(msg.payload.channel) || 1) - 1;
+        const value = parseInt(msg.payload.value) || 0;
+        const b4 = (value >>> 24) & 0xFF;
+        const b5 = (value >>> 16) & 0xFF;
+        const b6 = (value >>>  8) & 0xFF;
+        const b7 =  value         & 0xFF;
+        node.bridge.send(pkt(0xF8, node.address, [0xAD, ch, 0x00, b4, b5, b6, b7]));
+        return;
+      }
+
+      // Request channel name — DB2=channel bitmask
+      if (cmd === 'get_name') {
+        const ch = parseInt(msg.payload.channel) || 0;
+        const mask = ch >= 1 && ch <= 8 ? (1 << (ch - 1)) : 0xFF;
+        node.bridge.send(pkt(0xF8, node.address, [0xEF, mask]));
+        return;
+      }
+
+      node.warn('velbus-sensor: unknown cmd: ' + cmd);
+    });
+
+    // ── Cleanup ───────────────────────────────────────────────────────────
+
+    node.on('close', function() {
+      node.bridge.deregister(node.address, onPacket);
+    });
+
+    setStatus('ready', 'grey', 'dot');
+  }
+
+  RED.nodes.registerType('velbus-sensor', VelbusSensorNode);
+};

package/nodes/velbus-sensor-20/velbus-sensor-20.html

@@ -0,0 +1,158 @@
+<script type="text/javascript">
+(function() {
+
+  const SENSOR_TYPES_20 = {
+    0x4E: { name: 'VMB8IN-20', hasCounter: true, series: 'v2' },
+  };
+
+  RED.nodes.registerType('velbus-sensor-20', {
+    category:  'Velbus (inputs)',
+    color:     '#3A8C8C',
+    defaults: {
+      name:       { value: '' },
+      bridge:     { value: '', type: 'velbus-bridge', required: true },
+      address:    { value: '', required: true, validate: function(v) { return /^(0x)?[0-9a-fA-F]{1,2}$/.test(v); } },
+      moduleName: { value: '' },
+      typeId:     { value: '' },
+    },
+    inputs:  1,
+    outputs: 2,
+    outputLabels: ['channel events / status', 'energy counter'],
+    icon:    'font-awesome/fa-tachometer',
+    paletteLabel: 'sensor-20',
+
+    label: function() {
+      const t = this.typeId ? SENSOR_TYPES_20[parseInt(this.typeId, 16)] : null;
+      const n = this.name || this.moduleName || (t ? t.name : 'sensor-20');
+      return n + ' 0x' + (parseInt(this.address) || 0).toString(16).padStart(2,'0').toUpperCase();
+    },
+
+    oneditprepare: function() {
+      const savedAddr = this.address;
+      $('#node-input-typeId').prop('readonly', true).css('background', '#f0f0f0');
+
+      function populateDropdown(bridgeId) {
+        if (!bridgeId) return;
+        $.getJSON('velbus/scan-results?bridge=' + bridgeId, function(results) {
+          const modules = (results && results.modules) ? results.modules : [];
+          const $addr = $('#node-input-address');
+          $addr.empty().append($('<option>').val('').text('— select address —'));
+
+          const typeIds = Object.keys(SENSOR_TYPES_20).map(k => parseInt(k));
+          const filtered = modules.filter(m => typeIds.includes(parseInt(m.typeId, 16)));
+
+          if (!filtered.length) {
+            $addr.append($('<option>').val('').text('No V2 sensor modules found on bus'));
+            return;
+          }
+          filtered.forEach(function(m) {
+            const tid   = parseInt(m.typeId, 16);
+            const label = m.address + ' — ' + m.module;
+            const $opt  = $('<option>').val(m.addressDec).text(label).data('typeid', tid);
+            if (m.addressDec === parseInt(savedAddr)) $opt.attr('selected', true);
+            $addr.append($opt);
+          });
+          if (savedAddr) {
+            const $opt = $('#node-input-address option[value="' + parseInt(savedAddr) + '"]');
+            const tid = $opt.data('typeid');
+            if (tid) {
+              $('#sensor20-type-hint').text(SENSOR_TYPES_20[tid].name + ' · up to 32ch · energy counters').show();
+              $('#node-input-typeId').val('0x' + tid.toString(16).padStart(2,'0').toUpperCase());
+            }
+          }
+        });
+      }
+
+      $('#node-input-bridge').on('change', function() { populateDropdown($(this).val()); });
+      $('#node-input-address').on('change', function() {
+        const tid = $(this).find(':selected').data('typeid');
+        if (tid && SENSOR_TYPES_20[tid]) {
+          $('#sensor20-type-hint').text(SENSOR_TYPES_20[tid].name + ' · up to 32ch · energy counters').show();
+          $('#node-input-typeId').val('0x' + tid.toString(16).padStart(2,'0').toUpperCase());
+        }
+      });
+      // Deferred load — TypedInput sets value async after oneditprepare
+
+      $('#node-input-bridge').trigger('change');
+
+      setTimeout(function() { $('#node-input-bridge').trigger('change'); }, 150);
+    },
+
+    oneditsave: function() {
+      this.address = parseInt($('#node-input-address').val()) || 0;
+      const tid = $('#node-input-typeId').val();
+      this.typeId = tid || '';
+      if (tid) {
+        const t = SENSOR_TYPES_20[parseInt(tid, 16)];
+        if (t) this.moduleName = t.name;
+      }
+    },
+  });
+
+})();
+</script>
+
+<script type="text/html" data-template-name="velbus-sensor-20">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Optional label">
+  </div>
+  <div class="form-row">
+    <label for="node-input-bridge"><i class="fa fa-plug"></i> Bridge</label>
+    <input type="text" id="node-input-bridge">
+  </div>
+  <div class="form-row">
+    <label for="node-input-address"><i class="fa fa-map-marker"></i> Address</label>
+    <select id="node-input-address" style="width:70%">
+      <option value="">— select bridge first —</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label></label>
+    <span id="sensor20-type-hint" style="color:#888; font-size:0.9em; display:none;"></span>
+  </div>
+  <div class="form-row" style="display:none">
+    <input type="text" id="node-input-typeId">
+    <input type="text" id="node-input-moduleName">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="velbus-sensor-20">
+  <p style="background:#fff3cd; border-left:4px solid #ffc107; padding:8px 12px; margin-bottom:12px; font-size:0.85em;">
+  <strong>&#9888; Testing status:</strong> This node was generated with Claude.ai and is in
+  need of extensive field testing before being deployed into a commercial project.
+  It is presented "as is" &mdash; any use beyond testing is entirely at your own risk and liability.
+  Constructive feedback is welcomed, accompanied by as many examples and debug captures as possible.
+  <a href="https://github.com/MDAR/node-red-contrib-velbus-2026/issues" target="_blank">File an issue on GitHub</a>.
+  </p>
+  <p>V2 universal input node for VMB8IN-20 (0x4E).</p>
+  <p>Supports up to 32 digital input channels (8 primary + 24 via subaddresses),
+  8 energy counters, firmware check on startup, and name auto-retrieval.</p>
+  <p>For original series use <strong>velbus-sensor</strong>.</p>
+
+  <h3>Output 1 — Channel events / status</h3>
+  <p>Channel event (0x00) — includes sourceAddress to identify primary vs subaddress:</p>
+  <pre>{ "type": "channel", "on": true, "pressed": [1,3], "released": [],
+  "longPressed": [], "sourceAddress": "0x0A" }</pre>
+  <p>Primary module status (0xED — 8 bytes):</p>
+  <pre>{ "type": "status", "on": true, "channels": [1,2],
+  "enabled": [1,2,3,4,5,6,7,8], "normal": [1,2,3,4,5,6,7,8],
+  "locked": [], "progDisabled": [], "program": "group1",
+  "autoSendInterval": 30 }</pre>
+  <p>Subaddress status (0xED — 5 bytes):</p>
+  <pre>{ "type": "sub_status", "channels": [1,3], "enabled": [...], "locked": [], "progDisabled": [] }</pre>
+
+  <h3>Output 2 — Energy counter (0xA4)</h3>
+  <pre>{ "type": "energy", "channel": 1, "powerW": 1250, "energyWh": 45678 }</pre>
+
+  <h3>Input commands</h3>
+  <dl>
+    <dt><code>{ "cmd": "get_status" }</code></dt><dd>Request module status.</dd>
+    <dt><code>{ "cmd": "get_counter", "channels": 255, "interval": 30 }</code></dt>
+    <dd>Request energy counters. channels=bitmask of ch1-8 (255=all). interval=0 no change.</dd>
+    <dt><code>{ "cmd": "load_counter", "channel": 1, "value": 0 }</code></dt><dd>Load counter with preset value.</dd>
+    <dt><code>{ "cmd": "lock", "channel": 1, "duration": 3600 }</code></dt><dd>Lock channel by number (1-32, 255=all).</dd>
+    <dt><code>{ "cmd": "unlock", "channel": 1 }</code></dt><dd>Unlock channel.</dd>
+    <dt><code>{ "cmd": "get_name", "channel": 1 }</code></dt><dd>Request channel name (1-32, 255=all).</dd>
+  </dl>
+</script>