@machinemetrics/io-adapter-lib 2.32.0

package/lib/transform/risingEdgeCounter.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Increments a counter for every rising edge (F->T) in a digital stream.
+ *
+ * For every incoming sample, the internal counter value will be emitted.  When a rising edge is found,
+ * the counter will be incremented before the output value is emitted.
+ */
+class RisingEdgeCounterFilter extends TransformState {
+  constructor({ engine, path, args: { mergeWindow, accum = {}, reset = {} } }) {
+    super();
+
+    this.mergeWindow = mergeWindow || 0;
+    this.engine = engine;
+    this.accumExpression = accum.compiledExpression;
+    this.accumSources = engine.expressionService.expressionTriggers(`${path}.accum`);
+    this.resetExpression = reset.compiledExpression;
+    this.resetSources = engine.expressionService.expressionTriggers(`${path}.reset`);
+
+    this.defaultValue = false;
+    this.initReset();
+  }
+
+  static op = 'count';
+
+  static create(args) {
+    return new RisingEdgeCounterFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    configUtil.requireObjectParams(defn.args, 'count', {
+      optional: true,
+      availableAttributes: ['amount', 'reset', 'merge-window'],
+      defaultAttribute: 'amount',
+    });
+
+    let accum = _.get(defn.args, 'amount', defn.args.count);
+    if (!_.isUndefined(accum)) {
+      try {
+        const expression = accum.toString();
+        const compiledExpression = configUtil.compileExpression(expression, this.op);
+        accum = { expression, compiledExpression };
+      } catch (err) {
+        configUtil.throwConfigError(`Problem evaluating expression: ${err.message}`, this.op);
+      }
+    }
+
+    let reset = _.get(defn.args, 'reset');
+    if (!_.isUndefined(reset)) {
+      try {
+        const expression = reset.toString();
+        const compiledExpression = configUtil.compileExpression(expression, this.op);
+        reset = { expression, compiledExpression };
+      } catch (err) {
+        configUtil.throwConfigError(`Problem evaluating expression: ${err.message}`, this.op);
+      }
+    }
+
+    const mergeWindow = _.get(defn.args, 'merge-window');
+    if (!_.isUndefined(mergeWindow)) {
+      configUtil.requirePositive(mergeWindow, 'merge-window', this.op);
+    }
+
+    defn.args = { accum, reset, mergeWindow };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    return [
+      ...configUtil.getExpressions(body, { ...info, field: 'accum' }, true),
+      ...configUtil.getExpressions(body, { ...info, field: 'reset' }),
+    ];
+  }
+
+  initReset() {
+    this.value = false;
+    this.previousValue = false;
+    this.count = 0;
+    this.preCount = 0;
+    this.pendingChangeTime = null;
+  }
+
+  supportsPendingChanges() {
+    return !!this.mergeWindow;
+  }
+
+  update(context, value, time) {
+    this.lastSuppliedValue = value;
+    this.lastSampleTime = time;
+    if (!this.available) {
+      this.available = true;
+
+      // Don't count when becoming available already in a high state
+      this.emitUpdate(context);
+      this.filter(context, value, time);
+      return;
+    }
+
+    this.filter(context, value, time);
+    this.emitUpdate(context);
+  }
+
+  emitUpdate(context) {
+    if (this.mergeWindow && this.lastSampleTime >= this.pendingChangeTime) {
+      this.count += this.preCount;
+      this.preCount = 0;
+      this.pendingChangeTime = null;
+    }
+
+    if (this.value && this.valueTime === this.lastSampleTime) {
+      if (this.accumExpression) {
+        const localState = { this: this.count };
+        const unavailTerm = this.accumSources.reduce((res, name) => {
+          const state = this.engine.getState(name);
+          localState[name] = state?.value;
+          return res || !state || !state.available;
+        }, false);
+
+        if (!unavailTerm) {
+          try {
+            this.preCount += this.accumExpression.evaluate(localState);
+          } catch (err) {
+            // Probably a type error in one of the arguments.
+            this.recordError(context, err, this.valueTime);
+            this.setUnavailable(context, this.valueTime);
+            return;
+          }
+        }
+      } else {
+        this.preCount += 1;
+      }
+
+      if (this.mergeWindow) {
+        this.pendingChangeTime = this.lastSampleTime + this.mergeWindow;
+      }
+    }
+
+    if (!this.mergeWindow) {
+      this.count += this.preCount;
+      this.preCount = 0;
+    }
+
+    // While resetExpression evals true, force count to 0
+    if (this.resetExpression) {
+      const localState = { this: this.count };
+      const unavailTerm = this.resetSources.reduce((res, name) => {
+        const state = this.engine.getState(name);
+        localState[name] = state?.value;
+        return res || !state || !state.available;
+      }, false);
+
+      try {
+        if (!unavailTerm && this.resetExpression.evaluate(localState)) {
+          this.count = 0;
+          this.preCount = 0;
+          this.pendingChangeTime = null;
+          this.emit('update', this.count, this.lastSampleTime, context);
+          return;
+        }
+      } catch (err) {
+        // Probably a type error in one of the arguments.
+        this.recordError(context, err, this.lastSampleTime);
+        this.setUnavailable(context, this.lastSampleTime);
+        return;
+      }
+    }
+
+    this.emit('update', this.count, this.lastSampleTime, context);
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+    this.initReset();
+  }
+}
+
+module.exports = RisingEdgeCounterFilter;

package/lib/transform/sampleInterval.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const DownsampleFilter = require('./downsample');
+
+// TODO: Might go away with better general handling of downsample/resample.
+class SampleIntervalFilter extends DownsampleFilter {
+  constructor(interval) {
+    super(interval * 500);
+  }
+}
+
+module.exports = SampleIntervalFilter;

package/lib/transform/source.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+const ChainSource = require('./util/chainSource');
+
+/**
+ * Transforms each value by a pre-parsed mathjs expression or re-emits a specified source.
+ *
+ * Filter must be provided with the backing engine to have access to current variable states, which can
+ * be referenced in expressions by name.  Unlike the expression transform, 'this' is not a valid
+ * identifier when an expression is supplied.
+ *
+ * Source discards the incoming value, so should only be used at the start of a transform chain.
+ *
+ * MathJS expressions are capable of dealing with any input types, and may produce output of differing type.
+ */
+
+class SourceFilter extends TransformState {
+  constructor({ engine, path, rootPath, baseTransform, args: { expression, compiledExpression } }) {
+    super();
+
+    if (baseTransform) {
+      this.origin = new ChainSource(this, { engine, path, rootPath }, {
+        onWatchSource: (name) => {
+          this.constantSource = false;
+          if (expression === name) {
+            this.simpleSource = true;
+          }
+        },
+      });
+    }
+
+    this.engine = engine;
+    this.expression = expression;
+    this.compiledExpression = compiledExpression;
+    this.simpleSource = !compiledExpression;
+    this.selfSources = engine.expressionService.expressionTriggers(path);
+
+    // If there's no variables in the expression, it's a constant that can be evaluated once
+    if (_.isEmpty(this.selfSources)) {
+      try {
+        this.lastSuppliedValue = this.compiledExpression.evaluate();
+        this.constantSource = true;
+      } catch (err) {
+        // Oh well
+      }
+    }
+  }
+
+  static op = 'source';
+
+  static create(args) {
+    return new SourceFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    let expression = defn.args[defn.func];
+    if (_.isUndefined(expression)) {
+      expression = '';
+    }
+    expression = expression.toString();
+
+    if (_.isEmpty(expression)) {
+      configUtil.throwConfigError('source must be an identifier or expression', this.op);
+    }
+
+    try {
+      const compiledExpression = configUtil.compileExpression(expression, this.op, {});
+      defn.args = { expression, compiledExpression };
+    } catch (err) {
+      configUtil.throwConfigError(`Problem evaluating source expression: ${err.message}`, this.op);
+    }
+  }
+
+  static getExpressions(configUtil, body, info) {
+    return configUtil.getExpressions(body, info);
+  }
+
+  update(context, value, time) {
+    if (value === 'UNAVAILABLE') {
+      this.setUnavailable(context, time);
+    } else {
+      super.update(context, value, time);
+    }
+  }
+
+  filter(context, value, time) {
+    if (this.constantSource || this.simpleSource) {
+      this.commitValue(context, value, time);
+    } else {
+      const localState = {};
+      const unavailTerm = _.reduce(this.selfSources, (res, name) => {
+        const state = this.engine.getState(name);
+        localState[name] = state?.value;
+        return res || !state || !state.available;
+      }, false);
+
+      if (unavailTerm) {
+        this.setUnavailable(context, time);
+        return;
+      }
+
+      try {
+        this.commitValue(context, this.compiledExpression.evaluate(localState), time);
+      } catch (err) {
+        // Huh the engine doesn't recognize some value probably
+        // This is not entirely unexpected early as the transform may be populated with names later
+        this.recordError(context, err, time);
+        this.setUnavailable(context, time);
+      }
+    }
+  }
+}
+
+module.exports = SourceFilter;

package/lib/transform/state.js

@@ -0,0 +1,201 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+const ChainSource = require('./util/chainSource');
+
+/**
+ * A reverse-switch style if/else chain
+ *
+ * For every incoming sample, each conditional assignment rule (a 'case') will be evaluated in order until
+ * one of them returns true.  The value associated with the expression will be emitted.  If no cases match,
+ * the incoming sample will be emitted instead.
+ *
+ * If any conditional assignment expressions include a variable that updates, the entire set of rules will be
+ * re-evaluated at that timestamp.
+ *
+ * Config Example 1:
+ *   - source: exec-in
+ *   - state:
+ *     - ACTIVE: this and not in-fault
+ *     - STOPPED: this and in-fault
+ *     - READY: true
+ *
+ * Config Example 2:
+ *   - source: in-fault
+ *   - state:
+ *     - select: Normal
+ *       when: this
+ *     - select: Machine is currently in fault
+ *       when: not this
+ */
+class StateFilter extends TransformState {
+  constructor({ engine, path, rootPath, baseTransform, args: { rules = {} } }) {
+    super();
+
+    if (baseTransform) {
+      const pathSet = _.map(rules, (rule, index) => `${path}.${index}.when`);
+      this.origin = new ChainSource(this, {
+        engine,
+        path: pathSet,
+        rootPath,
+      });
+    }
+
+    this.engine = engine;
+    this.rules = _.map(rules, (rule, index) => {
+      return {
+        value: rule.value,
+        expression: rule.expression,
+        compiledExpression: rule.compiledExpression,
+        expressionSources: engine.expressionService.expressionTriggers(`${path}.${index}.when`),
+        hasThis: engine.expressionService.findName(rule.expression, 'this'),
+        sourceCache: {},
+        resultCache: undefined,
+      };
+    });
+  }
+
+  static op = 'state';
+
+  static create(args) {
+    return new StateFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const items = defn.args;
+    if (!_.isArray(items)) {
+      configUtil.throwConfigError('Expected list of conditional assignments', this.op);
+    }
+
+    const rules = _.map(items, (item) => {
+      if (!_.isObject(item)) {
+        configUtil.throwConfigError('Invalid conditional assignment', this.op);
+      }
+
+      // convert shorthand to longhand
+      if (_.size(item) === 1) {
+        const assignValue = _.first(_.keys(item));
+        const assignExpr = item[assignValue];
+        item = {
+          select: assignValue,
+          when: assignExpr,
+        };
+      } else {
+        if (!_.has(item, 'select')) {
+          configUtil.throwConfigError('Expected "select" argument in non-shorthand conditional assignment', this.op);
+        }
+        if (!_.has(item, 'when')) {
+          configUtil.throwConfigError('Expected "when" argument in non-shorthand conditional assignment', this.op);
+        }
+      }
+
+      try {
+        const expression = item.when.toString();
+        const compiledExpression = configUtil.compileExpression(expression, this.op);
+
+        return {
+          value: item.select,
+          expression,
+          compiledExpression,
+        };
+      } catch (err) {
+        configUtil.throwConfigError(`Problem evaluating expression for case "${item.select}": ${err.message}`, this.op);
+        throw err;
+      }
+    });
+
+    defn.args = { rules };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    const { varName, index, attribute } = info;
+
+    if (!_.isArray(body)) {
+      return [];
+    }
+
+    return _.map(body, (rule, ruleIndex) => {
+      if (_.isObject(rule)) {
+        let expr;
+        if (_.size(rule) === 1) {
+          expr = _.first(_.values(rule));
+        } else if (!_.isUndefined(rule.when)) {
+          expr = rule.when;
+        }
+
+        if (expr) {
+          expr = expr.toString();
+          return [{
+            path: `variables.${varName}.${index}.${attribute}.${ruleIndex}.when`,
+            expression: expr,
+          }, {
+            path: `variables.${varName}`,
+            expression: expr,
+          }];
+        }
+      }
+      return [];
+    });
+  }
+
+  filter(context, value, time) {
+    if (!_.reduce(this.rules, (pass, rule) => {
+      if (pass) {
+        return pass;
+      }
+
+      let cacheInvalid = false;
+      if (rule.hasThis) {
+        if (this.origin) {
+          // Any 'this' term is automatically unavailable if we're first in transform chain
+          return false;
+        }
+
+        cacheInvalid = rule.sourceCache.this !== value;
+        rule.sourceCache.this = value;
+      }
+
+      const unavailTerm = _.reduce(rule.expressionSources, (res, name) => {
+        const state = this.engine.getState(name);
+        if (state) {
+          cacheInvalid = cacheInvalid || (rule.sourceCache[name] !== state.value);
+          rule.sourceCache[name] = state.value;
+        }
+        return res || !state || !state.available;
+      }, false);
+
+      if (cacheInvalid) {
+        rule.resultCache = undefined;
+      }
+      if (unavailTerm) {
+        return false;
+      }
+
+      try {
+        if (rule.resultCache === undefined) {
+          rule.resultCache = rule.compiledExpression.evaluate(rule.sourceCache);
+        }
+
+        if (rule.resultCache) {
+          this.commitValue(context, rule.value, time);
+          return true;
+        }
+      } catch (err) {
+        // Probably a type error in one of the arguments.
+        this.recordError(context, err, time);
+      }
+      return false;
+    }, false)) {
+      // If we get here, none of the rules matched, so pass-through the input
+      if (this.origin) {
+        // ... unless we're first in the chain
+        this.setUnavailable(context, time);
+      } else {
+        this.commitValue(context, value, time);
+      }
+    }
+  }
+}
+
+module.exports = StateFilter;

package/lib/transform/threshold.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+/**
+ * Converts an analog stream to a digital stream by applying a threshold to each incoming value.
+ *
+ * For each sample equal or above the threshold, true will be emitted, and for each sample below
+ * the threshold, false will be emitted.
+ */
+class ThresholdFilter extends TransformState {
+  constructor({ args: { threshold, direction } }) {
+    super();
+
+    this.threshold = threshold;
+    this.direction = direction ?? 'above';
+  }
+
+  static op = 'threshold';
+
+  static create(args) {
+    return new ThresholdFilter(args);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const { value: threshold, usingShorthand } = configUtil.getArgOrShorthand(defn, 'value');
+    configUtil.requireNumeric(threshold, usingShorthand ? this.op : 'value', this.op);
+
+    const direction = defn.args.direction ?? 'above';
+    configUtil.requireValueIn(direction, ['above', 'below'], 'direction', this.op);
+    defn.args = { threshold, direction };
+  }
+
+  filter(context, value, time) {
+    if (value === true || value === 'true') {
+      this.commitValue(context, true, time);
+    } else if (value === false || value === 'false') {
+      this.commitValue(context, false, time);
+    } else {
+      value = _.toNumber(value);
+      if (!_.isNaN(value)) {
+        const cmp = this.direction === 'above' ? value >= this.threshold : value <= this.threshold;
+        this.commitValue(context, cmp, time);
+      } else {
+        this.commitValue(context, false, time);
+      }
+    }
+  }
+}
+
+module.exports = ThresholdFilter;