@machinemetrics/io-adapter-lib 2.32.0

package/test/dataItems.test.js

@@ -0,0 +1,140 @@
+'use strict';
+
+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('data-items.yml');
+  });
+
+  it('captures simple data items', async function () {
+    const source = testUtils.valueSource();
+    const captured = makeDataOutput(config, source);
+
+    source.sendValue('key1', 'test', 2);
+    source.sendValue('key2', 2, 3);
+    source.sendValue('key2', 4, 4);
+
+    expect(captured.length).to.eq(5);
+    validateData(captured[2], 'key1', 'test', 2000);
+    validateData(captured[3], 'keymod', false, 3000);
+    validateData(captured[4], 'keymod', true, 4000);
+  });
+
+  it('captures unavail data items', async function () {
+    const source = testUtils.valueSource();
+    const captured = makeDataOutput(config, source);
+
+    source.sendValue('key1', 'test', 2);
+    source.sendValue('key2', 2, 3);
+    source.unavailable(6);
+
+    expect(captured.length).to.eq(6);
+    validateData(captured[2], 'key1', 'test', 2000);
+    validateData(captured[3], 'keymod', false, 3000);
+    validateUnavail(captured[4], 'keymod', 6000);
+    validateUnavail(captured[5], 'key1', 6000);
+  });
+});
+
+describe('data items shorthand', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('data-items-shorthand.yml');
+  });
+
+  it('captures simple data items', async function () {
+    const source = testUtils.valueSource();
+    const captured = makeDataOutput(config, source);
+
+    source.sendValue('key1', 'test', 2);
+    source.sendValue('key2', 2, 3);
+    source.sendValue('key3', { position: 5, speed: 10 }, 5);
+
+    expect(captured.length).to.eq(11);
+    validateData(captured[5], 'key1', 'test', 2000);
+    validateData(captured[6], 'key2', 2, 3000);
+    validateUnavail(captured[7], 'key2b', 3000);
+    validateData(captured[8], 'key2a', false, 3000);
+    validateData(captured[9], 'key2b', 12, 5000);
+    validateData(captured[10], 'key3', 5, 5000);
+  });
+});
+
+describe('data items legacy', async function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('data-items-legacy.yml');
+  });
+
+  it('captures data items', async function () {
+    const source = testUtils.valueSource();
+    const captured = makeDataOutput(config, source);
+
+    source.sendValue('key1', 10, 2);
+    source.sendValue('key2', 2, 3);
+    source.sendValue('key2', 4, 4);
+    source.unavailable(5);
+
+    expect(captured.length).to.eq(20);
+    validateData(captured[5], 'key1', 10, 2000);
+    validateData(captured[6], 'key1a', 15, 2000);
+    validateUnavail(captured[7], 'key1b', 2000);
+
+    validateData(captured[8], 'key1b', 12, 3000);
+    validateData(captured[9], 'key2b', 'READY', 3000);
+    validateData(captured[10], 'key2a', 'READY', 3000);
+
+    validateData(captured[11], 'key1b', 14, 4000);
+    validateData(captured[12], 'key2b', 'ACTIVE', 4000);
+    validateData(captured[13], 'key2a', 'ACTIVE', 4000);
+
+    validateUnavail(captured[14], 'key1b', 5000);
+    validateUnavail(captured[15], 'key2b', 5000);
+    validateUnavail(captured[16], 'key2a', 5000);
+    validateUnavail(captured[17], 'key1', 5000);
+    validateUnavail(captured[18], 'key1a', 5000);
+    validateUnavail(captured[19], 'key1b', 5000);
+  });
+});
+
+function validateData(entry, key, value, time) {
+  expect(entry.event).to.eq('data');
+  expect(entry.key).to.eq(key);
+  expect(entry.value).to.eq(value);
+  expect(entry.time).to.eq(time);
+}
+
+function validateUnavail(entry, key, time) {
+  expect(entry.event).to.eq('unavailable');
+  expect(entry.key).to.eq(key);
+  expect(entry.time).to.eq(time);
+}
+
+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) => {
+    buf.push({ event: 'unavailable', key, time, });
+  });
+
+  engine.on('update', dataOutput.handleUpdate.bind(dataOutput));
+  engine.on('unavailable', dataOutput.handleItemUnavailable.bind(dataOutput));
+  engine.addValueSource(source);
+
+  dataOutput.initiailize();
+
+  return buf;
+}

package/test/engine-v1-tests.js

@@ -0,0 +1,418 @@
+'use strict';
+
+const _ = require('lodash');
+const EventEmitter = require('eventemitter3');
+const expect = require('chai').expect;
+const Config = require('../lib/config');
+const EngineV1 = require('../lib/engine/engineV1');
+
+describe('Analog sample process', function () {
+  it('passes through all samples', function () {
+    const labjack = newAnalogLabjack({
+      'sample-interval': 0.002,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generateAnalog([1, 1, 2, 4, 3, 3, 5, 1, 2, 1], 0.002));
+    labjack.validate([1, 0.002, 2, 0.004, 4, 0.006, 3, 0.008, 3, 0.010, 5, 0.012, 1, 0.014, 2, 0.016, 1, 0.018]);
+  });
+
+  it('passes through every 3rd sample', function () {
+    const labjack = newAnalogLabjack({
+      'sample-interval': 0.006,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generateAnalog([1, 1, 2, 4, 3, 3, 5, 1, 2, 1], 0.002));
+    labjack.validate([4, 0.006, 5, 0.012, 1, 0.018]);
+  });
+
+  it('passes through sliding min', function () {
+    const labjack = newAnalogLabjack({
+      'sample-interval': 0.002,
+      'sample-function': 'min',
+      'sample-window': 0.008,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generateAnalog([1, 1, 2, 4, 3, 3, 5, 1, 2, 1], 0.002));
+    labjack.validate([0, 0.002, 0, 0.004, 1, 0.006, 1, 0.008, 2, 0.010, 3, 0.012, 1, 0.014, 1, 0.016, 1, 0.018]);
+  });
+
+  it('passes through sliding max', function () {
+    const labjack = newAnalogLabjack({
+      'sample-interval': 0.002,
+      'sample-function': 'max',
+      'sample-window': 0.008,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generateAnalog([1, 1, 2, 4, 3, 3, 5, 1, 2, 1], 0.002));
+    labjack.validate([1, 0.002, 2, 0.004, 4, 0.006, 4, 0.008, 4, 0.010, 5, 0.012, 5, 0.014, 5, 0.016, 5, 0.018]);
+  });
+
+  it('passes through sliding avg', function () {
+    const labjack = newAnalogLabjack({
+      'sample-interval': 0.002,
+      'sample-function': 'avg',
+      'sample-window': 0.008,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generateAnalog([1, 1, 2, 4, 3, 3, 5, 1, 2, 1], 0.002));
+    labjack.validate([
+      0.5, 0.002, 1, 0.004, 2, 0.006, 2.5, 0.008, 3, 0.010, 3.75, 0.012, 3, 0.014, 2.75, 0.016, 2.25, 0.018
+    ]);
+  });
+
+  it('passes through changes greater than min-delta', function () {
+    // Will also pass through immediately preceding sample to "step" the signal, if preceding sample was not passed
+    const labjack = newAnalogLabjack({
+      'sample-interval': 0.002,
+      'min-delta': 1.5,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generateAnalog([1, 1, 2, 4, 3, 3, 5, 1, 2, 1], 0.002));
+    labjack.validate([2, 0.004, 4, 0.006, 4, 0.012, 1, 0.014]);
+  });
+
+  it('passes through changes greater than min-delta with skipping interval', function () {
+    // Will also pass through immediately preceding sample to "step" the signal, if preceding sample was not passed
+    const labjack = newAnalogLabjack({
+      'sample-interval': 0.004,
+      'min-delta': 1.5,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generateAnalog([1.04, 1.11, 1.08, 4.01, 3.99, 4.04, 4.15, 1.15, 1.05, 1.1, 4.08, 4.12, 4.09], 0.002));
+    labjack.validate([3.99, 0.008, 3.99, 0.014, 1.05, 0.016, 1.05, 0.018, 4.08, 0.020]);
+  });
+});
+
+describe('Digital sample processing', function () {
+  it('raises events on transitions', function () {
+    const labjack = newDigitalLabjack();
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^^^^__^^^^_____^___', 0.25));
+    labjack.validate([true, 0.5, false, 1.5, true, 2, false, 3, true, 4.25, false, 4.5]);
+  });
+
+  it('raises events for inverted', function () {
+    const labjack = newDigitalLabjack({
+      invert: true,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^^^^__^^^^_____^___', 0.25)); // implicit true @ 0 event
+    labjack.validate([true, 0, false, 0.5, true, 1.5, false, 2, true, 3, false, 4.25, true, 4.5]);
+  });
+
+  it('filters out <= 0.25s blips', function () {
+    const labjack = newDigitalLabjack({
+      filter: 0.25, // also delays output by 0.25
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('____^_^^____^^^_^^__^___^^^', 0.25));
+    labjack.validate([true, 1.75, false, 2.25, true, 3.25, false, 4.75, true, 6.25]);
+  });
+
+  it('filters out <= 0.5s blips', function () {
+    const labjack = newDigitalLabjack({
+      filter: 0.5, // also delays output by 0.5
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('____^_^^____^^^_^^__^___^^^', 0.25));
+    labjack.validate([true, 3.5, false, 5.75, true, 6.5]);
+  });
+
+  it('delays on-state by 1s', function () {
+    const labjack = newDigitalLabjack({
+      'on-delay': 1,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^^_^^_^^^^^__^^__^^^^^^^', 0.25));
+    labjack.validate([true, 3, false, 3.25, true, 5.75]);
+  });
+
+  it('delays off-state by 1s', function () {
+    const labjack = newDigitalLabjack({
+      'off-delay': 1,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^__^_^^^______^^__^^______', 0.25));
+    labjack.validate([true, 0.5, false, 3.5, true, 4, false, 6.5]);
+  });
+
+  it('delays on-state by 1s with 0.25s filter', function () {
+    const labjack = newDigitalLabjack({
+      'on-delay': 1,
+      filter: 0.25,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^^_^^_^^^^^__^^__^^^^^^^', 0.25));
+    labjack.validate([true, 1.5, false, 3.5, true, 5.75]);
+  });
+
+  it('delays off-state by 1s with 0.25s filter', function () {
+    const labjack = newDigitalLabjack({
+      'off-delay': 1,
+      filter: 0.25,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^^__^__^______^^__^^________', 0.25));
+    labjack.validate([true, 0.75, false, 2, true, 4.25, false, 6.5]);
+  });
+
+  it('holds on-state for 1s since last on-transition', function () {
+    const labjack = newDigitalLabjack({
+      'on-latch': 1,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^^__^__^______^^^^^^^__^^________', 0.25));
+    labjack.validate([true, 0.5, false, 3.25, true, 4, false, 5, true, 6.25, false, 7.25]);
+  });
+
+  it('holds off-state for 1s since last off-transition', function () {
+    const labjack = newDigitalLabjack({
+      'off-latch': 1,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^^__^__^______^^^^^^^__^^________', 0.25));
+    labjack.validate([true, 0.5, false, 1, true, 3.5, false, 5.75, true, 7.75]);
+  });
+});
+
+describe('Counter sample processing', function () {
+  it('counts rising edges', function () {
+    const labjack = newCounterLabjack('rising');
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^_^^___^_^_', 0.25));
+    labjack.validate([1, 0.5, 2, 1, 3, 2.25, 4, 2.75]);
+  });
+
+  it('counts falling edges', function () {
+    const labjack = newCounterLabjack('falling');
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^_^^___^_^_', 0.25));
+    labjack.validate([1, 0.75, 2, 1.5, 3, 2.5, 4, 3]);
+  });
+
+  it('counts both edges', function () {
+    const labjack = newCounterLabjack('both');
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^_^^___^_^_', 0.25));
+    labjack.validate([1, 0.5, 2, 0.75, 3, 1, 4, 1.5, 5, 2.25, 6, 2.5, 7, 2.75, 8, 3]);
+  });
+
+  it('counts rising edge pulses >= 0.5', function () {
+    const labjack = newCounterLabjack('rising', {
+      'min-pulse-width': 0.5,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^_^^___^_^_', 0.25));
+    labjack.validate([1, 0.5, 2, 2.25]);
+  });
+
+  it('counts falling edge pulses >= 0.5', function () {
+    const labjack = newCounterLabjack('falling', {
+      'min-pulse-width': 0.5,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^_^^___^^^_^_', 0.25));
+    labjack.validate([1, 1.5, 2, 3]);
+  });
+
+  it('counts rising edge pulses <= 0.5', function () {
+    const labjack = newCounterLabjack('rising', {
+      'max-pulse-width': 0.5,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^_^^___^_^_', 0.25));
+    labjack.validate([1, 0.5, 2, 1, 3, 2.75]);
+  });
+
+  it('counts falling edge pulses <= 0.5', function () {
+    const labjack = newCounterLabjack('falling', {
+      'max-pulse-width': 0.5,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^_^^___^^^_^_', 0.25));
+    labjack.validate([1, 0.75, 2, 1.5, 3, 3.5]);
+  });
+
+  it('counts falling edges with on-delay', function () {
+    const labjack = newCounterLabjack('falling', {
+      'on-delay': 1,
+    });
+    const source = new ValueSource();
+    labjack.addValueSource(source);
+
+    source.sendValues('pin-0', generate('__^^^^^__^^__', 0.25));
+    labjack.validate([1, 1.75]);
+  });
+});
+
+function newAnalogLabjack(options) {
+  options = {
+    pin: 0,
+    ...options,
+  };
+
+  const config = new Config({
+    device: 'labjack-u3',
+    input: {
+      analog: {
+        test: options,
+      },
+    },
+  });
+  const processor = new EngineV1(config);
+
+  processor.events = [];
+  processor.on('update', (pin, value, time) => {
+    processor.events.push(value, time);
+  });
+
+  processor.validate = (cmp) => {
+    expect(cmp.length).to.equal(processor.events.length);
+    for (let i = 0; i < cmp.length; i += 1) {
+      expect(Math.abs(cmp[i] - processor.events[i])).to.be.lt(0.00001);
+    }
+  };
+
+  return processor;
+}
+
+function newDigitalLabjack(options) {
+  options = {
+    pin: 0,
+    'source-type': 'analog',
+    'v-threshold': 1.5,
+    ...options,
+  };
+
+  const config = new Config({
+    device: 'labjack-u3',
+    input: {
+      digital: {
+        test: options,
+      },
+    },
+  });
+  const processor = new EngineV1(config);
+
+  processor.events = [];
+  processor.on('update', (pin, value, time) => {
+    processor.events.push(value, time);
+  });
+
+  processor.validate = (cmp) => {
+    expect(cmp).to.deep.equal(processor.events);
+  };
+
+  return processor;
+}
+
+function newCounterLabjack(edge, options) {
+  options = {
+    pin: 0,
+    'source-type': 'analog',
+    'v-threshold': 1.5,
+    'trigger-edge': edge,
+    ...options,
+  };
+
+  const config = new Config({
+    device: 'labjack-u3',
+    input: {
+      counter: {
+        test: options,
+      },
+    },
+  });
+  const processor = new EngineV1(config);
+
+  processor.events = [];
+  processor.on('update', (pin, value, time) => {
+    processor.events.push(value, time);
+  });
+
+  processor.validate = (cmp) => {
+    expect(cmp).to.deep.equal(processor.events);
+  };
+
+  return processor;
+}
+
+function generateAnalog(values, timeStep) {
+  return _.map(values, (value, time) => [value, time * timeStep]);
+}
+
+function generate(str, timeStep) {
+  let isHigh = false;
+  const signal = [];
+
+  for (const c of str) {
+    if (c === '^') {
+      isHigh = true;
+      signal.push(2);
+    } else if (c === '_') {
+      isHigh = false;
+      signal.push(0);
+    } else if (c === '|') {
+      isHigh = !isHigh;
+      signal.push(isHigh ? 2 : 0);
+    }
+  }
+
+  return _.map(signal, (value, time) => [value, time * timeStep]);
+}
+
+class ValueSource extends EventEmitter {
+  sendValues(pin, arr) {
+    _.each(arr, ([value, time]) => {
+      this.emit('update', pin, value, time);
+    });
+  }
+}