@machinemetrics/io-adapter-lib 2.32.0

package/lib/config/device/jsonHttpConfig.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+const { checkJsonPropPath } = require('../common/jsonPath');
+
+class JsonHttpConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), (name) => this.expressionService.addName(name));
+  }
+
+  getIdentifiers(config = {}) {
+    return _.map(_.keys(config.props), (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  device() {
+    return 'json-http';
+  }
+
+  parse(config = {}) {
+    if (config.device !== this.device()) {
+      return;
+    }
+
+    this.insecure = config.insecure;
+    this.scanInterval = this.checkScanInterval(config);
+    this.endpoint = config.endpoint;
+    this.props = this.loadProps(config);
+  }
+
+  loadProps(config) {
+    const props = _.mapValues(config.props, (value) => {
+      if (_.isObject(value)) {
+        return {
+          path: value.path,
+          route: value.route || config.route,
+        };
+      } else {
+        return {
+          path: value,
+          route: config.route,
+        };
+      }
+    });
+
+    try {
+      _.each(props, (prop, key) => checkJsonPropPath(prop.path, key));
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        error.atSection('props');
+      }
+      throw error;
+    }
+
+    return props;
+  }
+
+  checkScanInterval(config) {
+    const scanIntvl = +(config['scan-interval'] || 1.0);
+    if (scanIntvl < 1) {
+      throw new ConfigError('scan-interval must be >= 1').atAttribute('scan-interval');
+    }
+
+    return Math.ceil(scanIntvl * 1000);
+  }
+}
+
+module.exports = JsonHttpConfig;

package/lib/config/device/labjackT4Config.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const _ = require('lodash');
+const { scanInterval, deviceIdentifiers, loadPins } = require('../common/labjackU3T4Common');
+const ConfigError = require('../configError');
+
+class LabjackT4Config {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers() {
+    return deviceIdentifiers();
+  }
+
+  device() {
+    return 'labjack-t4';
+  }
+
+  parse(config = {}) {
+    if (config.device !== this.device()) {
+      return;
+    }
+
+    this.scanInterval = scanInterval(config);
+
+    if (!config.host) {
+      throw new ConfigError('No host defined');
+    }
+
+    this.host = config.host;
+
+    this.pins = loadPins('T4', config);
+  }
+}
+
+module.exports = LabjackT4Config;

package/lib/config/device/labjackT7Config.js

@@ -0,0 +1,192 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+const dacPins = _.times(2, i => `DAC${i}`);
+const analogPins = _.times(14, i => `AIN${i}`);
+const digitalPins = [
+  ..._.times(8, i => `FIO${i}`),
+  ..._.times(8, i => `EIO${i}`),
+  ..._.times(4, i => `CIO${i}`),
+  ..._.times(3, i => `MIO${i}`),
+];
+const allPins = [
+  ...dacPins,
+  ...analogPins,
+  ...digitalPins,
+];
+
+class LabjackT7Config {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers() {
+    return _.map([...analogPins, ...digitalPins], (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  parse(config = {}) {
+    if (config.device !== this.device()) {
+      return;
+    }
+
+    const scanIntervalRequest = config['scan-interval'] || 0.002;
+    const scanInterval4MHz = Math.floor(scanIntervalRequest * 4000000);
+    if (scanInterval4MHz <= 0) {
+      throw new ConfigError('scan-interval must be > 0').atAttribute('scan-interval');
+    }
+    if (scanInterval4MHz > 65535) {
+      throw new ConfigError('scan-interval must be <= 0.016').atAttribute('scan-interval');
+    }
+
+    this.scanInterval = scanInterval4MHz / 4000000;
+
+    if (!config.host) {
+      throw new ConfigError('No host defined');
+    }
+
+    this.host = config.host;
+
+    this.pins = this.loadPins(config);
+
+    // Fill out any pins not explicitly defined with default configs
+    _.each(analogPins, (name) => {
+      if (!this.pins[name]) {
+        this.pins[name] = this.makeAnalogPin({ name });
+      }
+    });
+
+    _.each(digitalPins, (name) => {
+      if (!this.pins[name]) {
+        this.pins[name] = this.makeDigitalPin({ name });
+      }
+    });
+
+    _.each(dacPins, (name) => {
+      if (!this.pins[name]) {
+        this.pins[name] = this.makeDacPin({ name });
+      }
+    });
+  }
+
+  device() {
+    return 'labjack-t7';
+  }
+
+  loadPins(config = {}) {
+    return _.mapValues(config.pins, (defn, name) => {
+      if (!defn) {
+        defn = { };
+      }
+
+      if (!_.includes(allPins, name)) {
+        throw new ConfigError(`${name} is not a valid T7 pin`).atPath(`pins.${name}`);
+      }
+
+      try {
+        if (defn.mode) {
+          throw new ConfigError('Mode cannot be set on T7 analog or digital pins').atAttribute('mode');
+        }
+
+        const direction = this.checkPinDirection(defn, name);
+        const range = this.checkPinRange(defn, name);
+        const dacValue = this.checkPinDacValue(defn, name);
+
+        if (_.includes(analogPins, name)) {
+          return this.makeAnalogPin({ name, range });
+        } else if (_.includes(digitalPins, name)) {
+          return this.makeDigitalPin({ name, direction });
+        } else if (_.includes(dacPins, name)) {
+          return this.makeDacPin({ name, value: dacValue });
+        }
+        throw new ConfigError(`${name} is an unknown pin type`).atPath(`pins.${name}`);
+      } catch (err) {
+        if (err instanceof ConfigError) {
+          err.atSection(`pins.${name}`);
+        }
+        throw err;
+      }
+    });
+  }
+
+  makeAnalogPin({ name, range = 10 }) {
+    return {
+      name,
+      mode: 'analog',
+      direction: 'input',
+      range,
+    };
+  }
+
+  makeDigitalPin({ name, direction = 'input' }) {
+    return {
+      name,
+      mode: 'digital',
+      direction,
+    };
+  }
+
+  makeDacPin({ name, value = 0 }) {
+    return {
+      name,
+      mode: 'dac',
+      value,
+    };
+  }
+
+  checkPinDirection(defn, name) {
+    if (!_.includes(digitalPins, name)) {
+      if (!_.isUndefined(defn.direction)) {
+        throw new ConfigError('Direction can only be set on digital pins').atAttribute('direction');
+      }
+      return null;
+    }
+
+    const direction = defn.direction || 'input';
+    if (!_.includes(['input', 'output'], direction)) {
+      throw new ConfigError('Direction must be one of [input, output]').atAttribute('direction');
+    }
+    return direction;
+  }
+
+  checkPinRange(defn, name) {
+    if (!_.includes(analogPins, name)) {
+      if (!_.isUndefined(defn.range)) {
+        throw new ConfigError('Range can only be set on analog pins').atAttribute('range');
+      }
+      return null;
+    }
+
+    const range = defn.range || 10;
+    if (!_.isNumber(range) || range <= 0) {
+      throw new ConfigError('Range must be > 0').atAttribute('range');
+    }
+    return range;
+  }
+
+  checkPinDacValue(defn, name) {
+    if (!_.includes(dacPins, name)) {
+      if (!_.isUndefined(defn.value)) {
+        throw new ConfigError('Output value can only be set on DAC pins').atAttribute('value');
+      }
+      return null;
+    }
+
+    const value = defn.value || 0;
+    if (!_.isNumber(value) || value < 0 || value > 5) {
+      throw new ConfigError('Output value must be between 0 and 5 (volts)').atAttribute('value');
+    }
+    return value;
+  }
+}
+
+module.exports = LabjackT7Config;

package/lib/config/device/labjackU3Config.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const _ = require('lodash');
+const { scanInterval, deviceIdentifiers, loadPins } = require('../common/labjackU3T4Common');
+
+class LabjackU3Config {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers() {
+    return deviceIdentifiers();
+  }
+
+  device() {
+    return 'labjack-u3';
+  }
+
+  parse(config = {}) {
+    if (config.device !== this.device()) {
+      return;
+    }
+
+    this.scanInterval = scanInterval(config);
+
+    this.pins = loadPins('U3-HV', config);
+  }
+}
+
+module.exports = LabjackU3Config;

package/lib/config/device/modbusTcpConfig.js

@@ -0,0 +1,336 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+class ModbusTcpConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers(config = {}) {
+    const coils = _.map(config.coils, (coil, name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: false,
+      };
+    });
+
+    const registers = _.map(config.registers, (register, name) => {
+      let defaultValue = 0;
+      if (register.type === 'string') {
+        defaultValue = '';
+      }
+
+      return {
+        name,
+        channel: 'device',
+        defaultValue,
+      };
+    });
+
+    return [...coils, ...registers];
+  }
+
+  parse(config = {}) {
+    if (!config.host) {
+      throw new ConfigError('No host defined');
+    }
+
+    this.host = config.host;
+    this.port = config.port || 502;
+    this.unitId = config['unit-id'] || 0;
+
+    this.byteOrder = this.checkByteOrder(config);
+    this.wordOrder = this.checkWordOrder(config);
+    this.addressSpace = this.checkAddressSpace(config);
+    this.stringEncoding = this.checkStringEncoding(config);
+
+    this.scanInterval = this.checkScanInterval(config);
+
+    this.coils = this.loadCoils(config.coils);
+    this.registers = this.loadRegisters(config.registers);
+  }
+
+  loadCoils(coils = {}) {
+    return _(coils).map((defn, name) => {
+      try {
+        const shorthand = !_.isObject(defn);
+        if (shorthand) {
+          defn = { address: defn };
+        }
+
+        const func = this.checkCoilFunction(defn, shorthand);
+        const address = this.checkCoilAddress(defn, shorthand);
+
+        const scanInterval = defn['scan-interval'] ? this.checkScanInterval(defn) : undefined;
+
+        return { name, func, address, scanInterval };
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          error.atSection(`coils.${name}`);
+        }
+        throw error;
+      }
+    }).keyBy('name').value();
+  }
+
+  loadRegisters(registers = {}) {
+    return _(registers).map((defn, name) => {
+      try {
+        const func = this.checkRegisterFunction(defn);
+        const address = this.checkRegisterAddress(defn);
+        const type = this.checkType(defn);
+        const size = this.checkSize(defn);
+
+        const scanInterval = defn['scan-interval'] ? this.checkScanInterval(defn) : undefined;
+
+        return { name, func, address, type, size, scanInterval };
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          error.atSection(`registers.${name}`);
+        }
+        throw error;
+      }
+    }).keyBy('name').value();
+  }
+
+  checkScanInterval(defn) {
+    const scanInterval = +(defn['scan-interval'] || 1.0);
+    if (scanInterval <= 0) {
+      throw new ConfigError('scan-interval must be > 0').atAttribute('scan-interval');
+    }
+
+    return Math.ceil(scanInterval * 1000);
+  }
+
+  checkCoilFunction(defn, shorthand = false) {
+    let func = defn.func || this.addressSpace;
+    let address = defn.address || 0;
+    if (_.isString(address)) {
+      address = parseInt(address, 10);
+    }
+
+    if (func === 'mixed') {
+      if (address > 0 && address < 10000) {
+        func = 1;
+      } else if (address > 10000 && address < 20000) {
+        func = 2;
+      } else {
+        const err = new ConfigError('Address out of range for mixed coil address space');
+        if (!shorthand) {
+          err.atAttribute('address');
+        }
+        throw err;
+      }
+    } else if (func === 'extended') {
+      if (address > 0 && address < 100000) {
+        func = 1;
+      } else if (address > 100000 && address < 200000) {
+        func = 2;
+      } else {
+        const err = new ConfigError('Address out of range for extended coil address space');
+        if (!shorthand) {
+          err.atAttribute('address');
+        }
+        throw err;
+      }
+    }
+
+    if (!_.includes([1, 2], func)) {
+      const err = new ConfigError('Valid functions are 1 or 2');
+      if (!shorthand) {
+        err.atAttribute('function');
+      }
+      throw err;
+    }
+    return func;
+  }
+
+  checkRegisterFunction(defn) {
+    let func = defn.func || this.addressSpace;
+    let address = defn.address || 0;
+    if (_.isString(address)) {
+      address = parseInt(address, 10);
+    }
+
+    if (func === 'mixed') {
+      if (address > 30000 && address < 40000) {
+        func = 4;
+      } else if (address > 40000 && address < 50000) {
+        func = 3;
+      } else {
+        throw new ConfigError('Address out of range for mixed register address space').atAttribute('address');
+      }
+    } else if (func === 'extended') {
+      if (address > 300000 && address < 400000) {
+        func = 4;
+      } else if (address > 400000 && address < 500000) {
+        func = 3;
+      } else {
+        throw new ConfigError('Address out of range for extended register address space').atAttribute('address');
+      }
+    }
+
+    if (!_.includes([3, 4], func)) {
+      throw new ConfigError('Valid functions are 3 or 4').atAttribute('function');
+    }
+    return func;
+  }
+
+  checkCoilAddress(defn, shorthand = false) {
+    const func = defn.func || this.addressSpace;
+    let address = defn.address;
+    if (_.isString(address)) {
+      address = parseInt(address, 10);
+    }
+
+    if (func === 'mixed') {
+      if (address > 0 && address < 10000) {
+        address -= 1;
+      } else if (address > 10000 && address < 20000) {
+        address -= 10001;
+      } else {
+        const err = new ConfigError('Address out of range for mixed coil address space');
+        if (!shorthand) {
+          err.atAttribute('address');
+        }
+        throw err;
+      }
+    } else if (func === 'extended') {
+      if (address > 0 && address < 100000) {
+        address -= 1;
+      } else if (address > 100000 && address < 200000) {
+        address -= 100001;
+      } else {
+        const err = new ConfigError('Address out of range for extended coil address space');
+        if (!shorthand) {
+          err.atAttribute('address');
+        }
+        throw err;
+      }
+    } else if (func >= 1 && func <= 2) {
+      if (address === undefined || address < 0 || address >= 65536) {
+        const err = new ConfigError('Address must be in range [0, 65535]');
+        if (!shorthand) {
+          err.atAttribute('address');
+        }
+      }
+    }
+    return address;
+  }
+
+  checkRegisterAddress(defn) {
+    const func = defn.func || this.addressSpace;
+    let address = defn.address;
+    if (_.isString(address)) {
+      address = parseInt(address, 10);
+    }
+
+    if (func === 'mixed') {
+      if (address > 30000 && address < 40000) {
+        address -= 30001;
+      } else if (address > 40000 && address < 50000) {
+        address -= 40001;
+      } else {
+        throw new ConfigError('Address out of range for mixed register address space').atAttribute('address');
+      }
+    } else if (func === 'extended') {
+      if (address > 300000 && address < 400000) {
+        address -= 300001;
+      } else if (address > 400000 && address < 500000) {
+        address -= 400001;
+      } else {
+        throw new ConfigError('Address out of range for extended register address space').atAttribute('address');
+      }
+    } else if (func >= 3 && func <= 4) {
+      if (address === undefined || address < 0 || address >= 65536) {
+        throw new ConfigError('Address must be in range [0, 65535]').atAttribute('address');
+      }
+    }
+    return address;
+  }
+
+  checkType(defn) {
+    const type = defn.type;
+    if (!_.includes(['int16', 'uint16', 'int32', 'uint32', 'float32', 'string'], type)) {
+      throw new ConfigError('Type must be one of [int16, uint16, int32, uint32, float32, string]').atAttribute('type');
+    }
+    return type;
+  }
+
+  checkStringEncoding(defn) {
+    const encoding = defn['string-encoding'] || 'ascii';
+    if (!_.includes(['ascii', 'utf8', 'ucs2', 'utf16le'], encoding)) {
+      throw new ConfigError('Encoding must be one of [ascii, utf8, ucs2, utf16le]').atAttribute('string-encoding');
+    }
+    return encoding;
+  }
+
+  checkSize(defn) {
+    const type = defn.type;
+    if (type === 'int16' || type === 'uint16') {
+      return 1;
+    } else if (type === 'int32' || type === 'uint32' || type === 'float32') {
+      return 2;
+    }
+
+    const size = defn.size;
+    if (!size) {
+      throw new ConfigError('Size must be specified for string types').atAttribute('size');
+    }
+    return Math.floor((size + 1) / 2);
+  }
+
+  checkByteOrder(defn) {
+    const order = defn['byte-order'] || 'big';
+    if (!_.includes(['big', 'little'], order)) {
+      throw new ConfigError('Valid byte-order values are big and little').atAttribute('byte-order');
+    }
+    return order;
+  }
+
+  checkWordOrder(defn) {
+    const order = defn['word-order'] || 'big';
+    if (!_.includes(['big', 'little'], order)) {
+      throw new ConfigError('Valid word-order values are big and little').atAttribute('word-order');
+    }
+    return order;
+  }
+
+  checkAddressSpace(defn) {
+    let addressSpace = defn['address-space'];
+    if (!addressSpace) {
+      if (this.hasExtendedAddressinging(defn.coils) || this.hasExtendedAddressinging(defn.registers)) {
+        addressSpace = 'extended';
+      } else {
+        addressSpace = 'mixed';
+      }
+    }
+
+    if (!_.includes(['mixed', 'extended', 1, 2, 3, 4], addressSpace)) {
+      throw new ConfigError('Valid address spaces are 1, 2, 3, 4, mixed, or extended').atAttribute('address-space');
+    }
+    return addressSpace;
+  }
+
+  hasExtendedAddressinging(block) {
+    let extended = false;
+    _.each(block, (item) => {
+      if (_.isString(item.address)) {
+        if (item.address.lenth === 6) {
+          extended = true;
+        }
+      } else if (item.address >= 50000) {
+        extended = true;
+      }
+    });
+
+    return extended;
+  }
+}
+
+module.exports = ModbusTcpConfig;