node-red-contrib-dmx-for-ha 0.1.0

package/nodes/ha-mqtt-dmx.js

@@ -0,0 +1,537 @@
+// ============================================================
+// ha-mqtt-dmx — DMX Fixture Node Runtime
+// Package: node-red-contrib-dmx-for-ha
+// Author:  DeSwaggy — Discord: @deswaggy
+// ============================================================
+
+module.exports = function (RED) {
+
+    // ── Gamma correction table ────────────────────────────────────
+    // Pre-computed CIE 1931 gamma 2.2 lookup — 0..255 → 0..255
+    const GAMMA_TABLE = (function () {
+        const t = new Array(256);
+        for (let i = 0; i < 256; i++) {
+            t[i] = Math.round(Math.pow(i / 255, 2.2) * 255);
+        }
+        return t;
+    })();
+
+    function HaMqttDmxNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // ── Config & broker ───────────────────────────────────────
+        const cfg = RED.nodes.getNode(config.config);
+        if (!cfg) { node.error('DMX: no config node selected'); return; }
+
+        const broker = RED.nodes.getNode(cfg.broker);
+        if (!broker) { node.error('DMX: no MQTT broker in config'); return; }
+
+        broker.register(node);
+
+        // ── Node settings ─────────────────────────────────────────
+        const S = {
+            uidPrefix:     config.uidPrefix    || 'L',
+            uid:           config.uid          || '',
+            uidPostfix:    config.uidPostfix    || '',
+            deviceType:    config.deviceType    || 'Downlight',
+            colorMode:     config.colorMode     || 'rgbw',
+            area:          config.area          || '',
+            situation:     config.situation      || 'in',
+            subLocation:   config.subLocation    || '',
+            ch: {
+                red:      parseInt(config.chRed)      || 0,
+                green:    parseInt(config.chGreen)    || 0,
+                blue:     parseInt(config.chBlue)     || 0,
+                white:    parseInt(config.chWhite)    || 0,
+                warmWhite:parseInt(config.chWarmWhite)|| 0,
+            },
+            controllerNum: config.controllerNum  || '1',
+            universe:      config.universe        || '1',
+            haIcon:        config.haIcon          || 'mdi:lightbulb',
+            showEffects:   config.showEffects     !== false,
+            transitions:   config.transitions     !== false,
+            groupSync:     config.groupSync       === true,
+            defaultState:  config.defaultState    || 'OFF',
+            dmxLimiter:    parseInt(config.dmxLimiter)  || 255,
+            minOutput:     parseInt(config.minOutput)   || 1,
+            brightBump:    parseInt(config.brightBump)  || 50,
+            ticksPerSec:   parseInt(config.ticksPerSec) || 31,
+            flashShort:    cfg.flashShort,
+            flashLong:     cfg.flashLong,
+            diskDelay:     cfg.diskDelay,
+        };
+
+        const fixtureId    = `${S.uidPrefix}-${S.uid}${S.uidPostfix}`;
+        const objectId     = `${S.uidPrefix}_${S.uid}${S.uidPostfix}`.toLowerCase().replace(/[^a-z0-9_]/g, '_');
+        const fixtureTopic = `${cfg.discoveryPrefix}/light/${fixtureId}`;
+        const cfgTopic     = `${fixtureTopic}/${cfg.configTopic}`;
+        const statTopic    = `${fixtureTopic}/${cfg.stateTopic}`;
+        const cmdTopic     = `${fixtureTopic}/${cfg.commandTopic}`;
+        const dmxTopic     = `${cfg.siteId}/${cfg.zone}/dmx/${S.universe}`;
+
+        // ── Context helpers ───────────────────────────────────────
+        function ctxGet(key, store) {
+            try { return node.context().get(key, store); }
+            catch(e) { return node.context().get(key); }
+        }
+        function ctxSet(key, val, store) {
+            try { node.context().set(key, val, store); }
+            catch(e) { node.context().set(key, val); }
+        }
+        function recall(ramKey, diskKey, fallback) {
+            const v = ctxGet(ramKey) ?? ctxGet(ramKey, 'disk');
+            return v !== null && v !== undefined ? v : fallback;
+        }
+
+        // ── Disk save timer ───────────────────────────────────────
+        let diskTimer = null;
+        function startDiskSave(onComplete) {
+            if (diskTimer) { clearTimeout(diskTimer); diskTimer = null; }
+            diskTimer = setTimeout(() => { diskTimer = null; onComplete(); }, S.diskDelay * 1000);
+        }
+
+        // ── DMX helpers ───────────────────────────────────────────
+        function scaleToDmx(colorValue, brightness) {
+            brightness = brightness !== undefined ? brightness : 255;
+            const limited = Math.round((colorValue / 255) * (brightness / 255) * S.dmxLimiter);
+            const gamma   = GAMMA_TABLE[Math.max(0, Math.min(255, limited))];
+            // Min output floor — only apply when both inputs are non-zero (intentionally on)
+            if (gamma === 0 && colorValue > 0 && brightness > 0 && S.minOutput > 0) {
+                return S.minOutput;
+            }
+            return gamma;
+        }
+
+        function buildDmxPayload(channel, value) {
+            if (channel == null || value == null) return null;
+            return String(channel).padStart(3, '0') + String(value).padStart(3, '0');
+        }
+
+        function sendDmxChannels(channels) {
+            channels.forEach(function ([ch, val]) {
+                const payload = buildDmxPayload(ch, val);
+                if (payload === null) return;
+                broker.publish({ topic: dmxTopic, payload, qos: cfg.qos, retain: false });
+            });
+        }
+
+        // ── MQTT helpers ──────────────────────────────────────────
+        function pub(topic, payload, retain) {
+            broker.publish({
+                topic,
+                payload: typeof payload === 'object' ? JSON.stringify(payload) : String(payload),
+                qos:    cfg.qos,
+                retain: retain !== undefined ? retain : cfg.retain,
+            });
+        }
+
+        function pubState(payload) {
+            pub(statTopic, JSON.stringify(payload), false);
+        }
+
+        function setStatus(fill, shape, text) {
+            node.status({ fill, shape, text });
+        }
+
+        // ── Effects ───────────────────────────────────────────────
+        let effectTimer   = null;
+        let preEffectState = null;
+
+        function stopEffect() {
+            if (effectTimer) {
+                clearInterval(effectTimer); clearTimeout(effectTimer);
+                effectTimer = null;
+            }
+        }
+
+        function savePreEffectState() {
+            preEffectState = {
+                state:      ctxGet('state'),
+                brightness: ctxGet('brightness'),
+                red:        ctxGet('red'),
+                green:      ctxGet('green'),
+                blue:       ctxGet('blue'),
+                white:      ctxGet('white'),
+                warmWhite:  ctxGet('warmWhite'),
+            };
+        }
+
+        function restoreAfterEffect() {
+            if (!preEffectState) return;
+            const p = preEffectState;
+            preEffectState = null;
+            const channels = buildColorChannels(
+                p.brightness || 255, p.red || 255, p.green || 255,
+                p.blue || 255, p.white || 255, p.warmWhite || 0
+            );
+            sendDmxChannels(channels);
+            pubState({ state: p.state || 'OFF', color_mode: S.colorMode });
+            setStatus('yellow', 'ring', `${fixtureId} ready — awaiting HA`);
+        }
+
+        function startEffect(label, intervalMs, tickFn) {
+            stopEffect();
+            savePreEffectState();
+            setStatus('blue', 'dot', `${fixtureId} effect: ${label}`);
+            effectTimer = setInterval(tickFn, intervalMs);
+        }
+
+        // ── Color channel builder ─────────────────────────────────
+        function buildColorChannels(brightness, r, g, b, w, ww) {
+            const mode = S.colorMode;
+            if (mode === 'rgbw')       return [[S.ch.red,scaleToDmx(r,brightness)],[S.ch.green,scaleToDmx(g,brightness)],[S.ch.blue,scaleToDmx(b,brightness)],[S.ch.white,scaleToDmx(w,brightness)]];
+            if (mode === 'rgbww')      return [[S.ch.red,scaleToDmx(r,brightness)],[S.ch.green,scaleToDmx(g,brightness)],[S.ch.blue,scaleToDmx(b,brightness)],[S.ch.white,scaleToDmx(w,brightness)],[S.ch.warmWhite,scaleToDmx(ww,brightness)]];
+            if (mode === 'rgb')        return [[S.ch.red,scaleToDmx(r,brightness)],[S.ch.green,scaleToDmx(g,brightness)],[S.ch.blue,scaleToDmx(b,brightness)]];
+            if (mode === 'color_temp') return [[S.ch.white,scaleToDmx(w,brightness)],[S.ch.warmWhite,scaleToDmx(ww,brightness)]];
+            if (mode === 'brightness') return [[S.ch.white,scaleToDmx(255,brightness)]];
+            if (mode === 'onoff')      return [[S.ch.white,scaleToDmx(255,brightness)]];
+            return [];
+        }
+
+        // ── Initial bump ──────────────────────────────────────────
+        function sendInitialBump(targetChannels) {
+            const prevState = recall('state', 'state_disk', S.defaultState);
+            if (prevState !== 'OFF' || !S.brightBump || S.brightBump <= 0) return 0;
+            const bumpDmx = GAMMA_TABLE[Math.min(255, S.brightBump)];
+            targetChannels.forEach(function ([ch, to]) {
+                if (to > 0) sendDmxChannels([[ch, Math.min(bumpDmx, to)]]);
+            });
+            return bumpDmx;
+        }
+
+        // ── Transition ────────────────────────────────────────────
+        function runTransition(fromChannels, toChannels, durationSecs) {
+            stopEffect();
+            const totalTicks = Math.round(durationSecs * S.ticksPerSec);
+            const intervalMs = Math.round(1000 / S.ticksPerSec);
+            let tick = 0;
+
+            effectTimer = setInterval(function () {
+                tick++;
+                const progress = Math.min(1, tick / totalTicks);
+                const channels = fromChannels.map(function ([ch, from], i) {
+                    const to  = toChannels[i] ? toChannels[i][1] : 0;
+                    return [ch, Math.round(from + (to - from) * progress)];
+                });
+                sendDmxChannels(channels);
+                if (tick >= totalTicks) {
+                    stopEffect();
+                    sendDmxChannels(toChannels);
+                }
+            }, intervalMs);
+        }
+
+        // ── State persistence ─────────────────────────────────────
+        function saveState(state, brightness, r, g, b, w, ww) {
+            ctxSet('state',      state);
+            ctxSet('brightness', brightness);
+            ctxSet('red',   r); ctxSet('green', g); ctxSet('blue', b);
+            ctxSet('white', w); ctxSet('warmWhite', ww);
+            startDiskSave(function () {
+                ctxSet('state',      state,      'disk');
+                ctxSet('brightness', brightness, 'disk');
+                ctxSet('red',   r, 'disk'); ctxSet('green', g, 'disk');
+                ctxSet('blue',  b, 'disk'); ctxSet('white', w, 'disk');
+                ctxSet('warmWhite', ww, 'disk');
+                node.log(`${fixtureId} disk saved — state:${state}`);
+            });
+        }
+
+        // ── ON handler ────────────────────────────────────────────
+        function handleON(payload) {
+            stopEffect();
+            const brightness = payload.brightness  !== undefined ? payload.brightness : (recall('brightness','brightness_disk',255));
+            const color      = payload.color        || {};
+            const r  = color.r !== undefined ? color.r : recall('red',      'red_disk',      255);
+            const g  = color.g !== undefined ? color.g : recall('green',    'green_disk',    255);
+            const b  = color.b !== undefined ? color.b : recall('blue',     'blue_disk',     255);
+            const w  = color.w !== undefined ? color.w : recall('white',    'white_disk',    255);
+            const ww = color.ww!== undefined ? color.ww: recall('warmWhite','warmWhite_disk', 0);
+
+            const toChannels = buildColorChannels(brightness, r, g, b, w, ww);
+
+            if (S.transitions && payload.transition && payload.transition > 0) {
+                const bump        = sendInitialBump(toChannels);
+                const prevBright  = recall('brightness', 'brightness_disk', 0);
+                const prevR       = recall('red',   'red_disk',   S.brightBump || r);
+                const prevG       = recall('green', 'green_disk', S.brightBump || g);
+                const prevB       = recall('blue',  'blue_disk',  S.brightBump || b);
+                const prevW       = recall('white', 'white_disk', S.brightBump || w);
+                const prevWW      = recall('warmWhite','warmWhite_disk', 0);
+                const fromChannels = buildColorChannels(
+                    bump || prevBright, prevR, prevG, prevB, prevW, prevWW
+                );
+                runTransition(fromChannels, toChannels, payload.transition);
+            } else {
+                sendInitialBump(toChannels);
+                sendDmxChannels(toChannels);
+            }
+
+            saveState('ON', brightness, r, g, b, w, ww);
+            pubState({ state: 'ON', color_mode: S.colorMode, brightness, color: { r, g, b, w, ww } });
+            setStatus('green', 'dot', `${fixtureId} ON  bright:${brightness}`);
+        }
+
+        // ── OFF handler ───────────────────────────────────────────
+        function handleOFF(payload) {
+            stopEffect();
+            const brightness = recall('brightness', 'brightness_disk', 255);
+            const r  = recall('red',       'red_disk',       255);
+            const g  = recall('green',     'green_disk',     255);
+            const b  = recall('blue',      'blue_disk',      255);
+            const w  = recall('white',     'white_disk',     255);
+            const ww = recall('warmWhite', 'warmWhite_disk', 0);
+
+            const toChannels   = buildColorChannels(0, r, g, b, w, ww);
+
+            if (S.transitions && payload && payload.transition && payload.transition > 0) {
+                const fromChannels = buildColorChannels(brightness, r, g, b, w, ww);
+                runTransition(fromChannels, toChannels, payload.transition);
+            } else {
+                sendDmxChannels(toChannels);
+            }
+
+            saveState('OFF', brightness, r, g, b, w, ww);
+            pubState({ state: 'OFF', color_mode: S.colorMode });
+            setStatus('grey', 'ring', `${fixtureId} OFF`);
+        }
+
+        // ── Effect dispatch ───────────────────────────────────────
+        function runEffect(effectName) {
+            if (effectName === 'none') {
+                stopEffect();
+                restoreAfterEffect();
+                return;
+            }
+            // Flash effects
+            if (effectName === 'flash_short' || effectName === 'flash_long') {
+                const dur = effectName === 'flash_short' ? S.flashShort : S.flashLong;
+                stopEffect(); savePreEffectState();
+                const allOn  = buildColorChannels(255,255,255,255,255,255);
+                const allOff = buildColorChannels(0,0,0,0,0,0);
+                sendDmxChannels(allOn);
+                effectTimer = setTimeout(() => { effectTimer = null; sendDmxChannels(allOff); restoreAfterEffect(); }, dur * 1000);
+                return;
+            }
+            // Strobe
+            if (effectName === 'strobe') {
+                let on = false;
+                startEffect('strobe', 100, () => { on = !on; sendDmxChannels(buildColorChannels(on ? 255 : 0, 255,255,255,255,255)); });
+                return;
+            }
+            // Rainbow
+            if (effectName === 'rainbow') {
+                let deg = 0;
+                startEffect('Rainbow', Math.round(1000 / S.ticksPerSec), () => {
+                    deg = (deg + 360 / (S.ticksPerSec * 3)) % 360;
+                    const [r,g,b] = hsvToRgb(deg, 1, 1);
+                    sendDmxChannels(buildColorChannels(255, r, g, b, 0, 0));
+                });
+                return;
+            }
+            // Rainbow RGBW
+            if (effectName === 'rainbow_rgbw') {
+                let deg = 0;
+                startEffect('Rainbow RGBW', Math.round(1000 / S.ticksPerSec), () => {
+                    deg = (deg + 360 / (S.ticksPerSec * 3)) % 360;
+                    const [r,g,b] = hsvToRgb(deg, 1, 1);
+                    const w = Math.round(255 * Math.abs(Math.sin(deg * Math.PI / 180)));
+                    sendDmxChannels(buildColorChannels(255, r, g, b, w, 0));
+                });
+                return;
+            }
+            // Fire
+            if (effectName === 'fire') {
+                startEffect('Fire', 80, () => {
+                    const r = 200 + Math.floor(Math.random() * 55);
+                    const g = Math.floor(Math.random() * 80);
+                    sendDmxChannels(buildColorChannels(255, r, g, 0, 0, 0));
+                });
+                return;
+            }
+            // Flicker
+            if (effectName === 'flicker') {
+                startEffect('Flicker', 120, () => {
+                    const bright = 180 + Math.floor(Math.random() * 75);
+                    sendDmxChannels(buildColorChannels(bright, 255, 180, 50, 200, 0));
+                });
+                return;
+            }
+            // Twinkle
+            if (effectName === 'twinkle') {
+                let dir = 1; let bright = 0;
+                startEffect('Twinkle', Math.round(1000 / S.ticksPerSec), () => {
+                    bright = Math.max(0, Math.min(255, bright + dir * 8));
+                    if (bright >= 255 || bright <= 0) dir = -dir;
+                    sendDmxChannels(buildColorChannels(bright, 255, 255, 255, 255, 0));
+                });
+                return;
+            }
+            // Police
+            if (effectName === 'police') {
+                let tick = 0;
+                startEffect('Police', 150, () => {
+                    tick++;
+                    const isRed = (tick % 4) < 2;
+                    sendDmxChannels(buildColorChannels(255, isRed ? 255 : 0, 0, isRed ? 0 : 255, 0, 0));
+                });
+                return;
+            }
+            node.warn(`${fixtureId} — unknown effect: "${effectName}"`);
+        }
+
+        // ── HSV helper ────────────────────────────────────────────
+        function hsvToRgb(h, s, v) {
+            const i = Math.floor(h / 60) % 6;
+            const f = h / 60 - Math.floor(h / 60);
+            const p = Math.round(v * (1 - s) * 255);
+            const q = Math.round(v * (1 - f * s) * 255);
+            const t = Math.round(v * (1 - (1 - f) * s) * 255);
+            const vv = Math.round(v * 255);
+            return [[vv,t,p],[q,vv,p],[p,vv,t],[p,q,vv],[t,p,vv],[vv,p,q]][i];
+        }
+
+        // ── Device add ────────────────────────────────────────────
+        function handleDeviceAdd() {
+            if (ctxGet('state') === undefined && ctxGet('state', 'disk') === undefined) {
+                ctxSet('state', S.defaultState);
+            }
+
+            const effectList = S.showEffects ? [
+                'none','flash_short','flash_long','strobe','rainbow','rainbow_rgbw',
+                'fire','flicker','twinkle','police',
+            ] : [];
+
+            const discovery = {
+                unique_id:              `${S.deviceType}(${fixtureId})`,
+                schema:                 'json',
+                object_id:              objectId,
+                optimistic:             false,
+                enabled_by_default:     cfg.enabledDefault,
+                icon:                   S.haIcon,
+                supported_color_modes:  [S.colorMode],
+                brightness:             true,
+                brightness_scale:       255,
+                effect:                 S.showEffects,
+                effect_list:            effectList,
+                flash_time_short:       S.flashShort,
+                flash_time_long:        S.flashLong,
+                min_mireds:             153,
+                max_mireds:             500,
+                stat_t:                 statTopic,
+                cmd_t:                  cmdTopic,
+                name:                   `${S.deviceType} ${S.situation} the ${cfg.zone} ${S.area} ${S.subLocation}`,
+                device: {
+                    identifiers:    `light-${fixtureId}`,
+                    name:           `(${fixtureId}) - ${S.deviceType} ${S.situation} the ${cfg.zone} - ${S.area} - ${S.subLocation}`,
+                    model:          `${S.colorMode} ${S.deviceType} located ${S.situation} the ${cfg.zone} - ${S.area}`,
+                    model_id:       `referenced on plan as: (${fixtureId}`,
+                    suggested_area: `${cfg.zone} ${S.area} ${S.subLocation}`,
+                    hw_version:     `DMX Controller in ${cfg.zone}. MQTT: ${dmxTopic}`,
+                    serial_number:  fixtureId,
+                    sw_version:     'ha-mqtt-dmx: 0.1.0',
+                    manufacturer:   'DeSwaggy — Discord: @deswaggy',
+                },
+            };
+
+            pub(cfgTopic, discovery, true);
+
+            broker.subscribe(cmdTopic, cfg.qos, function (topic, rawPayload) {
+                let payload;
+                try { payload = JSON.parse(rawPayload.toString()); }
+                catch(e) { node.warn(`${fixtureId} — failed to parse HA command`); return; }
+
+                if (payload.effect) {
+                    runEffect(payload.effect);
+                } else if (payload.state === 'ON') {
+                    handleON(payload);
+                } else if (payload.state === 'OFF') {
+                    handleOFF(payload);
+                }
+            }, node.id);
+
+            setStatus('green', 'ring', `${fixtureId} discovery sent`);
+            node.log(`${fixtureId} device added`);
+
+            // Recovery state
+            setTimeout(function () {
+                const state      = recall('state',      'state_disk',      S.defaultState);
+                const brightness = recall('brightness', 'brightness_disk', 255);
+                const r  = recall('red',       'red_disk',       255);
+                const g  = recall('green',     'green_disk',     255);
+                const b  = recall('blue',      'blue_disk',      255);
+                const w  = recall('white',     'white_disk',     255);
+                const ww = recall('warmWhite', 'warmWhite_disk',  0);
+
+                if (state === 'ON') {
+                    sendDmxChannels(buildColorChannels(brightness, r, g, b, w, ww));
+                } else {
+                    sendDmxChannels(buildColorChannels(0, r, g, b, w, ww));
+                }
+                pubState({ state, color_mode: S.colorMode, brightness, color: { r, g, b, w, ww } });
+                setStatus('yellow', 'ring', `${fixtureId} ready — awaiting HA`);
+                node.log(`${fixtureId} recovery — state:${state}`);
+            }, 2000);
+        }
+
+        // ── Device remove ─────────────────────────────────────────
+        function handleDeviceRemove() {
+            stopEffect();
+            if (diskTimer) { clearTimeout(diskTimer); diskTimer = null; }
+            ['state','brightness','red','green','blue','white','warmWhite'].forEach(function (k) {
+                ctxSet(k, null); ctxSet(k, null, 'disk');
+            });
+            pub(cfgTopic, '', true);
+            broker.unsubscribe(cmdTopic, node.id);
+            setStatus('red', 'ring', `${fixtureId} removed`);
+            node.log(`${fixtureId} device removed`);
+        }
+
+        // ── AUX from Group Node ───────────────────────────────────
+        function handleAux(msg) {
+            if (!msg.payload) return;
+            // groupSync=false only blocks effect sync — state commands always pass through
+            if (msg.payload.effect) {
+                if (S.groupSync) runEffect(msg.payload.effect);
+                // else: fixture ignores group effects and keeps its own
+            } else if (msg.payload.state === 'ON') {
+                handleON(msg.payload);
+            } else if (msg.payload.state === 'OFF') {
+                handleOFF(msg.payload);
+            }
+        }
+
+        // ── NR input entry point ──────────────────────────────────
+        node.on('input', function (msg, send, done) {
+            if (msg.dmx_trace != null) {
+                handleAux(msg);
+            } else {
+                const devReq = typeof msg.device === 'string'
+                    ? msg.device
+                    : (msg.device && msg.device.request);
+
+                if (devReq) {
+                    switch (devReq) {
+                        case 'add':    handleDeviceAdd();    break;
+                        case 'remove': handleDeviceRemove(); break;
+                        default: node.warn(`${fixtureId} — unknown device.request: "${devReq}"`);
+                    }
+                } else {
+                    node.warn(`${fixtureId} — unrecognised message received and dropped. See node documentation.`);
+                }
+            }
+            done();
+        });
+
+        // ── Cleanup ───────────────────────────────────────────────
+        node.on('close', function (done) {
+            stopEffect();
+            if (diskTimer) clearTimeout(diskTimer);
+            broker.unsubscribe(cmdTopic, node.id);
+            broker.deregister(node, done);
+        });
+    }
+
+    RED.nodes.registerType('ha-mqtt-dmx', HaMqttDmxNode);
+};