@machinemetrics/io-adapter-lib 2.32.0

package/lib/config/device/brotherHTTPConfig.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+class BrotherHTTPConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+    this.macroSettings = expressionService.config['macro-settings'] || {};
+
+    this.DataCollectionModes =
+    {
+      HTTP: 'HTTP',
+      FTP: 'FTP',
+      MIXED: 'MIXED',
+    };
+
+    const mode = expressionService.config['collection-mode'];
+    const defaultMode = this.DataCollectionModes.MIXED;
+    if (mode === undefined) this.dataCollectionMode = defaultMode;
+    else if (mode.toLowerCase() === 'http') this.dataCollectionMode = this.DataCollectionModes.HTTP;
+    else if (mode.toLowerCase() === 'ftp') this.dataCollectionMode = this.DataCollectionModes.FTP;
+    else if (mode.toLowerCase() === 'mixed') this.dataCollectionMode = this.DataCollectionModes.MIXED;
+
+    if (this.dataCollectionMode === this.DataCollectionModes.FTP) {
+      this.macros = expressionService.config.macros || {};
+    } else {
+      this.macros = {};
+    }
+
+    _.each(
+      this.getIdentifiers(_.keys(this.macros)),
+      name => this.expressionService.addName(name)
+    );
+  }
+
+  getFixedKeys() {
+    if (this.dataCollectionMode === this.DataCollectionModes.HTTP) {
+      return [
+        'part_count',
+        'custom_part_count_1',
+        'custom_part_count_2',
+        'custom_part_count_3',
+        'custom_part_count_4',
+        'operating_status',
+        'program_number_1',
+        'program_number_2',
+        'execution',
+        'machine_name',
+        'machine_model',
+      ];
+    } else if (this.dataCollectionMode === this.DataCollectionModes.MIXED) {
+      return [
+        'part_count',
+        'custom_part_count_1',
+        'custom_part_count_2',
+        'custom_part_count_3',
+        'custom_part_count_4',
+        'operating_status',
+        'program_number_1',
+        'program_number_2',
+        'execution',
+        'program_comment_1',
+        'program_comment_2',
+        'machine_name',
+        'machine_model',
+      ];
+    } else if (this.dataCollectionMode === this.DataCollectionModes.FTP) {
+      return [
+        'part_count',
+        'custom_part_count_1',
+        'custom_part_count_2',
+        'custom_part_count_3',
+        'custom_part_count_4',
+        'operating_status',
+        'cutting_1',
+        'cutting_2',
+        'program_number_1',
+        'program_number_2',
+        'rapid_traverse_override',
+        'feedrate_override',
+        'spindle_override',
+        'feedrate',
+        'spindle_speed',
+        'execution',
+        'emergency_stop',
+        'program_comment_1',
+        'program_comment_2',
+        'controller_mode',
+      ];
+    } else return [];
+  }
+
+  getIdentifiers(macroKeys) {
+    return _.map(this.getFixedKeys().concat(macroKeys), (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  /** For non-FTP modes a determination of whether or not part_count
+   * is available can only be made in the adapter; exclude here, added
+   * in adapter as appropriate. Do the same for program_number_2 (mixed/http) and
+   * program_comment_2 (mixed), meaningful only for two pallet machines.
+   *
+   * Leave the FTP mode alone since it is at this point at any rate considered experimental.
+   */
+  postParse(config) {
+    if (this.dataCollectionMode === this.DataCollectionModes.HTTP ||
+        this.dataCollectionMode === this.DataCollectionModes.MIXED) {
+      _.each(this.getFixedKeys().concat(_.map(this.macros, (_value, key) => { return key; })), (key) => {
+        if (key !== 'part_count' && key !== 'program_number_2' && key !== 'program_comment_2') {
+          config.adapter.loadDataItem(key, key);
+        }
+      });
+    } else {
+      _.each(this.getFixedKeys().concat(_.map(this.macros, (_value, key) => { return key; })), (key) => {
+        config.adapter.loadDataItem(key, key);
+      });
+    }
+  }
+
+  parse(config = {}) {
+    this.endpoint = config.endpoint;
+    this.username = config.username;
+    this.password = config.password;
+
+    if (!config.endpoint) {
+      throw new ConfigError('No endpoint defined').atAttribute('endpoint');
+    }
+
+    const [host, port] = config.endpoint.split(':');
+    this.host = host;
+    this.port = port || 21;
+
+    this.scanInterval = this.checkScanInterval(config);
+    this.httpInterval = this.checkHttpInterval(config);
+
+    /** Configuration indicates how to collect data:
+    *  HTTP only,
+    *  FTP only (default),
+    *  HTTP + FTP for program headers
+    */
+    let mode = config['collection-mode'] ?? '';
+    if (_.isString(mode)) {
+      mode = mode.toLowerCase();
+    }
+    if (!_.includes(['http', 'ftp', 'mixed'], mode)) {
+      throw new ConfigError('collection-mode must be one of: {http, ftp, mixed}').atAttribute('macros');
+    }
+
+    let keysThatAlreadyExist = '';
+    _.forEach(this.macros, (_value, key) => {
+      if (_.findIndex(this.getFixedKeys(), (itm) => { return itm === key; }) !== -1) {
+        keysThatAlreadyExist = `${keysThatAlreadyExist}${key}; `;
+      }
+    });
+    if (keysThatAlreadyExist !== '') {
+      throw new ConfigError(`The following macro keys are already in use: ${keysThatAlreadyExist}`).atAttribute('macros');
+    }
+
+    /** Macro program call control type set in the Data Bank -> G/M code macro section:
+     * 0 = Type 1
+     * 1 = Type 2
+     */
+    if (this.macroSettings.type === undefined) this.macroSettings.type = 'type1';
+    if (!(this.macroSettings.type === 'type1' || this.macroSettings.type === 'type2')) {
+      throw new ConfigError('The value of macro-settings key type must be either type1 or type2').atAttribute('type');
+    }
+
+    if (this.macroSettings.units === undefined) {
+      this.macroSettings.units = 'inches';
+    }
+    if (!(this.macroSettings.units === 'inches' || this.macroSettings.units === 'metric')) {
+      throw new ConfigError('The value of macro-settings key units must be either inches or metric').atAttribute('units');
+    }
+
+    if (this.macroSettings.databank === undefined) {
+      this.macroSettings.databank = 1;
+    }
+    const dataBankNum = Number(this.macroSettings.databank);
+    if (Number.isNaN(dataBankNum) || dataBankNum < 0 || dataBankNum > 10) {
+      throw new ConfigError('The value of macro-settings key databank must be 0 <= x <= 9').atAttribute('databank');
+    }
+
+    _.forEach(this.macros, (value, key) => {
+      if (value === '' || value === null || Number.isNaN(Number(value))) {
+        throw new ConfigError(`The value of macros key ${key} must be a valid integer`).atAttribute(key);
+      }
+    });
+  }
+
+  checkScanInterval(config) {
+    const scanIntvl = +(config['scan-interval'] || 1.0);
+    if (scanIntvl <= 0) {
+      throw new ConfigError('scan-interval must be > 0').atAttribute('scan-interval');
+    }
+
+    return Math.ceil(scanIntvl * 1000);
+  }
+
+  checkHttpInterval(config) {
+    const httpIntvl = +(config['http-interval'] || 0.05);
+    if (httpIntvl <= 0) {
+      throw new ConfigError('http-interval must be > 0').atAttribute('http-interval');
+    }
+
+    return Math.ceil(httpIntvl * 1000);
+  }
+}
+
+module.exports = BrotherHTTPConfig;

package/lib/config/device/ethernetIPConfig.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+const validations = require('../common/validations');
+
+class EthernetIPConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers(config = {}) {
+    return _.map(_.keys(config.tags), (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  parse(config = {}) {
+    this.host = this.checkHost(config);
+    this.slot = this.checkSlot(config);
+    this.scanRate = this.checkScanInterval(config);
+    this.groupRead = this.checkGroupRead(config);
+    this.reset = validations.checkReset(config);
+    this.tags = this.loadTags(config.tags);
+  }
+
+  loadTags(tags) {
+    // Shorthand syntax: tags: { name: 'path' }
+    tags = _.mapValues(tags, (tag, name) => {
+      if (_.isString(tag)) {
+        // TODO: We'd really like to examine newlines but YAML strips them.  Another yaml library could surface this.
+        if (/^path\s+/.test(tag)) {
+          throw new ConfigError('Malformed tag definition.  Possible mix of shorthand and standard form.').atSection('tags').atAttribute(name);
+        }
+
+        return { path: tag };
+      }
+      return tag;
+    });
+
+    return _(tags).map((defn, name) => {
+      try {
+        const tagPath = this.checkTagPath(defn);
+
+        return {
+          name,
+          path: tagPath,
+          verboseSample: !!defn['verbose-sample'],
+          verboseEmit: !!defn['verbose-emit'],
+        };
+      } catch (error) {
+        if (error instanceof ConfigError) {
+          error.atSection(`tags.${name}`);
+        }
+        throw error;
+      }
+    }).keyBy('name').value();
+  }
+
+  checkHost(defn) {
+    const host = defn.host;
+    if (_.isEmpty(host)) {
+      throw new ConfigError('An IP or hostname must be specified').atPath('host');
+    }
+
+    return host;
+  }
+
+  checkSlot(defn) {
+    const slot = defn.slot || 0;
+    return slot;
+  }
+
+  checkScanInterval(defn) {
+    const scanRate = defn['scan-interval'] || 0.2;
+    if (scanRate < 0) {
+      throw new ConfigError('Scan interval must be > 0').atPath('scan-interval');
+    }
+
+    return scanRate * 1000;
+  }
+
+  checkGroupRead(defn) {
+    const groupRead = _.get(defn, 'group-read', true);
+    try {
+      return EthernetIPConfig.booleanCast(groupRead);
+    } catch (err) {
+      throw new ConfigError('Value must be true or false').atPath('group-read');
+    }
+  }
+
+  checkTagPath(defn) {
+    const path = defn.path;
+    if (!path) {
+      throw new ConfigError('No tag path specified');
+    }
+
+    if (!EthernetIPConfig.isValidTagname(path)) {
+      throw new ConfigError('Invalid tag path').atAttribute('path');
+    }
+
+    return path;
+  }
+
+  static booleanCast(value) {
+    if (_.isString(value)) {
+      value = value.toLowerCase();
+    } else if (_.isNumber(value)) {
+      value = value.toString();
+    }
+
+    if (value === true || value === 'true' || value === 'yes' || value === '1') {
+      return true;
+    }
+    if (value === false || value === 'false' || value === 'no' || value === '0') {
+      return false;
+    }
+
+    throw new Error();
+  }
+
+  /* eslint prefer-template: 0 */
+  // Tag validation borrowed from ethernet-ip project
+
+  static isValidTagname(tagname) {
+    // regex components
+    const nameRegex = (captureIndex) => {
+      return `(_?[a-zA-Z]|_\\d)(?:(?=(_?[a-zA-Z0-9]))\\${captureIndex})*`;
+    };
+
+    const multDimArrayRegex = '(\\[\\d+(,\\d+){0,2}])';
+    const arrayRegex = '(\\[\\d+])';
+    const bitIndexRegex = '(\\.\\d{1,2})';
+
+    // user regex for user tags
+    const userRegex = new RegExp(
+      '^(Program:' +
+      nameRegex(3) +
+      '\\.)?' + // optional program name
+      nameRegex(5) +
+      multDimArrayRegex +
+      '?' + // tag name
+      '(\\.' +
+      nameRegex(10) +
+      arrayRegex +
+      '?)*' + // option member name
+      bitIndexRegex +
+      '?$'
+    ); // optional bit index
+    // full user regex
+    // ^(Program:(_?[a-zA-Z]|_\d)(?:(?=(_?[a-zA-Z0-9]))\3)*\.)?(_?[a-zA-Z]|_\d)(?:(?=(_?[a-zA-Z0-9]))\5)*
+    //    (\[\d+(,\d+){0,2}])?(\.(_?[a-zA-Z]|_\d)(?:(?=(_?[a-zA-Z0-9]))\10)*(\[\d+])?)*(\.\d{1,2})?$
+
+    // module regex for module tags
+    const moduleRegex = new RegExp(
+      '^' +
+      nameRegex(2) + // module name
+      '(:\\d{1,2})?' + // optional slot num (not required for rack optimized connections)
+      ':[IOC]' + // input/output/config
+      '(\\.' +
+      nameRegex(6) +
+      arrayRegex +
+      '?)?' + // optional member with optional array index
+      bitIndexRegex +
+      '?$'
+    ); // optional bit index
+    // full module regex
+    // ^(_?[a-zA-Z]|_\d)(?:(?=(_?[a-zA-Z0-9]))\2)*(:\d{1,2})?:[IOC](\.(_?[a-zA-Z]|_\d)(?:(?=(_?[a-zA-Z0-9]))\6)*
+    //    (\[\d+])?)?(\.\d{1,2})?$
+
+    if (!userRegex.test(tagname) && !moduleRegex.test(tagname)) {
+      return false;
+    }
+
+    // check segments
+    if (tagname.split(/[:.[\],]/).filter(segment => segment.length > 40).length > 0) {
+      return false; // check that all segments are <= 40 char
+    }
+
+    // passed all tests
+    return true;
+  }
+}
+
+module.exports = EthernetIPConfig;

package/lib/config/device/ifmIotConfig.js

@@ -0,0 +1,245 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+class IfmIotConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(expressionService.config), name => this.expressionService.addName(name));
+  }
+
+  parse(config = {}) {
+    if (config.device !== this.device()) {
+      return;
+    }
+
+    this.endpoint = this.parseEndpoint(config.endpoint);
+    this.iolink = this.parseIOLink(config.iolink);
+    this.findIODD = this.checkFindIODD(config);
+    this.scanInterval = this.checkScanInterval(config);
+    this.deviceScanInterval = this.checkDeviceScanInterval(config);
+    this.declaredKeys = this.getDeclaredKeys(config);
+  }
+
+  device() {
+    return 'iolink-ifm-iot';
+  }
+
+  getIdentifiers(config = {}) {
+    const keys = [...this.getRecordKeys(config), ...this.getDeclaredKeys(config)];
+    return _.map(keys, (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  getRecordKeys(config = {}) {
+    if (!_.isObject(config.iolink)) {
+      return [];
+    }
+
+    const ports = _.map(config.iolink, (port, name) => {
+      if (!name.match(/^port\d+$/)) {
+        return [];
+      }
+
+      const pdata = port['process-data'];
+      if (!_.isObject(pdata)) {
+        return [];
+      }
+
+      return _.map(pdata, (record, rname) => {
+        return rname;
+      });
+    });
+
+    return _.flatten(ports);
+  }
+
+  getDeclaredKeys(config = {}) {
+    let attribute = 'declare-keys';
+    if (!config[attribute] && config.keys) {
+      attribute = 'keys';
+    }
+
+    const keys = config[attribute];
+    if (_.isEmpty(keys)) {
+      return [];
+    }
+    if (!_.isArray(keys)) {
+      throw new ConfigError('list expected').atAttribute(attribute);
+    }
+
+    return keys;
+  }
+
+  checkScanInterval(defn) {
+    const scanRate = defn['scan-interval'] || 1;
+    if (scanRate <= 0) {
+      throw new ConfigError('Scan interval must be > 0').atPath('scan-interval');
+    }
+
+    return scanRate * 1000;
+  }
+
+  checkDeviceScanInterval(defn) {
+    const scanRate = defn['device-scan-interval'] || 10;
+    if (scanRate < 0) {
+      throw new ConfigError('Device scan interval must be >= 0').atPath('device-scan-interval');
+    }
+
+    return scanRate * 1000;
+  }
+
+  parseEndpoint(endpoint) {
+    if (!endpoint) {
+      throw new ConfigError('No endpoint defined').atAttribute('endpoint');
+    }
+
+    // HTTP/S URLs are returned directly
+    if (endpoint.match(/^https?:\/\//)) {
+      return endpoint;
+    } else if (endpoint.match(/^\w+:\/\//)) {
+      throw new ConfigError('Unexpected endpoint protocol').atAttribute('endpoint');
+    }
+
+    // Assume HTTP protocol by default
+    return `http://${endpoint}`;
+  }
+
+  parseIOLink(iolink) {
+    const ports = [];
+    const keys = _.keys(iolink);
+
+    _.each(keys, (key) => {
+      const match = key.match(/^port(\d+)$/);
+      if (match === null) {
+        return;
+      }
+
+      const portNum = match[1];
+      ports.push(this.parsePort(iolink[key], portNum));
+    });
+
+    return ports;
+  }
+
+  parsePort(port, portNum) {
+    return {
+      portNumber: portNum,
+      enabled: this.parseBool(port.enabled ?? true),
+      processData: this.parseProcessData(port),
+    };
+  }
+
+  parseProcessData(defn) {
+    const data = defn['process-data'] ?? {};
+    if (!_.isObject(data)) {
+      throw new ConfigError('Invalid processd data').atAttribute('process-data');
+    }
+
+    return _.map(data, this.parseProcessDataRecord.bind(this));
+  }
+
+  parseProcessDataRecord(record, name) {
+    return {
+      name,
+      enabled: this.parseBool(record.enabled ?? true),
+      bitOffset: this.checkBitOffset(record),
+      bitLength: this.checkBitLength(record),
+      type: this.checkType(record),
+      gradient: this.checkGradient(record),
+      offset: this.checkOffset(record),
+    };
+  }
+
+  checkPortEnabled(defn) {
+    return this.parseBool(defn.enabled);
+  }
+
+  checkBitOffset(defn) {
+    const offset = defn['bit-offset'];
+    if (_.isUndefined(offset)) {
+      throw new ConfigError('bit-offset must be specified').atAttribute('bit-offset');
+    }
+    if (!_.isNumber(offset) || offset < 0) {
+      throw new ConfigError('bit-offset must be >= 0').atAttribute('bit-offset');
+    }
+
+    return offset;
+  }
+
+  checkBitLength(defn) {
+    const length = defn['bit-length'];
+    if (_.isUndefined(length)) {
+      throw new ConfigError('bit-length must be specified').atAttribute('bit-length');
+    }
+    if (!_.isNumber(length) || length < 0) {
+      throw new ConfigError('bit-length must be >= 0').atAttribute('bit-length');
+    }
+
+    return length;
+  }
+
+  checkType(defn) {
+    let type = defn.type;
+    if (_.isString(type)) {
+      type = type.toLowerCase();
+    }
+
+    if (!_.includes(['bool', 'uint', 'int', 'float', 'booleant', 'uintegert', 'integert', 'float32t'], type)) {
+      throw new ConfigError('type must be one of the supported data types: [bool, uint, int, float]').atAttribute('type');
+    }
+
+    return type;
+  }
+
+  checkGradient(defn) {
+    const gradient = defn.gradient;
+    if (_.isUndefined(gradient)) {
+      return 1;
+    }
+    if (!_.isNumber(gradient)) {
+      throw new ConfigError('gradient must be numeric').atAttribute('gradient');
+    }
+
+    return gradient;
+  }
+
+  checkOffset(defn) {
+    const offset = defn.offset;
+    if (_.isUndefined(offset)) {
+      return 0;
+    }
+    if (!_.isNumber(offset)) {
+      throw new ConfigError('offset must be numeric').atAttribute('offset');
+    }
+
+    return offset;
+  }
+
+  checkFindIODD(defn) {
+    const findIODD = defn['find-iodd'];
+    if (_.isUndefined(findIODD)) {
+      return true;
+    }
+
+    return this.parseBool(findIODD);
+  }
+
+  parseBool(value) {
+    if (_.isString(value)) {
+      value = value.toLowerCase();
+      return value === 'true';
+    }
+
+    return !!_.toInteger(value);
+  }
+}
+
+module.exports = IfmIotConfig;