node-red-contrib-velbus-2026 0.8.1 → 0.9.0

package/CHANGELOG_FORUM.md

@@ -14,6 +14,48 @@ All feedback via GitHub issues, with examples and debug captures where possible.
 
 ---
 
+## v0.9.0 — 08/07/2026
+
+### velbus-energy — new node (19th node), VMBPSUMNGR-20
+
+- **Closes the last "not yet built" item on the module registry** —
+  VMBPSUMNGR-20 (0x04), the power-supply-manager module, following the same
+  V2 architectural pattern as `velbus-sensor-20` (firmware/type check, name
+  auto-retrieval, standard startup RTR).
+- Handles: `0xED` module status (PSU load %ages, alarm bitmasks, shared
+  program/clock-alarm/sunrise/sunset byte), `0x00` real-time alarm events
+  (arrives via primary address as one bitmask, via sub-address1 as a second
+  bitmask — same command, discriminated by source address, merged into
+  running alarm state so a partial update never discards the other half),
+  `0xA1` warranty counter (31-bit hours-in-operation + expired flag, packed
+  across 4 bytes), `0xA2` PSU load status (mode + 3 load percentages), `0xA3`
+  PSU values (wattage/voltage/amperage per rail, one message per PSU/PSUOut).
+- **Does not reimplement the shared V2 "system" commands** (real-time clock,
+  date, DST, sunrise/sunset, clock alarm) present throughout this PDF —
+  `velbus-clock` already owns broadcasting those; duplicating them here
+  would just be dead weight.
+- **Two real errors found in Velbus's own protocol PDF while implementing
+  this, both documented in the node's source comments:**
+  - The document header reads "VMB8IN-20 PROTOCOL" throughout — an
+    un-retitled template artifact from a different module's document.
+  - The `0xA3` (PSU values status) section labels three different byte
+    positions all as "DATABYTE6" (voltage high, amperage high, amperage
+    low) — internally inconsistent with its own stated 8-byte length.
+    Reconstructed from the byte count as DATABYTE5/6 = voltage hi/lo,
+    DATABYTE7/8 = amperage hi/lo. Same category as the temperature-divisor
+    and build-number-mislabelling issues already known elsewhere in this
+    project — worth remembering if re-checking against the source PDF.
+- Verified with the mock-RED harness: every packet type (module type
+  identification, both alarm bitmask sources, module status, warranty
+  counter, PSU load, PSU values, name assembly across all three name-part
+  commands) exercised with hand-checked checksums; outgoing commands
+  (`get_status`, `get_warranty`, `get_name`) checksum-verified by hand
+  against the actual bytes produced. **Not yet sent to a real bus** — no
+  VMBPSUMNGR-20 has been confirmed present on a scanned bus yet (see the
+  handover's outstanding-verification notes).
+
+---
+
 ## v0.8.1 — 07/07/2026
 
 ### velbus-clock — set_alarm command (global + local, one command)

package/README.md

@@ -85,6 +85,7 @@ npm install /path/to/node-red-contrib-velbus-2026_v0.8.1.tar.gz
 | `velbus-blind-s` | VMB1BLS, VMB2BLE, VMB2BLE-10 — full position, lock, force, inhibit |
 | `velbus-blind-20` | VMB2BLE-20 — V2 series with CAN FD support |
 | `velbus-clock` | No fixed module — broadcasts time/date/DST to bus address `0x00`, plus global/local clock alarm (V2 series only) |
+| `velbus-energy` | VMBPSUMNGR-20 — power supply manager: PSU load, live wattage/voltage/amperage, warranty counter, PSU alarms (V2 series only) |
 
 ---
 

package/lib/energy-types-20.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Energy / power-supply-manager module type registry — V2 series
+// Covered by velbus-energy node.
+//
+// VMBPSUMNGR-20 (0x04): manages up to two power supplies (PSU1, PSU2) feeding
+//   a combined output (PSUOut) — load balancing / boost / back-up modes.
+//   Reports per-rail load percentage, live wattage/voltage/amperage, a
+//   warranty counter (hours in operation, 10-year/87660h limit + expired
+//   flag), and PSU/warranty alarm status. Single-purpose monitoring module —
+//   no per-channel I/O config in the usual sense.
+//
+// Source: protocol_vmbpsumngr_20.pdf (ed.1, 14/03/2025). Note: the PDF's own
+// header still reads "VMB8IN-20 PROTOCOL" throughout — an un-retitled
+// template artifact, not a sign this registry entry is wrong.
+// ─────────────────────────────────────────────────────────────────────────────
+
+const ENERGY_TYPES_20 = {
+  0x04: {
+    name:      'VMBPSUMNGR-20',
+    minMapVer: null,   // no minimum stated in the protocol PDF
+    series:    'v2',
+  },
+};
+
+const ENERGY_TYPE_IDS_20 = new Set(Object.keys(ENERGY_TYPES_20).map(k => parseInt(k)));
+
+module.exports = { ENERGY_TYPES_20, ENERGY_TYPE_IDS_20 };

package/nodes/velbus-energy/velbus-energy.html

@@ -0,0 +1,167 @@
+<script type="text/javascript">
+(function() {
+
+  const ENERGY_TYPES_20 = {
+    0x04: { name: 'VMBPSUMNGR-20', series: 'v2' },
+  };
+
+  RED.nodes.registerType('velbus-energy', {
+    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: ['status / alarm / warranty / psu load', 'psu values (per rail)'],
+    icon:    'font-awesome/fa-plug',
+    paletteLabel: 'energy',
+
+    label: function() {
+      const t = this.typeId ? ENERGY_TYPES_20[parseInt(this.typeId, 16)] : null;
+      const n = this.name || this.moduleName || (t ? t.name : 'energy');
+      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(ENERGY_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 power supply manager 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) {
+              $('#energy-type-hint').text(ENERGY_TYPES_20[tid].name + ' · PSU1/PSU2/PSUOut monitoring').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 && ENERGY_TYPES_20[tid]) {
+          $('#energy-type-hint').text(ENERGY_TYPES_20[tid].name + ' · PSU1/PSU2/PSUOut monitoring').show();
+          $('#node-input-typeId').val('0x' + tid.toString(16).padStart(2,'0').toUpperCase());
+        }
+      });
+
+      $('#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 = ENERGY_TYPES_20[parseInt(tid, 16)];
+        if (t) this.moduleName = t.name;
+      }
+    },
+  });
+
+})();
+</script>
+
+<script type="text/html" data-template-name="velbus-energy">
+  <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="energy-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-energy">
+  <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><strong>Verified only against a mock test harness, not yet against real hardware</strong> — no
+  VMBPSUMNGR-20 has been confirmed present on a scanned bus yet. Packet checksums, DLC, and field
+  layout have been hand-verified against the protocol PDF; the actual real-hardware byte layout has
+  not been independently confirmed. See this project's <code>HANDOVER.md</code> for detail.</p>
+
+  <p>V2 power supply manager node for VMBPSUMNGR-20 (0x04). Monitors up to two power supplies
+  (PSU1, PSU2) feeding a combined output (PSUOut) &mdash; load percentages, live wattage/voltage/
+  amperage per rail, a warranty counter (hours in operation), and PSU/warranty alarm status.</p>
+  <p>This is a monitoring-only module &mdash; there's no per-channel I/O configuration the way
+  most other nodes in this palette have.</p>
+
+  <h3>Output 1 — Status / alarm / warranty / PSU load</h3>
+  <p>Alarm event (0x00 &mdash; fires immediately on change):</p>
+  <pre>{ "type": "alarm", "on": true, "alarms": {
+  "psu1Offline": false, "psu2Offline": true, "warrantyExpired": false,
+  "psu1Alarm1": false, "psu2Alarm1": false, "psuOutAlarm1": false,
+  "psu1Alarm2": false, "psu1Alarm3": false, "psu1Alarm4": false,
+  "psu2Alarm2": false, "psu2Alarm3": false, "psu2Alarm4": false,
+  "psuOutAlarm2": false } }</pre>
+  <p>Module status (0xED &mdash; the same alarm bitmasks as above, plus load and program info in one packet):</p>
+  <pre>{ "type": "status", "on": false, "alarms": { ... },
+  "psu1Load": 45, "psu2Load": 50, "psuOutLoad": 48, "program": "group1",
+  "clockAlarms": { "alarm1": { "on": true, "global": false },
+                   "alarm2": { "on": false, "global": false } },
+  "sunrise": false, "sunset": false, "autoSendInterval": 60 }</pre>
+  <p>Warranty counter (0xA1):</p>
+  <pre>{ "type": "warranty", "hours": 5000, "expired": false, "limitHours": 87660, "on": false }</pre>
+  <p>PSU load status (0xA2):</p>
+  <pre>{ "type": "psu_load", "mode": "boost", "psu1Load": 60, "psu2Load": 70, "psuOutLoad": 65 }</pre>
+
+  <h3>Output 2 — PSU values (0xA3, one message per rail)</h3>
+  <pre>{ "type": "psu_values", "channel": 2, "channelName": "PSU2",
+  "wattageMW": 50000, "voltageMV": 24000, "amperageMA": 2100,
+  "watts": 50, "volts": 24, "amps": 2.1 }</pre>
+
+  <h3>Input commands</h3>
+  <dl>
+    <dt><code>{ "cmd": "get_status" }</code></dt><dd>Request module status.</dd>
+    <dt><code>{ "cmd": "get_warranty" }</code></dt><dd>Request the warranty/hours-in-operation counter.</dd>
+    <dt><code>{ "cmd": "get_name", "channel": 1 }</code></dt><dd>Request channel name (1-10, 255=all).</dd>
+  </dl>
+</script>

package/nodes/velbus-energy/velbus-energy.js

@@ -0,0 +1,365 @@
+'use strict';
+
+const { pkt, rtrPkt, parsePkt } = require('../../lib/velbus-utils');
+const { ENERGY_TYPES_20, ENERGY_TYPE_IDS_20 } = require('../../lib/energy-types-20');
+
+// ─────────────────────────────────────────────────────────────────────────────
+// velbus-energy — VMBPSUMNGR-20 (power supply manager), type 0x04
+//
+// Source: protocol_vmbpsumngr_20.pdf (ed.1, 14/03/2025). This PDF is largely
+// the same shared V2 "system" command block already implemented in
+// velbus-clock (real-time clock, date, DST, sunrise/sunset, clock alarm) —
+// none of that is reimplemented here; velbus-clock remains the single owner
+// of broadcasting those. Only the genuinely energy/PSU-specific packets are
+// handled below.
+//
+// Known PDF documentation issues, both worth remembering if re-checking
+// against the source document directly:
+//   - The document header reads "VMB8IN-20 PROTOCOL" throughout — an
+//     un-retitled template artifact from a different module's document, not
+//     a sign this file targets the wrong module.
+//   - The 0xA3 (PSU values status) section labels three different byte
+//     positions all as "DATABYTE6" (voltage high, amperage high, amperage
+//     low) — internally inconsistent with its own stated 8-byte length.
+//     Reconstructed below from the byte count and field descriptions as
+//     DATABYTE5/6 = voltage hi/lo, DATABYTE7/8 = amperage hi/lo.
+//   - 0xA0 (Warranty Counter Request)'s internal constant name is given as
+//     "COMMAND_POWER_UP" — clearly a copy-paste artifact from the 0xAB
+//     section just above it, not a sign this is actually the power-up
+//     command. Treated here as a simple no-parameter trigger, per its
+//     stated 1-byte length.
+//
+// NOT YET VERIFIED AGAINST REAL HARDWARE — this node has not been sent to a
+// real VMBPSUMNGR-20. See the mock-harness verification note in this
+// project's HANDOVER.md, section 11, for the testing method used instead.
+// ─────────────────────────────────────────────────────────────────────────────
+
+module.exports = function(RED) {
+
+  function VelbusEnergyNode(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-energy: 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-energy: invalid address ' + node.address);
+      return;
+    }
+
+    // Running alarm state — 0x00 arrives as two separate partial bitmasks
+    // (see the case 0x00 handler below), and 0xED conveniently repeats both
+    // in one packet. Kept as node state so a partial 0x00 update doesn't
+    // discard the other half of the picture.
+    let _alarmState = {
+      psu1Offline: false, psu2Offline: false, warrantyExpired: false,
+      psu1Alarm1: false, psu2Alarm1: false, psuOutAlarm1: false,
+      psu1Alarm2: false, psu1Alarm3: false, psu1Alarm4: false,
+      psu2Alarm2: false, psu2Alarm3: false, psu2Alarm4: false,
+      psuOutAlarm2: false,
+    };
+
+    function anyAlarmActive() {
+      return Object.values(_alarmState).some(v => v);
+    }
+
+    // Name retrieval state — channel-keyed per the protocol (channels 1-10
+    // declared, though only 1-3 are meaningful here: PSU1/PSU2/PSUOut).
+    // Channel 1's name is used as the module's own display name, matching
+    // the convention in velbus-sensor-20.
+    let _nameParts = {};
+    let _nameTimer = null;
+
+    function assembleName(ch) {
+      const bytes = [
+        ...(_nameParts[ch] && _nameParts[ch][0] || []),
+        ...(_nameParts[ch] && _nameParts[ch][1] || []),
+        ...(_nameParts[ch] && _nameParts[ch][2] || []),
+      ].filter(b => b !== 0 && b !== 0xFF);
+      const name = String.fromCharCode(...bytes).trim();
+      if (name && ch === 1) node.moduleName = name;
+      return name;
+    }
+
+    const _addrHex = '0x' + node.address.toString(16).padStart(2, '0').toUpperCase();
+
+    function setStatus(text, fill, shape) {
+      const label = node.moduleName
+        ? node.moduleName + ' (' + _addrHex + ')'
+        : _addrHex;
+      node.status({ fill: fill || 'green', shape: shape || 'dot', text: label + ' ' + text });
+    }
+
+    // ── Firmware/type check ───────────────────────────────────────────────
+
+    function handleModuleType(body) {
+      if (body.length < 8) return;
+      const typeId = body[1];
+      const build  = body[5] * 100 + body[6];
+      const canFD  = !!(body[7] & 0x20);
+
+      const desc = ENERGY_TYPES_20[typeId];
+      if (!desc) {
+        node.status({ fill: 'red', shape: 'ring',
+          text: 'unknown type 0x' + typeId.toString(16) });
+        node.error('velbus-energy: unrecognised module type 0x' + typeId.toString(16));
+        return;
+      }
+
+      node.moduleName = node.moduleName || desc.name;
+      setStatus('build ' + build + (canFD ? ' CAN FD' : ''), 'grey', 'dot');
+
+      setTimeout(() => {
+        node.bridge.send(pkt(0xF8, node.address, [0xEF, 0xFF]));
+        _nameTimer = setTimeout(() => assembleName(1), 2000);
+      }, 100);
+    }
+
+    // ── Packet handler ────────────────────────────────────────────────────
+
+    function onPacket(raw) {
+      const p = parsePkt(raw);
+      if (!p || p.rtr) return;
+
+      const { cmd, body } = p;
+
+      switch (cmd) {
+
+        // ── 0xFF  Module type ─────────────────────────────────────────────
+        case 0xFF: {
+          handleModuleType(body);
+          break;
+        }
+
+        // ── 0x00  Alarm status (primary address = bitmask 1, sub-address1 =
+        //          bitmask 2 — same command, discriminated by source address) ──
+        // The PDF's own DATABYTE2/3/4 labels ("Channel just pressed" etc.)
+        // are template leftovers from a different module and don't apply —
+        // the actual meaning comes from the bitmask tables underneath them.
+        case 0x00: {
+          if (body.length < 4) return;
+          const bits = body[1];
+
+          if (p.addr === node.address) {
+            // Primary address — alarm bitmask 1
+            _alarmState.psu1Offline    = !!(bits & 0x01);
+            _alarmState.psu2Offline    = !!(bits & 0x02);
+            _alarmState.warrantyExpired = !!(bits & 0x04);
+            _alarmState.psu1Alarm1     = !!(bits & 0x08);
+            // bit 0x10 = PSU1 peak load >xx% — documented "not implemented"
+            _alarmState.psu2Alarm1     = !!(bits & 0x20);
+            // bit 0x40 = PSU2 peak load >xx% — documented "not implemented"
+            _alarmState.psuOutAlarm1   = !!(bits & 0x80);
+          } else {
+            // Arrived via sub-address1 — alarm bitmask 2
+            _alarmState.psu1Alarm2   = !!(bits & 0x01);
+            _alarmState.psu1Alarm3   = !!(bits & 0x02);
+            _alarmState.psu1Alarm4   = !!(bits & 0x04);
+            _alarmState.psu2Alarm2   = !!(bits & 0x08);
+            _alarmState.psu2Alarm3   = !!(bits & 0x10);
+            _alarmState.psu2Alarm4   = !!(bits & 0x20);
+            _alarmState.psuOutAlarm2 = !!(bits & 0x40);
+            // bit 0x80 = PSUOut peak load >xx% — documented "not implemented"
+          }
+
+          const on = anyAlarmActive();
+          const payload = { type: 'alarm', on, alarms: { ..._alarmState } };
+          if (on) setStatus('alarm active', 'red');
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xED  Module status — repeats both alarm bitmasks from 0x00 in
+        //          one packet, plus load percentages and the shared
+        //          program/clock-alarm/sunrise/sunset byte ─────────────────
+        case 0xED: {
+          if (body.length < 8) return;
+          const bits1 = body[1];
+          const bits2 = body[2];
+
+          _alarmState.psu1Offline      = !!(bits1 & 0x01);
+          _alarmState.psu2Offline      = !!(bits1 & 0x02);
+          _alarmState.warrantyExpired  = !!(bits1 & 0x04);
+          _alarmState.psu1Alarm1       = !!(bits1 & 0x08);
+          _alarmState.psu2Alarm1       = !!(bits1 & 0x20);
+          _alarmState.psuOutAlarm1     = !!(bits1 & 0x80);
+          _alarmState.psu1Alarm2       = !!(bits2 & 0x01);
+          _alarmState.psu1Alarm3       = !!(bits2 & 0x02);
+          _alarmState.psu1Alarm4       = !!(bits2 & 0x04);
+          _alarmState.psu2Alarm2       = !!(bits2 & 0x08);
+          _alarmState.psu2Alarm3       = !!(bits2 & 0x10);
+          _alarmState.psu2Alarm4       = !!(bits2 & 0x20);
+          _alarmState.psuOutAlarm2     = !!(bits2 & 0x40);
+
+          const psu1Load   = body[3];
+          const psu2Load   = body[4];
+          const psuOutLoad = body[5];
+
+          const progByte = body[6];
+          const program = ['none', 'group1', 'group2', 'group3'][progByte & 0x03];
+          const clockAlarm1On    = !!(progByte & 0x04);
+          const clockAlarm1Global = !!(progByte & 0x08);
+          const clockAlarm2On    = !!(progByte & 0x10);
+          const clockAlarm2Global = !!(progByte & 0x20);
+          const sunriseEnabled   = !!(progByte & 0x40);
+          const sunsetEnabled    = !!(progByte & 0x80);
+
+          const autoSendInterval = body[7];
+          const on = anyAlarmActive();
+
+          const payload = {
+            type: 'status',
+            on,
+            alarms: { ..._alarmState },
+            psu1Load, psu2Load, psuOutLoad,
+            program,
+            clockAlarms: {
+              alarm1: { on: clockAlarm1On, global: clockAlarm1Global },
+              alarm2: { on: clockAlarm2On, global: clockAlarm2Global },
+            },
+            sunrise: sunriseEnabled,
+            sunset:  sunsetEnabled,
+            autoSendInterval,
+          };
+          setStatus('PSU1:' + psu1Load + '% PSU2:' + psu2Load + '% Out:' + psuOutLoad + '%',
+            on ? 'red' : 'green');
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xA1  Warranty counter status ─────────────────────────────────
+        // 31-bit hours-in-operation value spans body[1]-body[3] plus the low
+        // 7 bits of body[4]; bit 7 of body[4] is the expired flag. Byte
+        // ordering (MSB-first) reasoned from the field description order in
+        // the PDF ("1st/2nd/3rd byte of value" then "+7 bits") — not
+        // independently confirmed against a captured real packet.
+        case 0xA1: {
+          if (body.length < 5) return;
+          const hours = ((body[1] << 23) | (body[2] << 15) | (body[3] << 7) |
+                         (body[4] & 0x7F)) >>> 0;
+          const expired = !!(body[4] & 0x80);
+
+          const payload = { type: 'warranty', hours, expired,
+            limitHours: 87660, on: expired };
+          if (expired) setStatus('WARRANTY EXPIRED', 'red');
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xA2  PSU load status ──────────────────────────────────────────
+        case 0xA2: {
+          if (body.length < 5) return;
+          const modeNames = { 1: 'balance', 2: 'boost', 3: 'backup' };
+          const mode = modeNames[body[1]] || 'unknown';
+
+          const payload = {
+            type: 'psu_load',
+            mode,
+            psu1Load:   body[2],
+            psu2Load:   body[3],
+            psuOutLoad: body[4],
+          };
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xA3  PSU values status — one packet per rail (PSU1/PSU2/PSUOut) ─
+        // See the file-level comment re: the PDF's own DATABYTE6 labelling
+        // error — this reconstructs the intended 8-byte layout from the
+        // stated field count and DLC, not from the PDF's literal (broken)
+        // byte labels.
+        case 0xA3: {
+          if (body.length < 8) return;
+          const channel     = (body[1] >> 4) & 0x0F;   // 1=PSU1, 2=PSU2, 3=PSUOut
+          const wattageMSB  = body[1] & 0x0F;
+          const wattageMW   = (wattageMSB << 16) | (body[2] << 8) | body[3];
+          const voltageMV   = (body[4] << 8) | body[5];
+          const amperageMA  = (body[6] << 8) | body[7];
+          const channelName = { 1: 'PSU1', 2: 'PSU2', 3: 'PSUOut' }[channel] || 'unknown';
+
+          const payload = {
+            type: 'psu_values',
+            channel, channelName,
+            wattageMW, voltageMV, amperageMA,
+            watts: wattageMW / 1000,
+            volts: voltageMV / 1000,
+            amps:  amperageMA / 1000,
+          };
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xF0/F1/F2  Channel name parts ─────────────────────────────────
+        case 0xF0:
+        case 0xF1:
+        case 0xF2: {
+          const ch   = body[1];
+          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);
+
+    // Startup RTR
+    setTimeout(function() {
+      node.bridge.send(rtrPkt(node.address), true);
+    }, 500);
+
+    // ── 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;
+      }
+
+      // Warranty counter request — single byte, no parameters.
+      if (cmd === 'get_warranty') {
+        node.bridge.send(pkt(0xF8, node.address, [0xA0]));
+        return;
+      }
+
+      // Request channel name — DB2=channel number (1-10, 0xFF=all)
+      if (cmd === 'get_name') {
+        const ch = parseInt(msg.payload.channel) || 0xFF;
+        node.bridge.send(pkt(0xF8, node.address, [0xEF, ch]));
+        return;
+      }
+
+      node.warn('velbus-energy: unknown cmd: ' + cmd);
+    });
+
+    // ── Cleanup ───────────────────────────────────────────────────────────
+
+    node.on('close', function() {
+      if (_nameTimer) { clearTimeout(_nameTimer); _nameTimer = null; }
+      node.bridge.deregister(node.address, onPacket);
+    });
+
+    setStatus('ready', 'grey', 'dot');
+  }
+
+  RED.nodes.registerType('velbus-energy', VelbusEnergyNode);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-velbus-2026",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Node-RED palette for Velbus building automation \u2014 relay, dimmer, glass panel, PIR, blind, sensor, meteo, clock nodes. Original and V2 (-20) series.",
   "keywords": [
     "node-red",
@@ -31,7 +31,8 @@
       "velbus-blind": "nodes/velbus-blind/velbus-blind.js",
       "velbus-blind-s": "nodes/velbus-blind-s/velbus-blind-s.js",
       "velbus-blind-20": "nodes/velbus-blind-20/velbus-blind-20.js",
-      "velbus-clock": "nodes/velbus-clock/velbus-clock.js"
+      "velbus-clock": "nodes/velbus-clock/velbus-clock.js",
+      "velbus-energy": "nodes/velbus-energy/velbus-energy.js"
     },
     "examples": "examples"
   },