@frangoteam/fuxa-min 1.1.19

package/runtime/devices/index.js

@@ -0,0 +1,489 @@
+/**
+ * Devices manager, manage all the configurated devices in project
+ */
+
+'use strict';
+var Device = require('./device');
+
+var sharedDevices = {};             // Shared Devices list
+var activeDevices = {};             // Actives Devices list
+var runtime;                        // Access to application resource like logger/settings
+var wokingStatus;                   // Current status (start/stop) to know if is working
+
+const FuxaServerId = '0';
+/**
+ * Init by set the access to application resource
+ * @param {*} _runtime 
+ */
+function init(_runtime) {
+    runtime = _runtime;
+}
+
+/**
+ * Load and start all Devices actives
+ */
+function start() {
+    wokingStatus = 'starting';
+    devices.load();
+    return new Promise(function (resolve, reject) {
+        // runtime.logger.info('devices.start-all (' + Object.keys(activeDevices).length + ')', true);
+        for (var id in activeDevices) {
+            activeDevices[id].start();
+        }
+        resolve();
+        wokingStatus = null;
+    });
+}
+
+/**
+ * Stop all Devices
+ */
+function stop() {
+    wokingStatus = 'stopping';
+    return new Promise(function (resolve, reject) {
+        // runtime.logger.info('devices.stop-all (' + Object.keys(activeDevices).length + ')');
+        var deviceStopfnc = [];
+        for (var id in activeDevices) {
+            deviceStopfnc.push(activeDevices[id].stop());
+        }
+        return Promise.all(deviceStopfnc).then(values => {
+            resolve(true);
+            wokingStatus = null;
+        }, reason => {
+            runtime.logger.error('devices.stop-all: ' + reason);
+            resolve(reason);
+            wokingStatus = null;
+        });
+    });
+}
+
+/**
+ * Update all by restart all devices
+ */
+function update() {
+    devices.stop().then(function () {
+        devices.start().then(function () {
+
+        }).catch(function (err) {
+            runtime.logger.error('devices.update-start: ' + err);
+        });
+    }).catch(function (err) {
+        runtime.logger.error('devices.ipdate-stop: ' + err);
+    });
+}
+
+/**
+ * Update the device, load and restart it
+ * @param {*} device 
+ */
+function updateDevice(device) {
+    if (!activeDevices[device.id]) {
+        if (devices.loadDevice(device) && device.enabled) {
+            activeDevices[device.id].start();
+        }
+    } else {
+        activeDevices[device.id].stop().then(function () {
+            devices.loadDevice(device);
+            if (device.enabled) {
+                activeDevices[device.id].start();
+            } else {
+                delete activeDevices[device.id];
+            }
+        }).catch(function (err) {
+            runtime.logger.error('devices.update-device ' + device.name + ': ' + err);
+        });
+    }
+}
+
+/**
+ * Remove the device, stop it if active and remove from actieDevices list
+ * @param {*} device 
+ */
+function removeDevice(device) {
+    if (!activeDevices[device.id]) {
+        delete activeDevices[device.id];
+    } else {
+        activeDevices[device.id].stop().then(function () {
+            delete activeDevices[device.id];
+        }).catch(function (err) {
+            delete activeDevices[device.id];
+            runtime.logger.error('devices.remove-device by stop ' + device.name + ': ' + err);
+        });
+    }
+}
+
+/**
+ * Load the device from project and add or remove of active device for the management 
+ */
+function load() {
+    var tempdevices = runtime.project.getDevices();
+    activeDevices = {};
+    runtime.daqStorage.reset();
+    // check existing or to add new 
+    for (var id in tempdevices) {
+        if (tempdevices[id].enabled) {
+            if(tempdevices[id].type == 'ModbusRTU'){
+                if(!(tempdevices[id].property.address in sharedDevices)){
+                    sharedDevices[tempdevices[id].property.address] = [];
+                }
+                sharedDevices[tempdevices[id].property.address].push(id);
+                tempdevices[id].sharedDevices = sharedDevices;
+            }
+            devices.loadDevice(tempdevices[id]);
+        }
+    }
+    // log remove device not used
+    for (var id in activeDevices) {
+        if (Object.keys(tempdevices).indexOf(id) < 0) {
+            runtime.logger.info(`devices.load-removed: '${activeDevices[id].name}'`, true);
+        }
+    }
+}
+
+/**
+ * Load the device to manage and set on depending of settings 
+ * @param {*} device 
+ */
+function loadDevice(device) {
+    if (activeDevices[device.id]) {
+        // device exist
+        runtime.logger.info(`'${device.name}' exist`, true);
+        activeDevices[device.id].load(device);
+    } else {
+        // device create
+        let tdev = Device.create(device, runtime);
+        if (tdev && tdev.start) {
+            runtime.logger.info(`'${device.name}' created`);
+            activeDevices[device.id] = tdev;
+            activeDevices[device.id].bindGetProperty(runtime.project.getDeviceProperty);
+            activeDevices[device.id].bindUpdateConnectionStatus(setDeviceConnectionStatus);
+        } else {
+            if (!Device.isInternal(device)) {
+                runtime.logger.warn('try to create ' + device.name + ' but plugin is missing!');
+            }
+            return false;
+        }
+    }
+    if (runtime.settings.daqEnabled) {
+        var fncToSaveDaqValue = runtime.daqStorage.addDaqNode(device.id, activeDevices[device.id].getTagProperty);
+        activeDevices[device.id].bindSaveDaqValue(fncToSaveDaqValue);
+        activeDevices[device.id].bindGetDaqValueToRestore(runtime.daqStorage.getCurrentStorageFnc());
+    }
+    return true;
+}
+
+/**
+ * Return all devices status 
+ */
+function getDevicesStatus() {
+    var adev = {};
+    for (var id in activeDevices) {
+        adev[id] = activeDevices[id].getStatus();
+    }
+    return adev;
+}
+
+/**
+ * Return all devices values
+ */
+function getDevicesValues() {
+    var adev = {};
+    for (var id in activeDevices) {
+        adev[id] = activeDevices[id].getValues();
+    }
+    return adev;
+}
+
+
+/**
+ * Get the Device Tag value
+ * used from Alarms
+ * @param {*} deviceid 
+ * @param {*} sigid 
+ * @param {*} value 
+ */
+function getDeviceValue(deviceid, sigid) {
+    if (activeDevices[deviceid]) {
+        return activeDevices[deviceid].getValue(sigid);
+    }
+    return null;
+}
+
+/**
+ * Get the Device Tag value
+ * used from Alarms, Script
+ * @param {*} sigid 
+ * @param {*} fully, struct with timestamp
+ */
+ function getTagValue(sigid, fully) {
+     try {
+        let deviceid = getDeviceIdFromTag(sigid)
+        if (activeDevices[deviceid]) {
+            let result = activeDevices[deviceid].getValue(sigid);
+            if (fully) {
+                return result;
+            } else if (result) {
+                return result.value;
+            }
+        }
+    } catch (err) {
+        console.error(err);
+    }
+    return null;
+}
+
+/**
+ * Get the Device Tag Id
+ * used from Script
+ * @param {*} tagName 
+ * @param {*} deviceName 
+ */
+function getTagId(tagName, deviceName) {
+    try {
+        const devices = runtime.project.getDevices();
+        for (var id in devices) {
+            if (!deviceName || devices[id].name === deviceName) {
+                const tag = Object.values(devices[id].tags).find(tag => tag.name === tagName);
+                if (tag) {
+                    return tag.id;
+                }
+            }
+        }
+    } catch (err) {
+        console.error(err);
+    }
+    return null;
+}
+
+/**
+ * Set the Device Tag value
+ * used from Scripts
+ * @param {*} tagid 
+ * @param {*} value 
+ */
+function setTagValue(tagid, value) {
+    try {
+        let deviceid = getDeviceIdFromTag(tagid)
+        if (activeDevices[deviceid]) {
+            return activeDevices[deviceid].setValue(tagid, value);
+        }
+    } catch (err) {
+        console.error(err);
+    }
+    return null;
+}
+
+/**
+ * Get the Device Tag Daq settings
+ * used from Scripts
+ * @param {*} tagid
+ */
+function getTagDaqSettings(tagId) {
+    try {
+        let deviceId = getDeviceIdFromTag(tagId)
+        if (activeDevices[deviceId]) {
+            return activeDevices[deviceId].getTagDaqSettings(tagId);
+        }
+    } catch (err) {
+        console.error(err);
+    }
+    return null;
+}
+
+/**
+ * Set the Device Tag Daq settings
+ * used from Scripts
+ * @param {*} tagId
+ * @param {*} settings
+ */
+function setTagDaqSettings(tagId, settings) {
+    try {
+        let deviceId = getDeviceIdFromTag(tagId)
+        if (activeDevices[deviceId]) {
+            return activeDevices[deviceId].setTagDaqSettings(tagId, settings);
+        }
+    } catch (err) {
+        console.error(err);
+    }
+    return null;
+}
+
+/**
+ * Enable/disable Device connection
+ * used from Scripts
+ * @param {*} deviceName
+ * @param {*} enable 
+ */
+function enableDevice(deviceName, enable) {
+    try {
+        let device = runtime.project.getDevice(deviceName);
+        enable = (typeof enable === 'string') ? enable === "true" : Boolean(enable);
+        if (device && device.enabled !== enable) {
+            device.enabled = enable;
+            updateDevice(device);
+        }
+        runtime.logger.info(`devices.enableDevice: '${deviceName} - ${enable}'`, true);
+    } catch (err) {
+        console.error(err);
+    }
+}
+
+/**
+ * Get the Device from the tag id
+ * used from Alarms
+ * @param {*} sigid 
+ */
+ function getDeviceIdFromTag(sigid) {
+    for (var id in activeDevices) {
+        var tag = activeDevices[id].getTagProperty(sigid);
+        if (tag) {
+            return id;
+        }
+    }
+    return null;
+}
+
+/**
+ * Get the Tag value format from the tag id
+ * used from Report
+ * @param {*} sigid 
+ */
+function getTagFormat(sigid) {
+    for (var id in activeDevices) {
+        var tag = activeDevices[id].getTagProperty(sigid);
+        if (tag) {
+            return tag.format;
+        }
+    }
+    return null;
+}
+
+/**
+ * Return if manager is working (started or stopped)
+ */
+function isWoking() {
+    return (wokingStatus) ? true : false;
+}
+
+/**
+ * Set the Device Tag value
+ * @param {*} deviceid 
+ * @param {*} sigid 
+ * @param {*} value 
+ */
+function setDeviceValue(deviceid, sigid, value, fnc) {
+    if (activeDevices[deviceid]) {
+        activeDevices[deviceid].setValue(sigid, value, fnc);
+    }
+}
+
+/**
+ * Set connection device status to server tag
+ * @param {*} deviceId 
+ * @param {*} status 
+ */
+function setDeviceConnectionStatus(deviceId, status) {
+    activeDevices[FuxaServerId].setDeviceConnectionStatus(deviceId, status);
+}
+
+/**
+ * Return the Device browser result Tags/Nodes
+ * @param {*} deviceid 
+ * @param {*} node 
+ */
+function browseDevice(deviceid, node, callback) {
+    return new Promise(function (resolve, reject) {
+        if (activeDevices[deviceid] && activeDevices[deviceid].browse) {
+            activeDevices[deviceid].browse(node, callback).then(function (result) {
+                resolve(result);
+            }).catch(function (err) {
+                reject(err);
+            });
+        } else {
+            reject('Device not found!');
+        }
+    });
+}
+
+/**
+ * Return Device Tag/Node attribute
+ * @param {*} deviceid 
+ * @param {*} node 
+ */
+function readNodeAttribute(deviceid, node) {
+    return new Promise(function (resolve, reject) {
+        if (activeDevices[deviceid] && activeDevices[deviceid].readNodeAttribute) {
+            activeDevices[deviceid].readNodeAttribute(node).then(function (result) {
+                resolve(result);
+            }).catch(function (err) {
+                reject(err);
+            });
+        } else {
+            reject('Device not found!');
+        }
+    });
+}
+
+/**
+ * Return Device Tags settings
+ * @param {*} deviceId 
+ */
+function getDeviceTagsResult(deviceId) {
+    return new Promise(function (resolve, reject) {
+        if (activeDevices[deviceId] && activeDevices[deviceId].getTagsProperty) {
+            activeDevices[deviceId].getTagsProperty().then(function (result) {
+                resolve(result);
+            }).catch(function (err) {
+                reject(err);
+            });
+        } else {
+            reject('Device not found!');
+        }
+    });
+}
+
+/**
+ * Return the property (security mode) supported from device
+ * @param {*} endpoint 
+ * @param {*} type 
+ */
+function getSupportedProperty(endpoint, type) {
+    return Device.getSupportedProperty(endpoint, type, runtime.plugins.manager);
+}
+
+/**
+ * Return result of request
+ * @param {*} property 
+ */
+function getRequestResult(property) {
+    return Device.getRequestResult(property);
+}
+
+var devices = module.exports = {
+    init: init,
+    start: start,
+    stop: stop,
+    load: load,
+    loadDevice: loadDevice,
+    update: update,
+    updateDevice: updateDevice,
+    removeDevice: removeDevice,
+    getDevicesStatus: getDevicesStatus,
+    getDevicesValues: getDevicesValues,
+    getDeviceValue: getDeviceValue,
+    getTagValue: getTagValue,
+    setTagValue: setTagValue,
+    setDeviceValue: setDeviceValue,
+    getDeviceIdFromTag: getDeviceIdFromTag,
+    browseDevice: browseDevice,
+    readNodeAttribute: readNodeAttribute,
+    getDeviceTagsResult: getDeviceTagsResult,
+    isWoking: isWoking,
+    getSupportedProperty: getSupportedProperty,
+    getRequestResult: getRequestResult,
+    getTagFormat: getTagFormat,
+    enableDevice: enableDevice,
+    getTagId: getTagId,
+    getTagDaqSettings: getTagDaqSettings,
+    setTagDaqSettings: setTagDaqSettings,
+}

package/runtime/devices/modbus/datatypes.js

@@ -0,0 +1,122 @@
+
+function _gen(bytes, bFn, WordLen, swapType, toCast = false) {
+    return {
+        bytes,
+        parser: (buffer, offset = 0) => { 
+            _swap(buffer, swapType, offset);
+            var value = buffer['read' + bFn](offset); 
+            return (toCast) ? Number(value) : value; 
+        },
+        formatter: v => {
+            var b = Buffer.allocUnsafe(bytes);//new Buffer(bytes);
+            b['write' + bFn](toCast ? BigInt(v) : v);
+            _swap(b, swapType);
+            return b;
+        },
+        WordLen
+    }
+}
+
+function _swap(buffer, swapType, offset = 0) {
+    if (swapType == 2) {
+        var temp = buffer[offset + 0];
+        buffer[offset + 0] = buffer[offset + 2]; buffer[offset + 2] = temp;
+        temp = buffer[offset + 1]; 
+        buffer[offset + 1] = buffer[offset + 3];buffer[offset + 3] = temp;
+    }
+}
+
+const Datatypes = {
+    /**
+     * Bool
+     */
+    Bool: {
+        bytes: 1,
+        // parser: (v, bit = 0) => v >> bit & 1 === 1,
+        parser: (buffer, offset = 0, bit = 0) => +buffer.readUInt8(offset) >> bit & 1 === 1,
+        formatter: v => (v === '1' || v === 1 || v === true) ? 1 : 0,
+        WordLen: 1
+    },
+    /**
+     * Int16
+     */
+    Int16: _gen(2, 'Int16BE', 1),
+    /**
+     * UInt16
+     */
+    UInt16: _gen(2, 'UInt16BE', 1),
+    /**
+     * Int32
+     */
+    Int32: _gen(4, 'Int32BE', 2),
+    /**
+     * UInt32
+     */
+    UInt32: _gen(4, 'UInt32BE', 2),
+    /**
+     * Float32
+     */
+    Float32: _gen(4, 'FloatBE', 2),
+    /**
+     * Float64
+     */
+    Float64: _gen(8, 'DoubleBE', 4),
+    /**
+     * Int64
+     */
+    Int64: _gen(8, 'BigInt64BE', 4, 0, true),
+        
+    /**
+     * Int16LE
+     */
+    Int16LE: _gen(2, 'Int16LE', 1),
+    /**
+     * UInt16LE
+     */
+    UInt16LE: _gen(2, 'UInt16LE', 1),
+    /**
+     * Int32LE
+     */
+    Int32LE: _gen(4, 'Int32LE', 2),
+    /**
+     * UInt32LE
+     */
+    UInt32LE: _gen(4, 'UInt32LE', 2),
+    /**
+     * Float32LE
+     */
+    Float32LE: _gen(4, 'FloatLE', 2),
+    /**
+     * Float64LE
+     */
+    Float64LE: _gen(8, 'DoubleLE', 4),
+    /**
+     * Int64
+     */
+    Int64LE: _gen(8, 'BigInt64LE', 4, 0, true),
+    
+    /**
+     * Int32MLE
+     */
+    Int32MLE: _gen(4, 'Int32BE', 2, 2),
+    /**
+     * UInt32MLE
+     */
+    UInt32MLE: _gen(4, 'UInt32BE', 2, 2),
+    /**
+     * Float32MLE
+     */
+    Float32MLE: _gen(4, 'FloatBE', 2, 2),
+
+    /**
+     * String
+     */
+    String: {
+        bytes: 1,
+        parser: (buffer, offset = 0) => buffer.toString('ascii', offset, offset + 1),
+        formatter: v => new Buffer(v, 'ascii'),
+        WordLen: 1
+    }
+};
+
+module.exports = Datatypes;