@machinemetrics/io-adapter-lib 2.32.0

package/lib/config/common/labjackU3T4Common.js

@@ -0,0 +1,227 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+const dacPins = _.times(2, i => `DAC${i}`);
+const analogPins = [
+  ..._.times(4, i => `AIN${i}`),
+  ..._.times(4, i => `pin-${i}`), // legacy alias
+];
+const flexiblePins = [
+  ..._.times(4, i => `FIO${i + 4}`),
+  ..._.times(4, i => `EIO${i}`),
+  ..._.times(8, i => `pin-${i + 4}`), // legacy alias
+];
+const digitalPins = [
+  ..._.times(4, i => `EIO${i + 4}`),
+  ..._.times(4, i => `CIO${i}`),
+];
+const allPins = [
+  ...dacPins,
+  ...analogPins,
+  ...flexiblePins,
+  ...digitalPins,
+];
+
+const pins = {
+  dacPins,
+  analogPins,
+  flexiblePins,
+  digitalPins,
+  allPins,
+};
+
+// Legacy is used by V2 pin-X naming and all V1 configs
+const legacyPinMap = _.mapValues(_.keyBy(_.range(12), i => i), i => `pin-${i}`);
+
+const makeAnalogPin = ({ name }) => {
+  return {
+    name,
+    mode: 'analog',
+    direction: 'input',
+  };
+};
+
+const makeDigitalPin = ({ name, direction = 'input', value }) => {
+  return {
+    name,
+    mode: 'digital',
+    direction,
+    value,
+  };
+};
+
+const makeDacPin = ({ name, value = 0 }) => {
+  return {
+    name,
+    mode: 'dac',
+    value,
+  };
+};
+
+const checkPinMode = (defn, name) => {
+  if (!_.includes(flexiblePins, name)) {
+    if (!_.isUndefined(defn.mode)) {
+      throw new ConfigError('Mode can only be set on flexible pins').atAttribute('mode');
+    }
+    return null;
+  }
+  const mode = defn.mode || 'analog';
+  if (!_.includes(['digital', 'analog'], mode)) {
+    throw new ConfigError('Mode must be one of [analog, digital]').atAttribute('mode');
+  }
+  return mode;
+};
+
+const checkPinDirection = (defn, name) => {
+  const isDigital = _.includes(digitalPins, name) || (_.includes(flexiblePins, name) && defn.mode === 'digital');
+  if (!isDigital) {
+    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;
+};
+
+const 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;
+};
+
+const checkPinOutValue = (defn, name) => {
+  const isDigital = _.includes(digitalPins, name) || (_.includes(flexiblePins, name) && defn.mode === 'digital');
+  if (!isDigital) {
+    if (!_.isUndefined(defn.value)) {
+      throw new ConfigError('Value can only be set on digital pins').atAttribute('value');
+    }
+    return null;
+  }
+  const value = defn.value;
+  if (!_.isUndefined(value) && defn.direction !== 'output') {
+    throw new ConfigError('Value can only be set on an output pin').atAttribute('value');
+  }
+  return value;
+};
+
+const deviceIdentifiers = () => {
+  return _.map([...analogPins, ...flexiblePins, ...digitalPins], (name) => {
+    return {
+      name,
+      channel: 'device',
+      defaultValue: 0,
+    };
+  });
+};
+
+const scanInterval = (config) => {
+  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');
+  }
+
+  return scanInterval4MHz / 4000000;
+};
+
+const loadUnreferencedPins = (data) => {
+  // Fill out any pins not explicitly defined with default configs
+  _.each(analogPins, (name) => {
+    if (!data[name]) {
+      data[name] = makeAnalogPin({ name });
+    }
+  });
+  _.each(flexiblePins, (name) => {
+    if (!data[name]) {
+      data[name] = makeAnalogPin({ name });
+    }
+  });
+  _.each(digitalPins, (name) => {
+    if (!data[name]) {
+      data[name] = makeDigitalPin({ name });
+    }
+  });
+  _.each(dacPins, (name) => {
+    if (!data[name]) {
+      data[name] = makeDacPin({ name });
+    }
+  });
+
+  return data;
+};
+
+const loadPins = (deviceName, config = {}) => {
+  const data = _(config.pins).map((defn, name) => {
+    if (!defn) {
+      defn = { };
+    }
+
+    // Deal with legacy pin definitions
+    if (legacyPinMap[+name]) {
+      name = legacyPinMap[+name];
+      if (_.isString(defn)) {
+        if (_.includes(analogPins, name) && defn === 'analog') {
+          defn = { };
+        } else {
+          defn = { mode: defn };
+        }
+      }
+    }
+
+    if (!_.includes(allPins, name)) {
+      throw new ConfigError(`${name} is not a valid ${deviceName} pin`).atPath(`pins.${name}`);
+    }
+
+    try {
+      const mode = checkPinMode(defn, name);
+      const direction = checkPinDirection(defn, name);
+      const outValue = checkPinOutValue(defn, name);
+
+      if (_.includes(analogPins, name)) {
+        return makeAnalogPin({ name });
+      } else if (_.includes(flexiblePins, name)) {
+        if (mode === 'analog') {
+          return makeAnalogPin({ name });
+        }
+        return makeDigitalPin({ name, direction, value: outValue });
+      } else if (_.includes(digitalPins, name)) {
+        return makeDigitalPin({ name, direction, value: outValue });
+      } else if (_.includes(dacPins, name)) {
+        const dacValue = checkPinDacValue(defn, name);
+        return 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;
+    }
+  }).keyBy('name').value();
+
+  return loadUnreferencedPins(data);
+};
+
+module.exports = {
+  pins,
+  deviceIdentifiers,
+  scanInterval,
+  loadPins,
+};

package/lib/config/common/validations.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+const checkRequired = (defn, fieldName, required = false) => {
+  if (required && !_.has(defn, fieldName)) {
+    throw new ConfigError(`${fieldName} is required`).atAttribute(fieldName);
+  }
+};
+
+module.exports = {
+  checkInterval: (defn, fieldName, defaultValue = 1) => {
+    const interval = defn[fieldName] ?? defaultValue;
+    const pattern = /^\d+\s*(ms|s|m|h|d|w)?$/;
+    if (!_.isString(interval) || !pattern.test(interval)) {
+      throw new ConfigError(`${fieldName} must be > 0 with optional time unit (ms, s, m, h, d, w)`).atAttribute(fieldName);
+    }
+
+    return interval;
+  },
+
+  checkTimezone: (defn, fieldName) => {
+    const timezone = defn[fieldName];
+    if (timezone) {
+      if (!_.isString(timezone) || !timezone.match(/^[A-Za-z0-9+-_]+(\/[A-Za-z0-9+-_]+)*$/)) {
+        throw new ConfigError(`${fieldName} must be a valid TZ identifier`).atAttribute(fieldName);
+      }
+    }
+
+    return timezone;
+  },
+
+  checkScanInterval: (defn, fieldName, { defaultValue = 1, scale = 1 } = {}) => {
+    const scanRate = defn[fieldName] ?? defaultValue;
+    if (scanRate < 0) {
+      throw new ConfigError('Scan interval must be > 0').atAttribute(fieldName);
+    }
+
+    return scanRate * scale;
+  },
+
+  checkEndpoint: (defn, fieldName, { required = true, defaultPort = undefined } = {}) => {
+    checkRequired(defn, fieldName, required);
+    const endpoint = defn[fieldName];
+
+    if (endpoint) {
+      if (!endpoint.match(/^[\w.]+(:\d+)?$/)) {
+        throw new ConfigError('Invalid endpoint').atAttribute(fieldName);
+      }
+
+      const [host, port] = endpoint.split(':');
+      return { host, port: port ? (+port) : defaultPort };
+    }
+
+    return null;
+  },
+
+  checkNumber: (defn, fieldName, {
+    required = false,
+    defaultValue = 0,
+    min = undefined,
+    max = undefined,
+    exclusiveMin = undefined,
+    exclusiveMax = undefined,
+  } = {}) => {
+    checkRequired(defn, fieldName, required);
+
+    const value = defn[fieldName] ?? defaultValue;
+
+    if (!_.isNil(min) && value < min) {
+      throw new ConfigError(`${fieldName} must be >= ${min}`).atAttribute(fieldName);
+    }
+
+    if (!_.isNil(max) && value > max) {
+      throw new ConfigError(`${fieldName} must be <= ${max}`).atAttribute(fieldName);
+    }
+
+    if (!_.isNil(exclusiveMin) && value <= exclusiveMin) {
+      throw new ConfigError(`${fieldName} must be > ${exclusiveMin}`).atAttribute(fieldName);
+    }
+
+    if (!_.isNil(exclusiveMax) && value >= exclusiveMax) {
+      throw new ConfigError(`${fieldName} must be < ${exclusiveMax}`).atAttribute(fieldName);
+    }
+
+    return value;
+  },
+
+  checkBoolean: (defn, fieldName, { required = false, defaultValue = false } = {}) => {
+    checkRequired(defn, fieldName, required);
+
+    let value = defn[fieldName] ?? defaultValue;
+
+    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 ConfigError('Value must be true or false').atAttribute(fieldName);
+  },
+
+  checkReset: (defn, fieldName = 'reset') => {
+    const adapterReset = defn[fieldName];
+
+    if (!adapterReset) {
+      return null;
+    }
+
+    if (!_.isObject(adapterReset)) {
+      throw new ConfigError(`${fieldName} must be an object`).atAttribute(fieldName);
+    }
+
+    const result = {};
+
+    if (_.has(adapterReset, 'interval')) {
+      const interval = adapterReset.interval;
+      if (!_.isNumber(interval) || interval <= 0) {
+        throw new ConfigError('interval must be a number > 0').atPath(`${fieldName}.interval`);
+      }
+      result.interval = interval;
+    }
+
+    if (_.has(adapterReset, 'no-change-timeout')) {
+      const noChangeTimeout = adapterReset['no-change-timeout'];
+      if (!_.isNumber(noChangeTimeout) || noChangeTimeout <= 0) {
+        throw new ConfigError('no-change-timeout must be a number > 0').atPath(`${fieldName}.no-change-timeout`);
+      }
+      result.noChangeTimeout = noChangeTimeout;
+    }
+
+    return _.isEmpty(result) ? null : result;
+  },
+};

package/lib/config/configError.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const _ = require('lodash');
+
+class ConfigError extends Error {
+  atPath(path) {
+    if (_.isString(path)) {
+      path = path.split('.');
+    }
+
+    this.section = _.initial(path);
+    this.attribute = _.last(path);
+
+    return this;
+  }
+
+  atSection(section) {
+    if (_.isString(section)) {
+      section = section.split('.');
+    }
+
+    this.section = section;
+    return this;
+  }
+
+  atAttribute(attribute) {
+    this.attribute = attribute;
+    return this;
+  }
+}
+
+module.exports = ConfigError;

package/lib/config/device/adam-6052Config.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+const digiCountPins = [
+  ..._.times(8, i => `DI${i}`),
+  ..._.times(8, i => `pin-${i}`),
+];
+
+const allPins = [
+  ...digiCountPins,
+];
+
+// Legacy is used by V2 pin-X naming and all V1 configs
+const legacyPinMap = _.mapValues(_.keyBy(_.range(8), i => i), i => `pin-${i}`);
+
+class AdamConfig {
+  constructor(expressionService) {
+    this.expressionService = expressionService;
+
+    _.each(this.getIdentifiers(), name => this.expressionService.addName(name));
+  }
+
+  getIdentifiers() {
+    return _.map(allPins, (name) => {
+      return {
+        name,
+        channel: 'device',
+        defaultValue: 0,
+      };
+    });
+  }
+
+  parse(config = {}) {
+    if (!config.host) {
+      throw new ConfigError('No host defined');
+    }
+
+    this.host = config.host;
+    this.pins = this.loadPins(config);
+  }
+
+  loadPins(config = {}) {
+    return _(config.pins).map((defn, name) => {
+      if (!defn) {
+        defn = { };
+      }
+
+      // Deal with legacy pin definitions
+      if (legacyPinMap[+name]) {
+        name = legacyPinMap[+name];
+      }
+      if (_.isString(defn)) {
+        defn = { mode: defn };
+      }
+
+      if (!_.includes(allPins, name)) {
+        throw new ConfigError(`${name} is not a valid ADAM-6052 pin`).atPath(`pins.${name}`);
+      }
+
+      try {
+        const mode = this.checkPinMode(defn, name);
+
+        if (mode === 'digital') {
+          return this.makeDigitalPin({ name });
+        } else if (mode === 'counter') {
+          return this.makeCounterPin({ name });
+        }
+        throw new ConfigError(`${name} is an unknown pin type`).atPath(`pins.${name}`);
+      } catch (err) {
+        if (err instanceof ConfigError) {
+          err.atSection(`pins.${name}`);
+        }
+        throw err;
+      }
+    }).keyBy('name').value();
+  }
+
+  makeDigitalPin({ name }) {
+    return {
+      name,
+      mode: 'digital',
+    };
+  }
+
+  makeCounterPin({ name }) {
+    return {
+      name,
+      mode: 'counter',
+    };
+  }
+
+  checkPinMode(defn) {
+    const mode = defn.mode || 'digital';
+    if (!_.includes(['digital', 'counter'], mode)) {
+      throw new ConfigError('Mode must be one of [digital, counter]').atAttribute('mode');
+    }
+    return mode;
+  }
+}
+
+module.exports = AdamConfig;