@machinemetrics/io-adapter-lib 2.32.0

package/lib/transform/valueIncrease.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const TransformState = require('./transformState');
+
+/**
+ * Emits a T signal each time the value increases in a stream.
+ */
+class ValueIncreaseFilter extends TransformState {
+  constructor() {
+    super();
+
+    this.defaultValue = false;
+    this.value = false;
+    this.previousValue = false;
+  }
+
+  static op = 'value-increase';
+
+  static create(_args) {
+    return new ValueIncreaseFilter();
+  }
+
+  filter(context, value, time) {
+    this.commitValue(context, +value, time);
+  }
+
+  emitUpdate(context) {
+    if (this.forceEmit || (this.value > this.previousValue && this.valueTime === this.lastSampleTime)) {
+      this.forceEmit = false;
+      this.lastEmitValue = this.value;
+      this.lastEmitTime = this.lastSampleTime;
+      this.emit('update', true, this.lastSampleTime, context);
+    }
+    this.emit('update', false, this.lastSampleTime, context);
+  }
+}
+
+module.exports = ValueIncreaseFilter;

package/lib/transform/valueIncreaseDiff.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const TransformState = require('./transformState');
+
+/**
+ * Emits a diff value followed by a persistent 0 each time the input value increases
+ */
+class ValueIncreaseDiffFilter extends TransformState {
+  constructor() {
+    super();
+
+    this.defaultValue = 0;
+    this.value = 0;
+    this.previousValue = 0;
+    this.ignoreFirst = true;
+  }
+
+  static op = 'value-increase-diff';
+
+  static create(_args) {
+    return new ValueIncreaseDiffFilter();
+  }
+
+  filter(context, value, time) {
+    value = +value;
+
+    if (this.ignoreFirst) {
+      this.ignoreFirst = false;
+      this.value = value;
+      this.previousValue = value;
+      this.valueTime = time;
+      this.previousValueTime = time;
+      return;
+    }
+
+    // Unconditionally swap over current to previous to avoid "multi-emitting" the diff
+    // event if multiple source updates trigger multiple executions of the transform chain
+    this.previousValue = this.value;
+    this.previousValueTime = this.valueTime;
+    this.value = value;
+    this.valueTime = time;
+  }
+
+  emitUpdate(context) {
+    const diff = this.value - this.previousValue;
+
+    if (this.forceEmit || this.valueTime === this.lastSampleTime) {
+      this.forceEmit = false;
+      this.lastEmitValue = this.value;
+      this.lastEmitTime = this.lastSampleTime;
+
+      if (diff > 0) {
+        this.emit('update', diff, this.lastSampleTime, context);
+      }
+    }
+
+    this.emit('update', 0, this.lastSampleTime, context);
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.ignoreFirst = true;
+  }
+}
+
+module.exports = ValueIncreaseDiffFilter;

package/lib/transform/whenUnavailable.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const TransformState = require('./transformState');
+
+/**
+ * Checks incoming value for special UNAVAILABLE state
+ *
+ * When the incoming value is UNAVAILABLE (exact match including case), the corresponding expression
+ * is executed for the result value.  The expression itself may result in UNAVAILABLE.  When the
+ * incoming value is anything else, it is passed through.
+ */
+class WhenUnavailableFilter extends TransformState {
+  constructor({ engine, path, args: { compiledExpression } }) {
+    super();
+
+    this.engine = engine;
+    this.compiledExpression = compiledExpression;
+    this.selfSources = engine.expressionService.expressionTriggers(path);
+  }
+
+  static op = 'when-unavailable';
+
+  static create(args) {
+    return new WhenUnavailableFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const expression = (defn.args[defn.func] ?? '').toString();
+    const compiledExpression = configUtil.compileExpression(expression, this.op);
+
+    defn.args = { expression, compiledExpression };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    return configUtil.getExpressions(body, info);
+  }
+
+  setUnavailable(context, time) {
+    this.update(context, 'UNAVAILABLE', time);
+  }
+
+  filter(context, value, time) {
+    if (value !== 'UNAVAILABLE') {
+      this.commitValue(context, value, time);
+      return;
+    }
+
+    const localState = {};
+    const unavailTerm = this.selfSources.reduce((res, name) => {
+      const state = this.engine.getState(name);
+      localState[name] = state?.value;
+      return res || !state || !state.available;
+    }, false);
+
+    if (unavailTerm) {
+      super.setUnavailable(context, time);
+      return;
+    }
+
+    try {
+      if (!this.origin) {
+        localState.this = value;
+      }
+      this.commitValue(context, this.compiledExpression.evaluate(localState), time);
+    } catch (err) {
+      // Probably a type error in one of the arguments.
+      this.recordError(context, err, time);
+      super.setUnavailable(context, time);
+    }
+  }
+}
+
+module.exports = WhenUnavailableFilter;

package/lib/transform/windowCount.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Keeps a count of all rising edges (F->T) that appear in a given sliding window.
+ *
+ * For every incoming sample, the internal counter value will be emitted.  When a new rising edge
+ * is found, the counter will be incremented.  When a previously seen rising edge is older than the
+ * configured window length, the counter will be decremented.
+ */
+class WindowCountFilter extends TransformState {
+  constructor(window) {
+    super();
+
+    this.defaultValue = false;
+    this.window = window;
+    this.initReset();
+  }
+
+  static op = 'window-count';
+
+  static create(args) {
+    return new WindowCountFilter(args.args.window);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const { value: window, usingShorthand } = configUtil.getArgOrShorthand(defn, 'window');
+    configUtil.requirePositive(window, usingShorthand ? this.op : 'window', this.op);
+
+    defn.args = { window };
+  }
+
+  initReset() {
+    this.value = false;
+    this.previousValue = false;
+    this.countHistory = [];
+  }
+
+  update(context, value, time) {
+    this.lastSampleTime = time;
+    if (!this.available) {
+      this.available = true;
+
+      // Don't count when becoming available already in a high state
+      this.emitUpdate(context);
+      return;
+    }
+
+    this.filter(context, value, time);
+    this.emitUpdate(context);
+  }
+
+  emitUpdate(context) {
+    if (this.countHistory.length > 0 && this.countHistory[0] <= this.lastSampleTime - this.window) {
+      const [expired, current] = _.partition(this.countHistory, t => t < this.lastSampleTime - this.window);
+      this.countHistory = current;
+
+      // Go through all recorded events older than sliding window, and emit new counter values at the times
+      // they should have exactly expired.
+      _.reduce(expired, (count, t) => {
+        this.emit('update', count - 1, t + this.window, context);
+        return count - 1;
+      }, current.length + expired.length);
+
+      // An event that expired at exactly lastSampleTime is handled separately from above, and will be
+      // accounted for in the normal emit.
+      if (this.countHistory.length > 0 && this.countHistory[0] === this.lastSampleTime - this.window) {
+        this.countHistory.shift();
+      }
+    }
+
+    if (this.value && this.valueTime === this.lastSampleTime) {
+      this.countHistory.push(this.lastSampleTime);
+    }
+    this.emit('update', this.countHistory.length, this.lastSampleTime, context);
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = WindowCountFilter;

package/lib/util/fileUtil.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  mkdirSync: (targetDir, { isRelativeToScript = false } = {}) => {
+    const initDir = path.isAbsolute(targetDir) ? path.sep : '';
+    const baseDir = isRelativeToScript ? __dirname : '.';
+
+    targetDir.split(path.sep).reduce((parentDir, childDir) => {
+      const curDir = path.resolve(baseDir, parentDir, childDir);
+      try {
+        fs.mkdirSync(curDir);
+      } catch (err) {
+        if (err.code === 'EEXIST' || err.code === 'EISDIR') {
+          return curDir;
+        }
+        if (err.code === 'EPERM') {
+          if (fs.existsSync(curDir)) {
+            return curDir;
+          }
+        }
+
+        throw err;
+      }
+
+      return curDir;
+    }, initDir);
+  },
+
+  ensureFileDirectoryExistence: (filePath) => {
+    const dirname = path.dirname(filePath);
+    return module.exports.ensureDirectoryExistence(dirname);
+  },
+
+  ensureDirectoryExistence: (dirPath) => {
+    if (fs.existsSync(dirPath)) {
+      return;
+    }
+
+    fs.mkdirSync(dirPath, { recursive: true });
+  },
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@machinemetrics/io-adapter-lib",
+  "version": "2.32.0",
+  "description": "Configuration and engine implementation for MachineMetrics AdapterScripts and adapters",
+  "main": "index.js",
+  "license": "UNLICENSED",
+  "author": {
+    "name": "MachineMetrics",
+    "url": "http://machinemetrics.com"
+  },
+  "dependencies": {
+    "buffer": "^6.0.3",
+    "cronosjs": "^1.7.1",
+    "eventemitter3": "^5.0.1",
+    "lodash": "^4.17.21",
+    "mathjs": "^14.2.1",
+    "md5": "^2.3.0",
+    "sha1": "^1.1.1",
+    "yaml": "^1.10.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "chai": "^4.5.0",
+    "eslint": "^8.57.1",
+    "eslint-config-airbnb": "^19.0.2",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-jsx-a11y": "^6.5.1",
+    "eslint-plugin-react": "^7.27.1",
+    "mocha": "^11.1.0"
+  },
+  "scripts": {
+    "test": "npm run lint && npm run test-only",
+    "test-only": "mocha test/*",
+    "lint": "eslint ."
+  }
+}

package/test/.eslintrc.json

@@ -0,0 +1,15 @@
+{
+  "parserOptions": {
+    "ecmaVersion": 2022
+  },
+  "rules": {
+    "import/no-extraneous-dependencies": [ "off" ],
+    "prefer-arrow-callback": "off"
+  },
+  "env": {
+    "mocha": true
+  },
+  "globals": {
+    "BigInt": true
+  }
+}

package/test/chainedTransform.test.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const Transform = require('../lib/transform');
+const testUtils = require('./util/testUtils');
+
+describe('Chained transform tests', function () {
+  // NB: on/off delays are not commutative, though it can appear that they are in some tests.
+  it('on-delay + off-delay', function () {
+    const filter = new Transform.onDelay(2)
+      .chain(new Transform.offDelay(2));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    //                 '____|___^^________^^^_'
+    filter.valdDigital('____^^__^^^^______^^^^', 1);
+  });
+
+  it('off-delay + on-delay', function () {
+    const filter = new Transform.offDelay(2)
+      .chain(new Transform.onDelay(2));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    //                 '__^^^^|^^^^^__^^^^^^^^'
+    filter.valdDigital('____^^__^^^^____^^^^^^', 1);
+  });
+
+  it('rising-edge + off-delay (on-latch)', function () {
+    const filter = new Transform.risingEdge()
+      .chain(new Transform.offDelay(2));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    //                 '__|___|_______|_|_____'
+    filter.valdDigital('__^^__^^______^^|^____', 1);
+  });
+
+  it('falling-edge + off-delay + invert (off-latch)', function () {
+    const filter = new Transform.fallingEdge()
+      .chain(new Transform.offDelay(2))
+      .chain(new Transform.invert());
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    //                 '____|_____|____|_____|'
+    //                 '____^^____^^___^^____^'
+    filter.valdDigital('^^^^__^^^^__^^^__^^^^_', 1);
+  });
+
+  // NB: In theory the same as above, except start-of-stream conditions lead to difference at start
+  it('falling-edge + invert + on-delay (off-latch)', function () {
+    const filter = new Transform.fallingEdge()
+      .chain(new Transform.invert())
+      .chain(new Transform.onDelay(2));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_', 1);
+    //                 '____|_____|____|_____|'
+    //                 '^^^^|^^^^^|^^^^|^^^^^|'
+    filter.valdDigital('__^^__^^^^__^^^__^^^^_', 1);
+  });
+
+  it('rising-edge + off-delay + rising-edge-counter (counter cooldown)', function () {
+    const filter = new Transform.risingEdge()
+      .chain(new Transform.offDelay(3))
+      .chain(new Transform.risingEdgeCounter(testUtils.standardBuilderArgs(null, 'test1')));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^__^^^^____^_^^^^^_^_', 1);
+    //                 '__|___|_______|_|_____|_'
+    //                 '__^^^_^^^_____^^^^^___^^'
+    filter.valdCounter('  +   +       +       + ', 1);
+  });
+
+  it('rising-edge + off-delay + falling-edge + off-delay', function () {
+    const filter = new Transform.risingEdge()
+      .chain(new Transform.offDelay(1))
+      .chain(new Transform.fallingEdge())
+      .chain(new Transform.offDelay(1));
+    testUtils.attachTransformValidator(filter);
+
+    filter.testDigital('__^^^^______^____', 1);
+    //                 '__|_________|____'
+    //                 '__^_________^____'
+    //                 '___|_________|___'
+    filter.valdDigital('___^_________^___', 1);
+  });
+});

package/test/conditions.test.js

@@ -0,0 +1,118 @@
+'use strict';
+
+/* eslint-disable no-template-curly-in-string */
+/* eslint-disable no-useless-escape */
+
+const expect = require('chai').expect;
+const EngineV2 = require('../lib/engine/engineV2');
+const Builder = require('../lib/engine/transformBuilderV2');
+const DataOutput = require('../lib/engine/dataOutput');
+const testUtils = require('./util/testUtils');
+
+describe('data items', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('conditions.yml');
+  });
+
+  it('parses overrides', async function () {
+    expect(config.adapter.conditions.cond3.passthroughSource).to.eq('key4');
+    expect(config.adapter.conditions.cond3.overrides.length).to.eq(3);
+
+    expect(config.adapter.conditions.cond3.overrides[0].code).to.eq('E${this}');
+    expect(config.adapter.conditions.cond3.overrides[0].codeIsStatic).to.eq(false);
+    expect(config.adapter.conditions.cond3.overrides[0].codePath).to.eq('conditions.cond3.overrides.0.override-code');
+    expect(config.adapter.conditions.cond3.overrides[0].matchCode.toString()).to.eq(/^X\d+$/.toString());
+    expect(config.adapter.conditions.cond3.overrides[0].codeResolverTriggers).to.deep.eq([]);
+
+    expect(config.adapter.conditions.cond3.overrides[0].message).to.eq('Extra ${this}');
+    expect(config.adapter.conditions.cond3.overrides[0].messageIsStatic).to.eq(false);
+    expect(config.adapter.conditions.cond3.overrides[0].messagePath).to.eq('conditions.cond3.overrides.0.override-message');
+    expect(config.adapter.conditions.cond3.overrides[0].messageResolverTriggers).to.deep.eq([]);
+
+    expect(config.adapter.conditions.cond3.overrides[1].message).to.eq('${this} coolant=${key1}');
+    expect(config.adapter.conditions.cond3.overrides[1].messageIsStatic).to.eq(false);
+    expect(config.adapter.conditions.cond3.overrides[1].messagePath).to.eq('conditions.cond3.overrides.1.override-message');
+    expect(config.adapter.conditions.cond3.overrides[1].matchMessage.toString()).to.eq(/^.*coolant.*$/.toString());
+    expect(config.adapter.conditions.cond3.overrides[1].messageResolverTriggers).to.deep.eq(['key1']);
+
+    expect(config.adapter.conditions.cond3.overrides[2].code).to.eq('Y');
+    expect(config.adapter.conditions.cond3.overrides[2].codeIsStatic).to.eq(true);
+    expect(config.adapter.conditions.cond3.overrides[2].codePath).to.eq('conditions.cond3.overrides.2.override-code');
+    expect(config.adapter.conditions.cond3.overrides[2].codeResolverTriggers).to.deep.eq([]);
+    expect(config.adapter.conditions.cond3.overrides[2].message).to.eq('Z');
+    expect(config.adapter.conditions.cond3.overrides[2].messageIsStatic).to.eq(true);
+    expect(config.adapter.conditions.cond3.overrides[2].messagePath).to.eq('conditions.cond3.overrides.2.override-message');
+    expect(config.adapter.conditions.cond3.overrides[2].messageResolverTriggers).to.deep.eq([]);
+  });
+
+  it('captures simple data items', async function () {
+    const source = testUtils.valueSource();
+    const [dataOutput, captured] = makeDataOutput(config, source);
+
+    source.sendValue('key1', 7, 2);
+    dataOutput.handleScanSync();
+    source.sendValue('key1', 11, 3);
+    dataOutput.handleScanSync();
+    source.sendValue('key2', 2, 4);
+    dataOutput.handleScanSync();
+    source.sendValue('key2', 5, 5);
+    dataOutput.handleScanSync();
+    source.sendValue('key3', 33, 6);
+    dataOutput.handleScanSync();
+
+    expect(captured.length).to.eq(12);
+    validateCondition(captured[3], 'cond1', 'WARNING', 2000, 'A1', 'Code A1');
+    validateUnavail(captured[4], 'cond1', 2000, 'A2');
+    validateCondition(captured[5], 'cond1', 'FAULT', 3000, 'A1', 'Code A1');
+    validateUnavail(captured[6], 'cond1', 3000, 'A2');
+    validateCondition(captured[7], 'cond1', 'FAULT', 4000, 'A1', 'Code A1');
+    validateCondition(captured[8], 'cond1', 'NORMAL', 4000, 'A2', 'Code A2');
+    validateCondition(captured[9], 'cond1', 'FAULT', 5000, 'A1', 'Code A1');
+    validateCondition(captured[10], 'cond1', 'FAULT', 5000, 'A2', 'Code A2');
+    validateCondition(captured[11], 'cond2', 'FAULT', 6000, 'B33', 'Code B33');
+  });
+});
+
+function validateCondition(entry, key, value, time, code, message) {
+  expect(entry.event).to.eq('data');
+  expect(entry.key).to.eq(key);
+  expect(entry.value).to.eq(value);
+  expect(entry.time).to.eq(time);
+  expect(entry.meta.type).to.eq('condition');
+  expect(entry.meta.nativeCode).to.eq(code);
+  expect(entry.meta.message).to.eq(message);
+}
+
+function validateUnavail(entry, key, time, code) {
+  expect(entry.event).to.eq('unavailable');
+  expect(entry.key).to.eq(key);
+  expect(entry.time).to.eq(time);
+  if (code) {
+    expect(entry.meta.type).to.eq('condition');
+    expect(entry.meta.nativeCode).to.eq(code);
+  }
+}
+
+function makeDataOutput(config, source) {
+  const engine = new EngineV2(config);
+  const builder = new Builder(config);
+  builder.build(engine);
+
+  const buf = [];
+  const dataOutput = new DataOutput(engine, config);
+  dataOutput.on('data', (key, value, time, meta) => {
+    buf.push({ event: 'data', key, value, time, meta });
+  });
+  dataOutput.on('data_unavailable', (key, time, meta) => {
+    buf.push({ event: 'unavailable', key, time, meta });
+  });
+
+  engine.on('update', dataOutput.handleUpdate.bind(dataOutput));
+  engine.on('unavailable', dataOutput.handleItemUnavailable.bind(dataOutput));
+  engine.addValueSource(source);
+
+  dataOutput.initiailize();
+
+  return [dataOutput, buf];
+}

package/test/config/ab-pccc.test.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('Allen Bradley PCCC config tests', function () {
+  let config;
+  let config2;
+  before(async () => {
+    config = await testUtils.loadConfig('device/ab-pccc-default.yml');
+    config2 = await testUtils.loadConfig('device/ab-pccc-full.yml');
+  });
+
+  it('reads default config', async function () {
+    expect(config.device.host).to.eq('192.168.1.150');
+    expect(config.device.port).to.eq(undefined);
+    expect(config.device.scanRate).to.eq(1);
+    expect(config.device.routing).to.eq(false);
+    expect(config.device.verboseDevice).to.eq(false);
+    expect(config.device.extraVerboseDevice).to.eq(false);
+    expect(config.device.deviceTimeout).to.eq(4.5);
+    expect(config.device.slot).to.eq(0);
+    expect(config.device.tags).to.deep.eq({});
+  });
+
+  it('reads full config', async function () {
+    expect(config2.device.host).to.eq('192.168.1.150');
+    expect(config2.device.port).to.eq(1234);
+    expect(config2.device.scanRate).to.eq(0.1);
+    expect(config2.device.routing).to.eq(true);
+    expect(config2.device.verboseDevice).to.eq(true);
+    expect(config2.device.extraVerboseDevice).to.eq(true);
+    expect(config2.device.deviceTimeout).to.eq(10);
+    expect(config2.device.slot).to.eq(1);
+
+    expect(Object.keys(config2.device.tags).length).to.eq(3);
+    expect(config2.device.tags.tag1).to.deep.eq({ name: 'tag1', path: 'F7:5' });
+    expect(config2.device.tags.tag2).to.deep.eq({ name: 'tag2', path: 'B12:3/5' });
+    expect(config2.device.tags.tag3).to.deep.eq({ name: 'tag3', path: 'ST3:1,4' });
+  });
+});

package/test/config/adam-6052.test.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('ADAM-6052 config tests', function () {
+  let defaultConfig;
+  before(async () => {
+    defaultConfig = await testUtils.loadConfig('device/adam-6052-default.yml');
+  });
+
+  it('reads default config', async function () {
+    expect(defaultConfig.device.host).to.eq('192.168.1.100');
+    expect(defaultConfig.device.pins).to.deep.eq({});
+  });
+});