568 lines
18 KiB
JavaScript
568 lines
18 KiB
JavaScript
/* jshint -W097 */
|
|
/* jshint strict: false */
|
|
/* jslint node: true */
|
|
'use strict';
|
|
|
|
const utils = require(__dirname + '/lib/utils');
|
|
let yuanqu = null;
|
|
let fs;
|
|
|
|
let adapter = utils.Adapter({
|
|
name: 'yuanqu',
|
|
unload: stop
|
|
});
|
|
|
|
process.on('SIGINT', stop);
|
|
|
|
adapter.on('ready', function () {
|
|
|
|
adapter.setState('info.connection', adapter.config.params.slave ? 0 : false, true);
|
|
main();
|
|
});
|
|
|
|
adapter.on('message', function (obj) {
|
|
if (obj) {
|
|
switch (obj.command) {
|
|
case 'listUart':
|
|
adapter.log.warn('listUart');
|
|
adapter.sendTo(obj.from, obj.command, [{comName: 'Not available'}], obj.callback);
|
|
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
function stop(callback) {
|
|
if (yuanqu) {
|
|
yuanqu.close();
|
|
yuanqu = null;
|
|
}
|
|
|
|
if (adapter && adapter.setState && adapter.config && adapter.config.params) {
|
|
adapter.setState('info.connection', adapter.config.params.slave ? 0 : false, true);
|
|
}
|
|
|
|
if (typeof callback === 'function') callback();
|
|
|
|
setTimeout(function() {
|
|
process.exit();
|
|
}, 5000);
|
|
}
|
|
|
|
let objects = {};
|
|
let enums = {};
|
|
let infoRegExp = new RegExp(adapter.namespace.replace('.', '\\.') + '\\.info\\.');
|
|
|
|
adapter.on('stateChange', (id, state) => {
|
|
if (state && !state.ack && id && !infoRegExp.test(id)) {
|
|
if (!yuanqu) {
|
|
adapter.log.warn('No connection')
|
|
} else {
|
|
if (objects[id]) {
|
|
yuanqu.write(id, state);
|
|
} else {
|
|
adapter.getObject(id, (err, data) => {
|
|
if (!err) {
|
|
objects[id] = data;
|
|
yuanqu.write(id, state);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
|
|
function addToEnum(enumName, id, callback) {
|
|
adapter.getForeignObject(enumName, function (err, obj) {
|
|
if (!err && obj) {
|
|
let pos = obj.common.members.indexOf(id);
|
|
if (pos === -1) {
|
|
obj.common.members.push(id);
|
|
adapter.setForeignObject(obj._id, obj, function (err) {
|
|
if (callback) callback(err);
|
|
});
|
|
} else {
|
|
if (callback) callback(err);
|
|
}
|
|
} else {
|
|
if (callback) callback(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
function removeFromEnum(enumName, id, callback) {
|
|
adapter.getForeignObject(enumName, function (err, obj) {
|
|
if (!err && obj) {
|
|
let pos = obj.common.members.indexOf(id);
|
|
if (pos !== -1) {
|
|
obj.common.members.splice(pos, 1);
|
|
adapter.setForeignObject(obj._id, obj, function (err) {
|
|
if (callback) callback(err);
|
|
});
|
|
} else {
|
|
if (callback) callback(err);
|
|
}
|
|
} else {
|
|
if (callback) callback(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
function syncEnums(enumGroup, id, newEnumName, callback) {
|
|
if (!enums[enumGroup]) {
|
|
adapter.getEnum(enumGroup, function (err, _enums) {
|
|
enums[enumGroup] = _enums;
|
|
syncEnums(enumGroup, id, newEnumName, callback);
|
|
});
|
|
return;
|
|
}
|
|
|
|
// try to find this id in enums
|
|
let found = false;
|
|
let count = 0;
|
|
for (let e in enums[enumGroup]) {
|
|
if (enums[enumGroup].hasOwnProperty(e) &&
|
|
enums[enumGroup][e].common &&
|
|
enums[enumGroup][e].common.members &&
|
|
enums[enumGroup][e].common.members.indexOf(id) !== -1) {
|
|
if (enums[enumGroup][e]._id !== newEnumName) {
|
|
count++;
|
|
removeFromEnum(enums[enumGroup][e]._id, id, function () {
|
|
if (!--count && typeof callback === 'function') callback();
|
|
});
|
|
} else {
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
if (!found && newEnumName) {
|
|
count++;
|
|
addToEnum(newEnumName, id, function () {
|
|
if (!--count&& typeof callback === 'function') callback();
|
|
});
|
|
}
|
|
|
|
if (!count && typeof callback === 'function') callback();
|
|
}
|
|
|
|
const type_items_len = {
|
|
'uint8be': 1,
|
|
'string': 0,
|
|
'ieee754': 2
|
|
};
|
|
|
|
const _rmap = {
|
|
0: 15,
|
|
1: 14
|
|
};
|
|
const _dmap = {
|
|
0: 0,
|
|
1: 1
|
|
};
|
|
|
|
function address2alias(id, address, isDirect, offset) {
|
|
if (typeof address === 'string') address = parseInt(address, 10);
|
|
|
|
if (id === 'disInputs' || id === 'coils') {
|
|
address = Math.floor(address / 16) * 16 + (isDirect ? _dmap[address % 16] : _rmap[address % 16]);
|
|
address += offset;
|
|
return address;
|
|
} else {
|
|
return address + offset;
|
|
}
|
|
}
|
|
|
|
function createExtendObject(id, objData, callback) {
|
|
adapter.getObject(id, function (err, oldObj) {
|
|
if (!err && oldObj) {
|
|
adapter.extendObject(id, objData, callback);
|
|
} else {
|
|
adapter.setObjectNotExists(id, objData, callback);
|
|
}
|
|
});
|
|
}
|
|
|
|
function processTasks(tasks, callback) {
|
|
if (!tasks || !tasks.length) {
|
|
if (typeof callback === 'function') callback();
|
|
return;
|
|
}
|
|
let task = tasks.shift();
|
|
if (task.name === 'add') {
|
|
createExtendObject(task.id, task.obj, function () {
|
|
setTimeout(processTasks, 0, tasks, callback);
|
|
});
|
|
} else if (task.name === 'del') {
|
|
adapter.delObject(task.id, function () {
|
|
setTimeout(processTasks, 0, tasks, callback);
|
|
});
|
|
} else if (task.name === 'syncEnums') {
|
|
syncEnums('rooms', task.id, task.obj, function () {
|
|
setTimeout(processTasks, 0, tasks, callback);
|
|
});
|
|
} else {
|
|
throw 'Unknown task';
|
|
}
|
|
}
|
|
|
|
function prepareConfig(config) {
|
|
let params = config.params;
|
|
|
|
params.slave = parseInt(params.slave, 10) || 0; // required in stop
|
|
|
|
let options = {
|
|
config: {
|
|
type: params.type || 'tcp',
|
|
slave: params.slave,
|
|
round: parseInt(params.round, 10) || 0,
|
|
timeout: parseInt(params.timeout, 10) || 5000,
|
|
defaultDeviceId: (params.deviceId === undefined || params.deviceId === null) ? 1 : (parseInt(params.deviceId, 10) || 0),
|
|
},
|
|
devices: {}
|
|
};
|
|
options.config.round = Math.pow(10, options.config.round);
|
|
|
|
if (!options.config.slave) {
|
|
options.config.multiDeviceId = params.multiDeviceId === true || params.multiDeviceId === 'true';
|
|
}
|
|
|
|
let deviceIds = [];
|
|
|
|
|
|
// settings for master
|
|
if (!options.config.slave) {
|
|
options.config.poll = parseInt(params.poll, 10) || 1000; // default is 1 second
|
|
options.config.recon = parseInt(params.recon, 10) || 60000;
|
|
options.config.maxBlock = parseInt(params.maxBlock, 10) || 100;
|
|
options.config.maxBoolBlock = parseInt(params.maxBoolBlock, 10) || 128;
|
|
options.config.pulsetime = parseInt(params.pulsetime || 1000);
|
|
}
|
|
|
|
|
|
if (params.type === 'tcp' || params.type === 'tcprtu') {
|
|
options.config.tcp = {
|
|
port: parseInt(params.port, 10) || 502,
|
|
bind: params.bind
|
|
};
|
|
}
|
|
|
|
options.objects = objects;
|
|
|
|
adapter.log.warn('objects=' + objects[0]);
|
|
|
|
return options;
|
|
}
|
|
|
|
function checkDeviceIds(options, config, deviceIds) {
|
|
for (let i = config.length - 1; i >= 0; i--) {
|
|
config[i].deviceId = !options.config.multiDeviceId ? options.config.defaultDeviceId : (config[i].deviceId !== undefined ? parseInt(config[i].deviceId, 10) : options.config.defaultDeviceId);
|
|
if (isNaN(config[i].deviceId)) config[i].deviceId = options.config.defaultDeviceId;
|
|
if (deviceIds.indexOf(config[i].deviceId) === -1) {
|
|
deviceIds.push(config[i].deviceId);
|
|
}
|
|
}
|
|
}
|
|
|
|
function checkObjects(options, regType, regName, regFullName, tasks, newObjects) {
|
|
|
|
let regs = options[regType];
|
|
|
|
adapter.log.warn('regs=' + JSON.stringify(regs));
|
|
|
|
for (let i = 0; regs.length > i; i++) {
|
|
const id = adapter.namespace + '.' + regs[i].id;
|
|
|
|
|
|
adapter.log.warn('id=' + id);
|
|
|
|
regs[i].fullId = id;
|
|
objects[id] = {
|
|
_id: regs[i].id,
|
|
type: 'state',
|
|
common: {
|
|
name: regs[i].description,
|
|
role: regs[i].role,
|
|
type: regType === 'coils' || regType === 'disInputs' ? 'boolean' :
|
|
((regs[i].type === 'string' || regs[i].type === 'string') ? 'string' : 'number'),
|
|
read: true,
|
|
write: regType === 'coils' || regType === 'holdingRegs',
|
|
def: regType === 'coils' || regType === 'disInputs' ? false : 0
|
|
},
|
|
native: {
|
|
regType: regType,
|
|
address: regs[i].address,
|
|
deviceId: regs[i].deviceId
|
|
}
|
|
};
|
|
if (regType === 'coils') {
|
|
objects[id].native.poll = regs[i].poll;
|
|
objects[id].native.wp = regs[i].wp;
|
|
} else
|
|
if (regType === 'inputRegs' || regType === 'holdingRegs') {
|
|
objects[id].common.unit = regs[i].unit || '';
|
|
|
|
objects[id].native.type = regs[i].type;
|
|
objects[id].native.len = regs[i].len;
|
|
objects[id].native.offset = regs[i].offset;
|
|
objects[id].native.factor = regs[i].factor;
|
|
if (regType === 'holdingRegs') {
|
|
objects[id].native.poll = regs[i].poll;
|
|
}
|
|
}
|
|
|
|
tasks.push({
|
|
id: regs[i].id,
|
|
name: 'add',
|
|
obj: objects[id]
|
|
});
|
|
tasks.push({
|
|
id: id,
|
|
name: 'syncEnums',
|
|
obj: regs[i].room
|
|
});
|
|
newObjects.push(id);
|
|
}
|
|
|
|
if (regs.length) {
|
|
tasks.push({
|
|
id: regName,
|
|
name: 'add',
|
|
obj: {
|
|
type: 'channel',
|
|
common: {
|
|
name: regFullName
|
|
},
|
|
native: {}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
function iterateAddresses(isBools, deviceId, result, regName, regType, localOptions) {
|
|
const config = result.config;
|
|
if (config && config.length) {
|
|
result.addressLow = 0xFFFFFFFF;
|
|
result.addressHigh = 0;
|
|
|
|
for (let i = config.length - 1; i >= 0; i--) {
|
|
if (config[i].deviceId !== deviceId) continue;
|
|
const address = config[i].address = parseInt(config[i].address, 10);
|
|
|
|
if (address < 0) {
|
|
adapter.log.error(`Invalid ${regName} address: ${address}`);
|
|
config.splice(i, 1);
|
|
continue;
|
|
}
|
|
|
|
if (!isBools) {
|
|
config[i].type = config[i].type || 'uint16be';
|
|
config[i].offset = parseFloat(config[i].offset) || 0;
|
|
config[i].factor = parseFloat(config[i].factor) || 1;
|
|
if (config[i].type === 'string') {
|
|
config[i].len = parseInt(config[i].len, 10) || 1;
|
|
} else {
|
|
config[i].len = type_items_len[config[i].type];
|
|
}
|
|
config[i].len = config[i].len || 1;
|
|
} else {
|
|
config[i].len = 1;
|
|
}
|
|
|
|
if (localOptions.multiDeviceId) {
|
|
config[i].id = regName + '.' + deviceId + '.';
|
|
} else {
|
|
config[i].id = regName + '.';
|
|
}
|
|
|
|
if (localOptions.showAliases) {
|
|
config[i].id += address2alias(regType, address, localOptions.directAddresses, result.offset);
|
|
} else {
|
|
config[i].id += address;
|
|
}
|
|
config[i].id += (config[i].name ? '_' + (config[i].name.replace('.', '_').replace(' ', '_')) : '');
|
|
|
|
// collect cyclic write registers
|
|
if (config[i].cw) {
|
|
result.cyclicWrite.push(adapter.namespace + '.' + config[i].id);
|
|
}
|
|
|
|
if (address < result.addressLow) result.addressLow = address;
|
|
if (address + config[i].len > result.addressHigh) {
|
|
result.addressHigh = address + (config[i].len || 1);
|
|
}
|
|
}
|
|
|
|
const maxBlock = isBools ? localOptions.maxBoolBlock : localOptions.maxBlock;
|
|
let lastAddress = null;
|
|
let startIndex = 0;
|
|
let blockStart = 0;
|
|
let i;
|
|
for (i = 0; i < config.length; i++) {
|
|
if (config[i].deviceId !== deviceId) continue;
|
|
|
|
if (lastAddress === null) {
|
|
startIndex = i;
|
|
blockStart = config[i].address;
|
|
lastAddress = blockStart + config[i].len;
|
|
}
|
|
|
|
// try to detect next block
|
|
if (result.blocks) {
|
|
if ((config[i].address - lastAddress > 10 && config[i].len < 10) || (lastAddress - blockStart >= maxBlock)) {
|
|
if (result.blocks.map(obj => obj.start).indexOf(blockStart) === -1) {
|
|
result.blocks.push({start: blockStart, count: lastAddress - blockStart, startIndex: startIndex, endIndex: i});
|
|
}
|
|
blockStart = config[i].address;
|
|
startIndex = i;
|
|
}
|
|
}
|
|
lastAddress = config[i].address + config[i].len;
|
|
}
|
|
if (lastAddress && lastAddress - blockStart && result.blocks && result.blocks.map(obj => obj.start).indexOf(blockStart) === -1) {
|
|
result.blocks.push({start: blockStart, count: lastAddress - blockStart, startIndex: startIndex, endIndex: i});
|
|
}
|
|
|
|
if (config.length) {
|
|
result.length = result.addressHigh - result.addressLow;
|
|
if (isBools && !localOptions.doNotRoundAddressToWord) {
|
|
result.addressLow = Math.floor(result.addressLow / 16) * 16;
|
|
|
|
if (result.length % 16) {
|
|
result.length = (Math.floor(result.length / 16) + 1) * 16;
|
|
}
|
|
if (result.blocks) {
|
|
for (let b = 0; b < result.blocks.length; b++) {
|
|
result.blocks[b].start = Math.floor(result.blocks[b].start / 16) * 16;
|
|
|
|
if (result.blocks[b].count % 16) {
|
|
result.blocks[b].count = (Math.floor(result.blocks[b].count / 16) + 1) * 16;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
result.length = 0;
|
|
}
|
|
|
|
if (result.mapping) {
|
|
for (let i = 0; i < config.length; i++) {
|
|
result.mapping[config[i].address - result.addressLow] = adapter.namespace + '.' + config[i].id;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function parseConfig(callback) {
|
|
|
|
adapter.log.warn('adapter.config=' + adapter.config);
|
|
|
|
let options = prepareConfig(adapter.config);
|
|
|
|
|
|
const params = adapter.config.params;
|
|
|
|
adapter.log.warn('params=' + params);
|
|
|
|
|
|
|
|
adapter.getForeignObjects(adapter.namespace + '.*', (err, list) => {
|
|
let oldObjects = list;
|
|
let newObjects = [];
|
|
|
|
adapter.config.yz.sort(sortByAddress);
|
|
|
|
let tasks = [];
|
|
|
|
|
|
|
|
// device.yz.config = adapter.config.yz.filter(e => e.deviceId === deviceId);
|
|
|
|
//device.disInputs.config = adapter.config.disInputs. filter(e => e.deviceId === deviceId);
|
|
|
|
// Discrete inputs
|
|
// iterateAddresses(true, deviceId, device.yz, 'discreteInputs', 'disInputs', localOptions);
|
|
|
|
//iterateAddresses(true, deviceId, device.disInputs, 'discreteInputs', 'disInputs', localOptions);
|
|
|
|
// ------------- create states and objects ----------------------------
|
|
|
|
checkObjects(adapter.config, 'yz', 'yz', 'yz', tasks, newObjects);
|
|
|
|
//checkObjects(adapter.config, 'disInputs', 'discreteInputs', 'Discrete inputs', tasks, newObjects);
|
|
|
|
|
|
|
|
tasks.push({
|
|
id: 'info',
|
|
name: 'add',
|
|
obj: {
|
|
type: 'channel',
|
|
common: {
|
|
name: 'info'
|
|
},
|
|
native: {}
|
|
}
|
|
});
|
|
|
|
// create/ update 'info.connection' object
|
|
adapter.getObject('info.connection', function (err, obj) {
|
|
if (!obj) {
|
|
obj = {
|
|
type: 'state',
|
|
common: {
|
|
name: 'Number of connected partners',
|
|
role: 'indicator.connected',
|
|
write: false,
|
|
read: true,
|
|
type: options.config.slave ? 'number' : 'boolean'
|
|
},
|
|
native: {}
|
|
};
|
|
adapter.setObjectNotExists('info.connection', obj);
|
|
} else if (options.config.slave && obj.common.type !== 'number') {
|
|
obj.common.type = 'number';
|
|
obj.common.name = 'Number of connected masters';
|
|
adapter.setObjectNotExists('info.connection', obj);
|
|
} else if (!options.config.slave && obj.common.type !== 'boolean') {
|
|
obj.common.type = 'boolean';
|
|
obj.common.name = 'If master connected';
|
|
adapter.setObjectNotExists('info.connection', obj);
|
|
}
|
|
});
|
|
|
|
newObjects.push(adapter.namespace + '.info.connection');
|
|
|
|
// clear unused states
|
|
for (let id_ in oldObjects) {
|
|
if (oldObjects.hasOwnProperty(id_) && newObjects.indexOf(id_) === -1) {
|
|
tasks.push({
|
|
id: id_,
|
|
name: 'del'
|
|
});
|
|
}
|
|
}
|
|
|
|
processTasks(tasks, function () {
|
|
oldObjects = [];
|
|
newObjects = [];
|
|
adapter.subscribeStates('*');
|
|
// callback(options);
|
|
});
|
|
});
|
|
}
|
|
|
|
function main() {
|
|
parseConfig(options => {
|
|
|
|
});
|
|
}
|
|
|
|
function sortByAddress(a, b) {
|
|
let ad = parseFloat(a.address);
|
|
let bd = parseFloat(b.address);
|
|
return ((ad < bd) ? -1 : ((ad > bd) ? 1 : 0));
|
|
}
|