node-red-contrib-velbus-2026 0.8.1

package/nodes/velbus-meteo/velbus-meteo.js

@@ -0,0 +1,279 @@
+'use strict';
+
+const { pkt, rtrPkt, parsePkt } = require('../../lib/velbus-utils');
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+function activeFromBitmask(byte, count) {
+  const active = [];
+  for (let i = 0; i < count; i++) {
+    if (byte & (1 << i)) active.push('alarm' + (i + 1));
+  }
+  return active;
+}
+
+function decodeBitmask(byte, count) {
+  const result = {};
+  for (let i = 0; i < count; i++) {
+    result['alarm' + (i + 1)] = !!(byte & (1 << i));
+  }
+  return result;
+}
+
+function tempFrom16(hi, lo) {
+  const raw = (hi << 8) | lo;
+  return (raw > 32767 ? raw - 65536 : raw) / 512;  // °C × 512, 0.0625° res
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Node
+// ─────────────────────────────────────────────────────────────────────────────
+
+module.exports = function(RED) {
+
+  function VelbusMeteoNode(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
+
+    if (!node.bridge) {
+      node.status({ fill: 'red', shape: 'ring', text: 'no bridge' });
+      node.error('velbus-meteo: 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-meteo: invalid address ' + node.address);
+      return;
+    }
+
+    const _addrHex = '0x' + node.address.toString(16).padStart(2, '0').toUpperCase();
+
+    function setStatus(text, fill, shape) {
+      node.status({ fill: fill || 'green', shape: shape || 'dot',
+        text: _addrHex + ' ' + text });
+    }
+
+    // Alarm channel names — keyed by bitmask position (0-7)
+    const _alarmNames = {};
+    const _nameParts  = {};  // keyed by alarmBit then part (0/1/2)
+
+    function assembleNames() {
+      for (let bit = 0; bit < 8; bit++) {
+        const mask = 1 << bit;
+        const parts = _nameParts[mask];
+        if (!parts) continue;
+        const bytes = [
+          ...(parts[0] || []),
+          ...(parts[1] || []),
+          ...(parts[2] || []),
+        ].filter(b => b !== 0 && b !== 0xFF);
+        const name = String.fromCharCode(...bytes).trim();
+        if (name) _alarmNames[bit] = name;
+      }
+    }
+
+    // ── Packet handler ────────────────────────────────────────────────────
+
+    function onPacket(raw) {
+      const p = parsePkt(raw);
+      if (!p || p.rtr) return;
+      if (p.addr !== node.address) return;
+
+      const { cmd, body } = p;
+
+      switch (cmd) {
+
+        // ── 0x00  Alarm output 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], 8);
+          const released    = activeFromBitmask(body[2], 8);
+          const longPressed = activeFromBitmask(body[3], 8);
+          const on = pressed.length > 0 || longPressed.length > 0;
+
+          const payload = { type: 'alarm', on, pressed, released, longPressed };
+          if (pressed.length) setStatus('alarm: ' + pressed.join(','));
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xED  Module status ───────────────────────────────────────────
+        case 0xED: {
+          if (body.length < 7) return;
+          // body[0]=0xED, body[1]=alarm bitmask, body[2]=locked, body[3]=prog-disabled
+          // body[4]=clock alarm & program, body[5]=auto-send interval, body[6]=test mode
+          const alarms      = decodeBitmask(body[1], 8);
+          const locked      = decodeBitmask(body[2], 8);
+          const progDisabled = decodeBitmask(body[3], 8);
+
+          const progByte = body[4];
+          const program = ['none', 'group1', 'group2', 'group3'][progByte & 0x03];
+          const alarm1Active   = !!(progByte & 0x04);
+          const alarm2Active   = !!(progByte & 0x10);
+          const sunriseEnabled = !!(progByte & 0x40);
+          const sunsetEnabled  = !!(progByte & 0x80);
+
+          const autoSendInterval = body[5];
+          const testMode         = !!(body[6] & 0x80);
+
+          const on = Object.values(alarms).some(v => v);
+          const payload = {
+            type: 'status',
+            on,
+            alarms,
+            locked,
+            progDisabled,
+            program,
+            clockAlarms: { alarm1Active, alarm2Active },
+            sunrise: sunriseEnabled,
+            sunset:  sunsetEnabled,
+            autoSendInterval,
+            testMode,
+          };
+          node.send([{ payload }, null]);
+          break;
+        }
+
+        // ── 0xE6  Temperature ─────────────────────────────────────────────
+        case 0xE6: {
+          if (body.length < 3) return;
+          // body[0]=0xE6, body[1-2]=current, body[3-4]=min, body[5-6]=max
+          const current = tempFrom16(body[1], body[2]);
+          const min = body.length >= 5 ? tempFrom16(body[3], body[4]) : null;
+          const max = body.length >= 7 ? tempFrom16(body[5], body[6]) : null;
+
+          const payload = { type: 'temperature', current };
+          if (min !== null) payload.min = min;
+          if (max !== null) payload.max = max;
+          node.send([null, { payload }]);
+          break;
+        }
+
+        // ── 0xA9  Rain / light / wind raw values ─────────────────────────
+        case 0xA9: {
+          if (body.length < 7) return;
+          // body[0]=0xA9, body[1-2]=rain, body[3-4]=light, body[5-6]=wind
+          const rainRaw  = (body[1] << 8) | body[2];
+          const lightRaw = (body[3] << 8) | body[4];
+          const windRaw  = (body[5] << 8) | body[6];
+
+          const payload = {
+            type:  'meteo',
+            rain:  rainRaw  / 10,   // mm/h
+            light: lightRaw,        // lux
+            wind:  windRaw  / 10,   // km/h
+            raw: { rain: rainRaw, light: lightRaw, wind: windRaw },
+          };
+          setStatus('wind:' + payload.wind.toFixed(1) + ' rain:' + payload.rain.toFixed(1));
+          node.send([null, { payload }]);
+          break;
+        }
+
+        // ── 0xAC  Sensor text string ──────────────────────────────────────
+        case 0xAC: {
+          if (body.length < 4) return;
+          // body[0]=0xAC, body[1]=sensor bitmask, body[2]=start position, body[3..]=chars
+          const sensorByte = body[1];
+          const sensor = sensorByte === 0x02 ? 'rain'
+                       : sensorByte === 0x04 ? 'light'
+                       : sensorByte === 0x08 ? 'wind'
+                       : 'unknown';
+          const startPos = body[2];
+          let text = '';
+          for (let i = 3; i < body.length; i++) {
+            if (body[i] === 0) break;
+            text += String.fromCharCode(body[i]);
+          }
+          const payload = { type: 'meteo_text', sensor, startPos, text };
+          node.send([null, { payload }]);
+          break;
+        }
+
+        // ── 0xF0/F1/F2  Alarm channel name parts ─────────────────────────
+        case 0xF0:
+        case 0xF1:
+        case 0xF2: {
+          // body[0]=cmd, body[1]=channel bitmask, body[2..]=chars
+          const mask = body[1];
+          const part = cmd - 0xF0;
+          if (!_nameParts[mask]) _nameParts[mask] = {};
+          _nameParts[mask][part] = Array.from(body).slice(2);
+          if (part === 2) assembleNames();
+          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 temperature — DB2=0x00 means temp, interval in seconds
+      if (cmd === 'get_temp') {
+        const interval = parseInt(msg.payload.interval) || 0;
+        node.bridge.send(pkt(0xF8, node.address, [0xE5, 0x00, interval]));
+        return;
+      }
+
+      // Request sensor (rain/light/wind) — DB2=sensor bitmask, DB3=interval
+      if (cmd === 'get_meteo') {
+        const sensorMap = { rain: 0x02, light: 0x04, wind: 0x08 };
+        const sensor = msg.payload.sensor || 'all';
+        let mask = 0;
+        if (sensor === 'all') {
+          mask = 0x02 | 0x04 | 0x08;
+        } else if (typeof sensor === 'string' && sensorMap[sensor]) {
+          mask = sensorMap[sensor];
+        } else {
+          mask = 0x0E; // all three
+        }
+        const interval = parseInt(msg.payload.interval) || 0;
+        node.bridge.send(pkt(0xF8, node.address, [0xE5, mask, interval]));
+        return;
+      }
+
+      // Request alarm channel name — DB2=channel bitmask
+      if (cmd === 'get_alarm_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;
+      }
+
+      if (cmd === 'test_on')  { node.bridge.send(pkt(0xF8, node.address, [0xB5, 0x01])); return; }
+      if (cmd === 'test_off') { node.bridge.send(pkt(0xF8, node.address, [0xB5, 0x00])); return; }
+
+      node.warn('velbus-meteo: unknown cmd: ' + cmd);
+    });
+
+    // ── Cleanup ───────────────────────────────────────────────────────────
+
+    node.on('close', function() {
+      node.bridge.deregister(node.address, onPacket);
+    });
+
+    setStatus('ready', 'grey', 'dot');
+  }
+
+  RED.nodes.registerType('velbus-meteo', VelbusMeteoNode);
+};

package/nodes/velbus-pir/velbus-pir.html

@@ -0,0 +1,187 @@
+<script type="text/javascript">
+(function() {
+
+  const PIR_TYPES = {
+    0x2A: { name: 'VMBPIRM',    hasTempSensor: false, series: 'original' },
+    0x2B: { name: 'VMBPIRC',    hasTempSensor: false, series: 'original' },
+    0x2C: { name: 'VMBPIRO',    hasTempSensor: true,  series: 'original' },
+    0x23: { name: 'VMBPIRO-10', hasTempSensor: true,  series: '-10'      },
+  };
+
+  RED.nodes.registerType('velbus-pir', {
+    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 / status / light', 'temperature'],
+    icon:    'font-awesome/fa-eye',
+    paletteLabel: 'pir',
+
+    label: function() {
+      const t = this.typeId ? PIR_TYPES[parseInt(this.typeId, 16)] : null;
+      const n = this.name || this.moduleName || (t ? t.name : 'PIR');
+      return n + ' 0x' + (parseInt(this.address) || 0).toString(16).padStart(2,'0').toUpperCase();
+    },
+
+    oneditprepare: function() {
+      const savedAddr   = this.address;
+      const savedTypeId = this.typeId ? parseInt(this.typeId, 16) : null;
+
+      $('#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 : [];
+          if (!modules.length) return;
+
+          const $addr = $('#node-input-address');
+          $addr.empty().append($('<option>').val('').text('— select address —'));
+
+          const pirTypeIds = Object.keys(PIR_TYPES).map(k => parseInt(k));
+          const pirModules = modules.filter(m => pirTypeIds.includes(parseInt(m.typeId, 16)));
+
+          if (!pirModules.length) {
+            $addr.append($('<option>').val('').text('No PIR modules found on bus'));
+            return;
+          }
+
+          pirModules.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) updateHint(parseInt(savedAddr));
+        });
+      }
+
+      function updateHint(addrDec) {
+        const $opt = $('#node-input-address option[value="' + addrDec + '"]');
+        const tid  = $opt.data('typeid');
+        if (tid && PIR_TYPES[tid]) {
+          const t = PIR_TYPES[tid];
+          $('#pir-type-hint').text(
+            t.name + ' · ' + t.series +
+            (t.hasTempSensor ? ' · temperature sensor' : '')
+          ).show();
+          $('#node-input-typeId').val('0x' + tid.toString(16).padStart(2,'0').toUpperCase());
+        } else {
+          $('#pir-type-hint').hide();
+        }
+      }
+
+      $('#node-input-bridge').on('change', function() { populateDropdown($(this).val()); });
+      $('#node-input-address').on('change', function() { updateHint(parseInt($(this).val())); });
+
+      // 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 = PIR_TYPES[parseInt(tid, 16)];
+        if (t) this.moduleName = t.name;
+      }
+    },
+  });
+
+})();
+</script>
+
+<script type="text/html" data-template-name="velbus-pir">
+  <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="pir-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-pir">
+  <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>
+    PIR motion sensor node for Velbus original and -10 series modules.
+    For V2 (-20) series use <strong>velbus-pir-20</strong>.
+  </p>
+
+  <h3>Supported modules</h3>
+  <p>VMBPIRM (0x2A), VMBPIRC (0x2B), VMBPIRO (0x2C), VMBPIRO-10 (0x23).</p>
+  <p>VMBPIRO and VMBPIRO-10 include a temperature sensor — output 2 is active on these types.</p>
+
+  <h3>Output 1 — Channel / status / light</h3>
+  <p>Channel event (0x00):</p>
+  <pre>{
+  "type":        "channel",
+  "on":          true,
+  "pressed":     ["motion1", "dark"],
+  "released":    [],
+  "longPressed": []
+}</pre>
+  <p>Module status (0xED):</p>
+  <pre>{
+  "type":     "status",
+  "on":       true,
+  "channels": { "dark": false, "light": true, "motion1": true, ... },
+  "lightRaw": 1024,
+  "testMode": false,
+  "locked":   { "dark": false, ... },
+  "program":  "summer",
+  "alarms":   { "alarm1Active": false, "alarm2Active": false }
+}</pre>
+  <p>Light value (0xA9):</p>
+  <pre>{ "type": "light", "on": true, "raw": 1024 }</pre>
+
+  <h3>Output 2 — Temperature (VMBPIRO / VMBPIRO-10 only)</h3>
+  <pre>{ "type": "temperature", "current": 21.5, "min": 18.0, "max": 25.0 }</pre>
+  <p>Settings (0xE8):</p>
+  <pre>{ "type": "temp_settings", "calOffset": 0, "calGain": 128, "lowAlarm": 5.0, "highAlarm": 35.0, "zone": 0 }</pre>
+
+  <h3>Input commands</h3>
+  <dl>
+    <dt><code>{ "cmd": "get_status" }</code></dt><dd>Request module status (0xFA).</dd>
+    <dt><code>{ "cmd": "get_light", "interval": 30 }</code></dt><dd>Request light value. interval=0 means no change to auto-send setting.</dd>
+    <dt><code>{ "cmd": "get_temp" }</code></dt><dd>Request temperature (VMBPIRO/VMBPIRO-10 only).</dd>
+    <dt><code>{ "cmd": "get_temp_settings" }</code></dt><dd>Request temperature calibration and alarm settings.</dd>
+    <dt><code>{ "cmd": "test_on" }</code> / <code>{ "cmd": "test_off" }</code></dt><dd>Enable/disable test mode (30 minute timeout).</dd>
+  </dl>
+</script>