node-red-contrib-mobius-flow-dali
Version:
Node-RED nodes to work with MOBiUSFlow and DALI devices
275 lines (272 loc) • 12.9 kB
JavaScript
;
/**
Copyright (C) 2020, IAConnects Technology Limited
All Rights Reserved
ALL INFORMATION CONTAINED HEREIN IS, AND REMAINS
THE PROPERTY OF IACONNECTS TECHNOLOGY LIMITED AND ITS SUPPLIERS,
IF ANY. THE INTELLECTUAL AND TECHNICAL CONCEPTS CONTAINED
HEREIN ARE PROPRIETARY TO IACONNECTS TECHNOLOGY LIMITED
AND ITS SUPPLIERS AND ARE PROTECTED BY TRADE SECRET OR COPYRIGHT LAW.
DISSEMINATION OF THIS INFORMATION OR REPRODUCTION OF THIS MATERIAL
IS STRICTLY FORBIDDEN UNLESS PRIOR WRITTEN PERMISSION IS OBTAINED
FROM IACONNECTS TECHNOLOGY LIMITED.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
**/
Object.defineProperty(exports, "__esModule", { value: true });
const dali_addressing_class_1 = require("../dali-addressing-class");
const dali_emergency_class_1 = require("../dali-emergency-class");
const dali_flash_class_1 = require("../dali-flash-class");
module.exports = (RED) => {
RED.nodes.registerType('dali addressing', function (config) {
RED.nodes.createNode(this, config);
const node = this;
const masters = [];
let i;
for (i = 0; i < config.groups.length; i++) {
masters.push({
addressingInterface: new dali_addressing_class_1.CircuitAddressingInterface(config.addrTimeoutTime, config.scanTimeoutTime, (parseInt(config.groups[i].exp, 10) || 0), config.groups[i].con, RED.nodes.getNode),
flashInterface: new dali_flash_class_1.CircuitFlashInterface(config.groups[i].con, RED.nodes.getNode),
emergencyInterface: new dali_emergency_class_1.CircuitEmergencyInterface(config.groups[i].con, RED.nodes.getNode)
});
}
masters.forEach(master => {
master.addressingInterface.on('addressingNotification', (message) => {
node.send({
topic: 'addressingNotification',
payload: {
daliCircuitID: master.addressingInterface.circuit,
message: message
}
});
node.status({
fill: 'green',
shape: 'dot',
text: message
});
});
master.flashInterface.on('flashNotification', (message) => {
node.send({
topic: 'flashNotification',
payload: {
daliCircuitID: master.flashInterface.circuit,
message: message
}
});
node.status({
fill: 'green',
shape: 'dot',
text: message
});
});
master.emergencyInterface.on('emNotification', (message) => {
node.send({
topic: 'emNotification',
payload: {
daliCircuitID: master.flashInterface.circuit,
message: message
}
});
node.status({
fill: 'green',
shape: 'dot',
text: message
});
});
master.addressingInterface.on('daliAddressingFunction', (msg) => {
node.send(msg);
updateDeviceLists(msg);
});
master.flashInterface.on('interfaceLuminaireDevices', (devices) => {
node.send({
topic: 'interfaceLuminaireDevices',
payload: devices
});
});
master.flashInterface.on('interfaceLuminaireObjects', (objects) => {
node.send({
topic: 'interfaceLuminaireObjects',
payload: objects
});
});
master.emergencyInterface.on('interfaceEmergencyDevices', (devices) => {
node.send({
topic: 'interfaceEmergencyDevices',
payload: devices
});
});
master.emergencyInterface.on('interfaceEmergencyObjects', (objects) => {
node.send({
topic: 'interfaceEmergencyObjects',
payload: objects
});
});
});
/**
* Populate internal device lists within flash and em classes following scan process
* @param {Object} msg - Returned msg from scan process containing found devices
*/
function updateDeviceLists(msg) {
const luminaires = [];
const ems = [];
for (let j = 0; j < msg.payload.devices.length; j++) {
if (msg.payload.devices[j].deviceType === 1) {
ems.push(msg.payload.devices[j]);
}
else {
luminaires.push(msg.payload.devices[j]);
}
}
for (let j = 0; j < masters.length; j++) {
if (msg.payload.daliCircuitID === masters[j].addressingInterface.circuit) {
masters[j].flashInterface.updateDeviceList(luminaires);
masters[j].emergencyInterface.updateDeviceList(ems);
}
}
}
/**
* Runs functions within flash and em classes based on input topic
* @param msg - Node input message
*/
function sendCommand(msg) {
let j;
for (j = 0; j < masters.length; j++) {
if (msg.payload.daliCircuitID === masters[j].addressingInterface.circuit) {
if (!masters[j].addressingInterface.operationInProgress) {
switch (msg.topic) {
case 'daliScan':
masters[j].addressingInterface.scanCircuit();
break;
case 'daliAddress':
masters[j].addressingInterface.addressCircuit();
break;
case 'daliAdd':
masters[j].addressingInterface.addToCircuit();
break;
case 'daliSwap':
masters[j].flashInterface.unlinkOnSwap(msg.payload.data[0]);
masters[j].flashInterface.unlinkOnSwap(msg.payload.data[1]);
masters[j].addressingInterface.swap(msg.payload.data[0], msg.payload.data[1]);
break;
case 'daliDelete':
masters[j].flashInterface.unlinkOnSwap(msg.payload.data);
masters[j].addressingInterface.del(msg.payload.data);
break;
case 'daliUngroup':
masters[j].addressingInterface.ungroupAll();
break;
}
}
switch (msg.topic) {
case 'interfaceChangeCircuit':
masters[j].flashInterface.changeToThisCircuit();
masters[j].emergencyInterface.changeToThisCircuit();
break;
case 'unlinkAllLuminaires':
masters[j].flashInterface.unlinkAllMobObjects();
break;
case 'unlinkLuminaire':
masters[j].flashInterface.unlinkMobObject();
break;
case 'flashOn':
masters[j].flashInterface.stopFlash();
masters[j].flashInterface.startFlash();
break;
case 'flashOff':
masters[j].flashInterface.stopFlash();
break;
case 'flashNext':
masters[j].flashInterface.flashNext();
break;
case 'flashPrevious':
masters[j].flashInterface.flashPrevious();
break;
case 'updateFlashSettings':
masters[j].flashInterface.updateSettings(msg.payload.addressingMode, msg.payload.onLevel, msg.payload.offLevel, msg.payload.rate);
break;
case 'linkLuminaire':
masters[j].flashInterface.linkLuminaire();
break;
case 'interfaceSelectLuminaire':
masters[j].flashInterface.selectDevice(msg.payload.addr);
break;
case 'interfaceSelectLuminaireObject':
masters[j].flashInterface.selectObject(msg.payload.instance);
break;
case 'interfaceSelectEmergency':
masters[j].emergencyInterface.selectDevice(msg.payload.addr);
break;
case 'interfaceSelectEmergencyObject':
masters[j].emergencyInterface.selectObject(msg.payload.instance);
break;
case 'unlinkAllEmergencies':
masters[j].emergencyInterface.unlinkAllMobObjects();
break;
case 'unlinkEmergency':
masters[j].emergencyInterface.unlinkMobObject();
break;
case 'linkEmergency':
masters[j].emergencyInterface.linkLuminaire();
break;
case 'testEM': // Required
masters[j].emergencyInterface.illuminateCurrent();
break;
case 'testNextEM': // Required
masters[j].emergencyInterface.illuminateNext();
break;
case 'testPreviousEM': // Required
masters[j].emergencyInterface.illuminatePrevious();
break;
}
}
}
}
node.on('input', (msg) => {
if (msg.topic === 'interfaceConnect') {
node.send({
topic: 'interfaceConnect',
payload: {
circuitList: (() => {
let list = '';
for (i = 0; i < masters.length; i++) {
list += masters[i].addressingInterface.circuit;
if (i !== (masters.length - 1)) {
list += ', ';
}
}
return list;
})(),
circuitArray: (() => {
const array = [];
masters.forEach(master => {
array.push(`${master.addressingInterface.circuit} - ${master.addressingInterface.name}`);
});
return array;
})()
}
});
}
else {
sendCommand(msg);
}
});
node.on('close', (done) => {
for (i = 0; i < config.groups.length; i++) {
masters[i].addressingInterface.removeAllListeners('addressingNotification');
masters[i].addressingInterface.removeAllListeners('daliAddressingFunction');
masters[i].addressingInterface.close();
masters[i].flashInterface.stopFlash();
}
done();
});
});
};