node-red-contrib-knx-ultimate/nodes/knxUltimateGarage.js

Control your KNX and KNX Secure intallation via Node-Red! A bunch of KNX nodes, with integrated Philips HUE control and ETS group address importer. Easy to use and highly configurable.

const loggerClass = require('./utils/sysLogger');

module.exports = function (RED) {
  function knxUltimateGarage(config) {
    RED.nodes.createNode(this, config);
    const node = this;

    node.serverKNX = RED.nodes.getNode(config.server) || undefined;

    const pushStatus = (status) => {
      if (!status) return;
      const provider = node.serverKNX;
      if (provider && typeof provider.applyStatusUpdate === 'function') {
        provider.applyStatusUpdate(node, status);
      } else {
        node.status(status);
      }
    };

    if (node.serverKNX === undefined) {
      pushStatus({ fill: 'red', shape: 'dot', text: '[THE GATEWAY NODE HAS BEEN DISABLED]' });
      return;
    }

    node.name = config.name || 'KNX Garage';
    node.outputtopic = config.outputtopic || '';

    node.listenallga = true;
    node.notifyreadrequest = true;
    node.notifyresponse = true;
    node.notifywrite = true;
    node.initialread = false;
    node.outputtype = 'write';
    node.outputRBE = 'false';
    node.inputRBE = 'false';

    try {
      const baseLogLevel = (node.serverKNX && node.serverKNX.loglevel) ? node.serverKNX.loglevel : 'error';
      node.sysLogger = new loggerClass({ loglevel: baseLogLevel, setPrefix: node.type + ' <' + (node.name || node.id || '') + '>' });
    } catch (error) { console.log(error.stack); }

    node.setNodeStatus = ({ fill = 'grey', shape = 'ring', text: statusText = '', payload = '', GA = '', dpt = '', devicename = '' }) => {
      try {
        if (!node.serverKNX) {
          pushStatus({ fill: 'red', shape: 'dot', text: '[NO GATEWAY SELECTED]' });
          return;
        }
        const dDate = new Date();
        const gaLabel = GA ? `(${GA}) ` : '';
        const deviceLabel = devicename ? ` ${devicename}` : '';
        const dptLabel = dpt ? ` DPT${dpt}` : '';
        let payloadLabel = '';
        if (payload !== undefined && payload !== null && payload !== '') {
          payloadLabel = typeof payload === 'object' ? JSON.stringify(payload) : `${payload}`;
        }
        const composed = `${gaLabel}${payloadLabel}${deviceLabel}${dptLabel} (day ${dDate.getDate()}, ${dDate.toLocaleTimeString()}) ${statusText}`.trim();
        pushStatus({ fill, shape, text: composed });
        if (fill && fill.toUpperCase() === 'RED' && node.serverKNX && typeof node.serverKNX.reportToWatchdogCalledByKNXUltimateNode === 'function') {
          node.serverKNX.reportToWatchdogCalledByKNXUltimateNode({ nodeid: node.id, topic: node.outputtopic, devicename, GA, text: statusText });
        }
      } catch (error) {
        if (node.sysLogger) node.sysLogger.error(`Status update failed: ${error.message}`);
      }
    };

    const MOVEMENT_PULSE_MS = 1500;

    const boolFromConfig = (value) => (value === true || value === 'true');
    const boolFromPayload = (value) => {
      if (typeof value === 'boolean') return value;
      if (typeof value === 'number') return value !== 0;
      if (typeof value === 'string') {
        const trimmed = value.trim().toLowerCase();
        if (trimmed === 'true' || trimmed === '1' || trimmed === 'on' || trimmed === 'open') return true;
        if (trimmed === 'false' || trimmed === '0' || trimmed === 'off' || trimmed === 'close' || trimmed === 'closed') return false;
      }
      if (value && typeof value === 'object') {
        if (Object.prototype.hasOwnProperty.call(value, 'value')) return boolFromPayload(value.value);
        if (Object.prototype.hasOwnProperty.call(value, 'state')) return boolFromPayload(value.state);
      }
      return false;
    };

    const safeSendToKNX = (telegram, context = 'write') => {
      try {
        if (!node.serverKNX) return;
        node.serverKNX.sendKNXTelegramToKNXEngine({ ...telegram, nodecallerid: node.id });
      } catch (error) {
        if (node.sysLogger) {
          node.sysLogger.error(`Garage send failed (${context}): ${error.message}`);
        } else {
          RED.log.error(`knxUltimateGarage send failed (${context}): ${error.message}`);
        }
      }
    };

    const emitEvent = (event, payload = {}) => {
      if (!node.emitEvents) return;
      node.send([
        {
          topic: node.outputtopic || node.gaCommand || node.name,
          event,
          payload,
          state: node.doorState,
          disabled: node.disabled,
          holdOpen: node.holdOpenActive,
          obstruction: node.obstructionActive
        }
      ]);
    };

    node.gaCommand = (config.gaCommand || '').trim();
    node.dptCommand = config.dptCommand || '1.001';
    node.gaImpulse = (config.gaImpulse || '').trim();
    node.dptImpulse = config.dptImpulse || '1.017';
    node.gaHoldOpen = (config.gaHoldOpen || '').trim();
    node.dptHoldOpen = config.dptHoldOpen || '1.001';
    node.gaDisable = (config.gaDisable || '').trim();
    node.dptDisable = config.dptDisable || '1.001';
    node.gaPhotocell = (config.gaPhotocell || '').trim();
    node.dptPhotocell = config.dptPhotocell || '1.001';
    node.gaMoving = (config.gaMoving || '').trim();
    node.dptMoving = config.dptMoving || '1.001';
    node.gaObstruction = (config.gaObstruction || '').trim();
    node.dptObstruction = config.dptObstruction || '1.001';

    node.nameCommandGA = config.nameCommand || '';
    node.nameImpulseGA = config.nameImpulse || '';
    node.nameHoldOpenGA = config.nameHoldOpen || '';
    node.nameDisableGA = config.nameDisable || '';
    node.namePhotocellGA = config.namePhotocell || '';
    node.nameMovingGA = config.nameMoving || '';
    node.nameObstructionGA = config.nameObstruction || '';

    node.autoCloseEnabled = boolFromConfig(config.autoCloseEnable);
    node.autoCloseSeconds = Math.max(0, Number(config.autoCloseSeconds || 0));
    node.emitEvents = boolFromConfig(config.emitEvents);

    node.disabled = false;
    node.holdOpenActive = false;
    node.obstructionActive = false;
    node.photocellActive = false;
    node.doorState = 'closed';
    node.autoCloseTimer = null;
    node.autoCloseDeadline = 0;
    node.movementTimer = null;
    node.lastImpulseValue = false;
    node.commandEchoBlockUntil = 0;
    node.impulseEchoBlockUntil = 0;

    const cancelAutoClose = () => {
      if (node.autoCloseTimer) {
        clearTimeout(node.autoCloseTimer);
        node.autoCloseTimer = null;
      }
      node.autoCloseDeadline = 0;
    };

    const setMovement = (active, reason = '') => {
      if (node.gaMoving === '') return;
      safeSendToKNX({ grpaddr: node.gaMoving, payload: !!active, dpt: node.dptMoving, outputtype: 'write' }, reason || 'movement');
    };

    const scheduleMovementPulse = () => {
      if (node.gaMoving === '') return;
      setMovement(true, 'movement-start');
      if (node.movementTimer) clearTimeout(node.movementTimer);
      node.movementTimer = setTimeout(() => {
        setMovement(false, 'movement-stop');
        node.movementTimer = null;
      }, MOVEMENT_PULSE_MS);
    };

    const setObstruction = (active, reason = '') => {
      if (node.obstructionActive === active) return;
      node.obstructionActive = active;
      if (node.gaObstruction !== '') {
        safeSendToKNX({ grpaddr: node.gaObstruction, payload: !!active, dpt: node.dptObstruction, outputtype: 'write' }, reason || 'obstruction');
      }
      emitEvent('obstruction', { active, reason });
      updateStatus();
    };

    const scheduleAutoClose = () => {
      cancelAutoClose();
      if (node.doorState !== 'open') return;
      if (!node.autoCloseEnabled) return;
      if (node.autoCloseSeconds <= 0) return;
      if (node.holdOpenActive) return;
      if (node.disabled) return;
      node.autoCloseDeadline = Date.now() + node.autoCloseSeconds * 1000;
      node.autoCloseTimer = setTimeout(() => {
        node.autoCloseTimer = null;
        node.autoCloseDeadline = 0;
        closeDoor('auto-close');
      }, node.autoCloseSeconds * 1000);
      updateStatus();
    };

    const updateStatus = (override = null) => {
      if (override) {
        node.setNodeStatus(override);
        return;
      }
      if (node.disabled) {
        node.setNodeStatus({ fill: 'grey', shape: 'ring', text: 'Disabled', payload: true, GA: node.gaDisable, dpt: node.dptDisable, devicename: node.nameDisableGA });
        return;
      }
      if (node.obstructionActive) {
        node.setNodeStatus({ fill: 'red', shape: 'dot', text: 'Obstruction', payload: true, GA: node.gaObstruction, dpt: node.dptObstruction, devicename: node.nameObstructionGA });
        return;
      }
      const holdText = node.holdOpenActive ? ' (hold)' : '';
      switch (node.doorState) {
        case 'opening':
          node.setNodeStatus({ fill: 'green', shape: 'dot', text: 'Opening' + holdText, payload: true, GA: node.gaCommand, dpt: node.dptCommand, devicename: node.nameCommandGA });
          break;
        case 'open': {
          if (node.autoCloseTimer && node.autoCloseDeadline > Date.now()) {
            const remaining = Math.max(0, Math.round((node.autoCloseDeadline - Date.now()) / 1000));
            node.setNodeStatus({ fill: 'green', shape: 'ring', text: `Open (${remaining}s)` + holdText, payload: true, GA: node.gaCommand, dpt: node.dptCommand, devicename: node.nameCommandGA });
          } else {
            node.setNodeStatus({ fill: 'green', shape: 'ring', text: 'Open' + holdText, payload: true, GA: node.gaCommand, dpt: node.dptCommand, devicename: node.nameCommandGA });
          }
          break;
        }
        case 'closing':
          node.setNodeStatus({ fill: 'yellow', shape: 'dot', text: 'Closing', GA: node.gaCommand, dpt: node.dptCommand, devicename: node.nameCommandGA });
          break;
        case 'closed':
          node.setNodeStatus({ fill: 'blue', shape: 'ring', text: 'Closed', payload: false, GA: node.gaCommand, dpt: node.dptCommand, devicename: node.nameCommandGA });
          break;
        default:
          node.setNodeStatus({ fill: 'blue', shape: 'ring', text: node.doorState || 'Idle', GA: node.gaCommand });
      }
    };

    const finishMovement = (targetState) => {
      if (node.movementTimer) {
        clearTimeout(node.movementTimer);
        node.movementTimer = null;
      }
      if (node.gaMoving !== '') setMovement(false, 'movement-finish');
      node.doorState = targetState;
      if (targetState === 'open') scheduleAutoClose();
      updateStatus();
    };

    const openDoor = (source, { skipSend = false } = {}) => {
      if (node.disabled) {
        emitEvent('blocked', { reason: 'disabled', request: 'open', source });
        updateStatus({ fill: 'grey', shape: 'ring', text: 'Disabled', GA: node.gaDisable, dpt: node.dptDisable, devicename: node.nameDisableGA, payload: node.disabled });
        return;
      }
      cancelAutoClose();
      node.doorState = 'opening';
      if (!skipSend) {
        if (node.gaCommand !== '') {
          safeSendToKNX({ grpaddr: node.gaCommand, payload: true, dpt: node.dptCommand, outputtype: 'write' }, source || 'open');
          node.commandEchoBlockUntil = Date.now() + 500;
        } else if (node.gaImpulse !== '') {
          triggerImpulse('open');
        }
      }
      if (node.gaMoving !== '') scheduleMovementPulse();
      setTimeout(() => finishMovement('open'), 300);
      emitEvent('open', { source });
    };

    const closeDoor = (source, { skipSend = false } = {}) => {
      if (node.disabled) {
        emitEvent('blocked', { reason: 'disabled', request: 'close', source });
        updateStatus({ fill: 'grey', shape: 'ring', text: 'Disabled', GA: node.gaDisable, dpt: node.dptDisable, devicename: node.nameDisableGA, payload: node.disabled });
        return;
      }
      if (node.holdOpenActive) {
        emitEvent('blocked', { reason: 'hold-open', request: 'close', source });
        scheduleAutoClose();
        return;
      }
      node.doorState = 'closing';
      if (!skipSend) {
        if (node.gaCommand !== '') {
          safeSendToKNX({ grpaddr: node.gaCommand, payload: false, dpt: node.dptCommand, outputtype: 'write' }, source || 'close');
          node.commandEchoBlockUntil = Date.now() + 500;
        } else if (node.gaImpulse !== '') {
          triggerImpulse('close');
        }
      }
      if (node.gaMoving !== '') scheduleMovementPulse();
      setTimeout(() => finishMovement('closed'), 300);
      emitEvent('close', { source });
    };

    const triggerImpulse = (source) => {
      if (node.gaImpulse === '') return;
      safeSendToKNX({ grpaddr: node.gaImpulse, payload: true, dpt: node.dptImpulse, outputtype: 'write' }, source || 'impulse');
      node.impulseEchoBlockUntil = Date.now() + 500;
      setTimeout(() => {
        safeSendToKNX({ grpaddr: node.gaImpulse, payload: false, dpt: node.dptImpulse, outputtype: 'write' }, 'impulse-reset');
      }, 250);
    };

    const toggleDoor = (source, { skipSend = false } = {}) => {
      if (node.doorState === 'open' || node.doorState === 'opening') {
        closeDoor(source, { skipSend });
      } else {
        openDoor(source, { skipSend });
      }
    };

    const handleHoldOpen = (value) => {
      const newState = !!value;
      if (node.holdOpenActive === newState) return;
      node.holdOpenActive = newState;
      if (node.holdOpenActive) {
        cancelAutoClose();
        emitEvent('hold-open', { active: true });
      } else {
        if (node.doorState === 'open') scheduleAutoClose();
        emitEvent('hold-open', { active: false });
      }
      updateStatus();
    };

    const handleDisable = (value) => {
      const newState = !!value;
      if (node.disabled === newState) return;
      node.disabled = newState;
      if (node.disabled) {
        cancelAutoClose();
        emitEvent('disabled', { active: true });
      } else {
        if (node.doorState === 'open') scheduleAutoClose();
        emitEvent('disabled', { active: false });
      }
      updateStatus();
    };

    const handlePhotocell = (value) => {
      const newState = !!value;
      node.photocellActive = newState;
      if (newState) {
        setObstruction(true, 'photocell');
        if (node.doorState === 'closing') {
          openDoor('photocell');
        } else {
          updateStatus();
        }
      } else {
        setObstruction(false, 'photocell-clear');
      }
    };

    const handleCommandIncoming = (value) => {
      const boolValue = !!value;
      if (node.commandEchoBlockUntil > Date.now()) return;
      if (boolValue) {
        openDoor('command', { skipSend: true });
      } else {
        closeDoor('command', { skipSend: true });
      }
    };

    const handleImpulseIncoming = (value) => {
      const current = !!value;
      if (node.impulseEchoBlockUntil > Date.now()) {
        node.lastImpulseValue = current;
        return;
      }
      if (node.lastImpulseValue === current) return;
      node.lastImpulseValue = current;
      if (!current) return; // rising edge only
      toggleDoor('impulse', { skipSend: true });
    };

    const respondToRead = (destination) => {
      const respond = (ga, payload, dpt) => {
        if (ga === '') return;
        safeSendToKNX({ grpaddr: ga, payload, dpt, outputtype: 'response' }, 'read-response');
      };
      if (destination === node.gaCommand) {
        respond(node.gaCommand, node.doorState === 'open', node.dptCommand);
        return true;
      }
      if (destination === node.gaHoldOpen) {
        respond(node.gaHoldOpen, node.holdOpenActive, node.dptHoldOpen);
        return true;
      }
      if (destination === node.gaDisable) {
        respond(node.gaDisable, node.disabled, node.dptDisable);
        return true;
      }
      if (destination === node.gaPhotocell) {
        respond(node.gaPhotocell, node.photocellActive, node.dptPhotocell);
        return true;
      }
      if (destination === node.gaMoving) {
        respond(node.gaMoving, !!node.movementTimer, node.dptMoving);
        return true;
      }
      if (destination === node.gaObstruction) {
        respond(node.gaObstruction, node.obstructionActive, node.dptObstruction);
        return true;
      }
      return false;
    };

    node.handleSend = (msg) => {
      try {
        if (!msg || !msg.knx || !msg.knx.destination) return;
        const dest = msg.knx.destination;
        if (msg.knx.event === 'GroupValue_Read') {
          respondToRead(dest);
          return;
        }
        if (dest === node.gaCommand) {
          handleCommandIncoming(boolFromPayload(msg.payload));
          return;
        }
        if (dest === node.gaImpulse) {
          handleImpulseIncoming(boolFromPayload(msg.payload));
          return;
        }
        if (dest === node.gaHoldOpen) {
          handleHoldOpen(boolFromPayload(msg.payload));
          return;
        }
        if (dest === node.gaDisable) {
          handleDisable(boolFromPayload(msg.payload));
          return;
        }
        if (dest === node.gaPhotocell) {
          handlePhotocell(boolFromPayload(msg.payload));
          return;
        }
        if (dest === node.gaObstruction) {
          setObstruction(boolFromPayload(msg.payload), 'external');
          return;
        }
        if (dest === node.gaMoving) {
          const active = boolFromPayload(msg.payload);
          if (active) {
            node.doorState = 'moving';
          }
          updateStatus();
        }
      } catch (error) {
        if (node.sysLogger) {
          node.sysLogger.error(`Garage handleSend error: ${error.message}`);
        } else {
          RED.log.error(`knxUltimateGarage handleSend error: ${error.message}`);
        }
      }
    };

    node.on('input', (msg, send, done) => {
      try {
        const payload = msg.payload;
        if (payload === undefined || payload === null) {
          if (done) done();
          return;
        }
        if (typeof payload === 'string') {
          const lowered = payload.trim().toLowerCase();
          if (lowered === 'open') {
            openDoor('flow');
          } else if (lowered === 'close') {
            closeDoor('flow');
          } else if (lowered === 'toggle') {
            toggleDoor('flow');
          } else {
            if (boolFromPayload(payload)) openDoor('flow'); else closeDoor('flow');
          }
        } else if (typeof payload === 'boolean' || typeof payload === 'number' || typeof payload === 'object') {
          if (boolFromPayload(payload)) openDoor('flow'); else closeDoor('flow');
        }
        if (done) done();
      } catch (error) {
        if (node.sysLogger) {
          node.sysLogger.error(`Garage onInput error: ${error.message}`);
        } else {
          RED.log.error(`knxUltimateGarage onInput error: ${error.message}`);
        }
        if (done) done(error);
      }
    });

    updateStatus();

    scheduleAutoClose();

    node.on('close', (done) => {
      cancelAutoClose();
      if (node.movementTimer) clearTimeout(node.movementTimer);
      done();
    });
  }

  RED.nodes.registerType('knxUltimateGarage', knxUltimateGarage);
};