@machinemetrics/io-adapter-lib 2.32.0

package/lib/engine/deviceOutput.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const _ = require('lodash');
+const fs = require('fs/promises');
+const path = require('path');
+const EventEmitter = require('eventemitter3');
+const fileUtil = require('../util/fileUtil');
+
+class DeviceOutputOptions {
+  constructor({ endTime }) {
+    this.endTime = endTime;
+  }
+
+  makePath(file) {
+    return `${new Date(file.start).toISOString().json}`;
+  }
+
+  async writeFile(filePath, data) {
+    await fs.writeFile(filePath, data, { flush: true });
+  }
+}
+
+class DeviceOutput extends EventEmitter {
+  constructor(outputOptions) {
+    super();
+
+    this.outputOptions = outputOptions;
+    this.chunkFormat = 'YYYY-MM-DDTHH:mm:ss.SSS[Z]';
+    this.chunkInterval = 1000 * 60;
+    this.fileInterval = 10;
+    this.endTime = outputOptions?.endTime;
+
+    this.currentChunk = this.startChunk();
+    this.chunks = [this.currentChunk];
+  }
+
+  startFile(time) {
+    if (this.currentFile) {
+      this.endCurrentFile();
+    }
+
+    if (this.endTime && time > this.endTime) {
+      return;
+    }
+
+    const datetime = new Date(time);
+    const minuteOffset = datetime.getUTCMinutes() % this.fileInterval;
+    const start = time - minuteOffset * 60000 - datetime.getUTCSeconds() * 1000 - datetime.getUTCMilliseconds();
+    const end = start + this.chunkInterval * this.fileInterval;
+
+    this.currentFile = {
+      start,
+      end,
+      chunks: [],
+    };
+
+    this.startChunk(time);
+  }
+
+  endCurrentFile() {
+    if (!this.currentFile) {
+      return;
+    }
+
+    this.endCurrentChunk();
+
+    const filePath = this.outputOptions.makePath(this.currentFile);
+    const dirPath = path.dirname(filePath);
+    fileUtil.ensureDirectoryExistence(dirPath);
+
+    const data = JSON.stringify(this.currentFile.chunks);
+
+    // Async but we don't need to wait on it
+    this.outputOptions.writeFile(filePath, data);
+
+    this.currentFile = null;
+  }
+
+  startChunk(time) {
+    if (this.currentChunk) {
+      this.endCurrentChunk();
+    }
+
+    if (this.endTime && time > this.endTime) {
+      return;
+    }
+
+    const datetime = new Date(time);
+    const start = time - datetime.getUTCSeconds() * 1000 - datetime.getUTCMilliseconds();
+    const end = start + this.chunkInterval;
+
+    this.currentChunk = {
+      start,
+      end,
+      keys: {},
+    };
+
+    if (this.currentFile) {
+      this.currentFile.chunks.push(this.currentChunk);
+    }
+  }
+
+  endCurrentChunk() {
+    if (!this.currentChunk) {
+      return;
+    }
+
+    // envelope: [offset (ms), min, max, median, mean]
+    // NB: Currently taking a dumb mean, but would be more valuable as integral divided by time segment
+
+    _.each(this.currentChunk.keys, (key) => {
+      key.envelope = _.map(key.envelope, (envelope, offset) => {
+        return this.summarizeEnvelope(envelope, offset);
+      });
+      key.envelope = _.compact(key.envelope);
+    });
+
+    // NB: This would be a good spot to export the chunk data to a NATS bus
+
+    this.currentChunk = null;
+  }
+
+  summarizeEnvelope(values, offset) {
+    values = _.filter(values, _.isFinite);
+    values = _.sortBy(values);
+
+    if (_.isEmpty(values)) {
+      return null;
+    }
+
+    const min = _.first(values);
+    const max = _.last(values);
+    const median = values[Math.floor(values.length / 2)];
+    const mean = parseFloat(_.mean(values).toFixed(3));
+
+    return [+offset, min, max, median, mean];
+  }
+
+  add(key, value, time) {
+    try {
+      time = Math.floor(time * 1000);
+      if (!this.currentFile || time >= this.currentFile.end.valueOf()) {
+        this.startFile(time);
+      }
+
+      if (!this.currentChunk || time >= this.currentChunk.end.valueOf()) {
+        this.startChunk(time);
+      }
+
+      // If no current chunk, then we've exceeded the end time for collection
+      if (!this.currentChunk) {
+        return;
+      }
+
+      if (!this.currentChunk.keys[key]) {
+        this.currentChunk.keys[key] = {
+          envelope: {},
+          raw: [],
+        };
+      }
+
+      const chunkKey = this.currentChunk.keys[key];
+      const offset = time - this.currentChunk.start;
+
+      if (typeof value === 'number') {
+        value = parseFloat(value.toFixed(3));
+      }
+
+      chunkKey.raw.push([offset, value]);
+
+      const envelopeOffset = offset - (offset % 1000);
+      if (!chunkKey.envelope[envelopeOffset]) {
+        chunkKey.envelope[envelopeOffset] = [];
+      }
+
+      chunkKey.envelope[envelopeOffset].push(value);
+    } catch (err) {
+      this.emit('error', err);
+    }
+  }
+}
+
+module.exports = {
+  DeviceOutputOptions,
+  DeviceOutput,
+};

package/lib/engine/engineV1.js

@@ -0,0 +1,480 @@
+const _ = require('lodash');
+const EventEmitter = require('eventemitter3');
+
+class EngineV1 extends EventEmitter {
+  constructor(config = {}, options = {}) {
+    super();
+
+    this.logDir = options.logDir || '.';
+    this.logger = options.logger || {
+      error: () => {},
+      warn: () => {},
+      info: () => {},
+    };
+
+    this.diagnostic = options.diagnostic || {
+      writePin: () => {},
+      writeInput: () => {},
+    };
+
+    this.config = config;
+    this.port = config.port;
+    this.scanInterval = config.device.scanInterval;
+    this.pins = config.device.pins;
+    this.analogPins = config.device.analogPins;
+    this.digitalPins = config.device.digitalPins;
+    this.vpins = config.engine.vpins;
+    this.vpinsMap = _.groupBy(this.vpins, 'pin');
+
+    _(this.vpins).filter({ type: 'analog' }).map((vpin) => {
+      vpin.handle = this.handleAnalogSample.bind(this);
+      vpin.state = this.defaultAnalogState(vpin);
+
+      return null;
+    }).value();
+
+    _(this.vpins).filter({ type: 'digital' }).map((vpin) => {
+      vpin.handle = this.handleDigitalSample.bind(this);
+      vpin.state = this.defaultDigitalState();
+
+      return null;
+    }).value();
+
+    _(this.vpins).filter({ type: 'counter' }).map((vpin) => {
+      vpin.handle = this.handleCounterSample.bind(this);
+      vpin.state = this.defaultCounterState();
+
+      return null;
+    }).value();
+
+    // Current state of all vpins as expression scope
+    this.expressionInputState = this.defaultInputState();
+  }
+
+  defaultAnalogState(vpin) {
+    const filter = ((f) => {
+      switch (f) {
+        case 'avg': return newSMAFilter(vpin.sampleWindow);
+        case 'min': return newMinFilter(vpin.sampleWindow);
+        case 'max': return newMaxFilter(vpin.sampleWindow);
+        default: return newIdentityFilter();
+      }
+    })(vpin.sampleFunc);
+
+    return {
+      defaultValue: 0,
+      value: 0,
+      lastSampledValue: 0,
+      lastReportedValue: 0,
+      filter,
+      lastSampleTime: 0,
+      lastEmitTime: 0,
+    };
+  }
+
+  defaultDigitalState() {
+    return {
+      defaultValue: false,
+      value: false,
+      signal: false,
+      lastChangeTime: 0,
+      current: {
+        value: false,
+        lastChangeTime: 0,
+      },
+      filter: {
+        value: false,
+        lastChangeTime: 0,
+        lastChangeOnTime: 0,
+        lastChangeOffTime: 0,
+      },
+    };
+  }
+
+  defaultCounterState() {
+    return {
+      defaultValue: 0,
+      value: 0,
+      signal: false,
+      lastChangeTime: 0,
+      current: {
+        value: false,
+        lastChangeTime: 0,
+      },
+      filter: {
+        value: false,
+        lastChangeTime: 0,
+      },
+    };
+  }
+
+  addSource(source) {
+    if (source.sourceType === 'value') {
+      this.addValueSource(source);
+    } else if (source.sourceType === 'mtconnect') {
+      this.addMtconnectSource(source);
+    }
+  }
+
+  addValueSource(source) {
+    const pinMap = _.keyBy(_.range(12), i => `pin-${i}`);
+
+    source.on('update', (pin, value, time) => {
+      if (_.has(pinMap, pin)) {
+        _.each(this.vpinsMap[pinMap[pin]], (vpin) => {
+          vpin.handle(vpin, value, time);
+        });
+      }
+    });
+
+    source.on('unavailable', (time) => {
+      _.each(this.vpins, (vpin) => {
+        this.emit('unavailable', vpin.name, time);
+
+        if (vpin.type === 'analog') {
+          vpin.state = this.defaultAnalogState(vpin);
+        } else if (vpin.type === 'digital') {
+          vpin.state = this.defaultDigitalState();
+        } else if (vpin.type === 'counter') {
+          vpin.state = this.defaultCounterState();
+        }
+      });
+    });
+
+    source.on('available', (time) => {
+      _.each(this.vpins, (vpin) => {
+        this.emit('update', vpin.name, vpin.state.value, time);
+      });
+    });
+  }
+
+  addMtconnectSource(source) {
+    source.on('update-sample', (key, value, time) => {
+      this.emit('update-sample', key, value, time);
+    });
+
+    source.on('update-condition', (key, fields, time) => {
+      this.emit('update-condition', key, fields, time);
+    });
+
+    source.on('update-message', (key, value, time) => {
+      this.emit('update-message', key, value, time);
+    });
+  }
+
+  inputNames() {
+    return _.keys(this.vpins);
+  }
+
+  defaultInputState() {
+    return _.mapValues(this.vpins, vpin => vpin.state.defaultValue);
+  }
+
+  currentState() {
+    return _.mapValues(this.vpins, vpin => vpin.state.value);
+  }
+
+  setVpinState(vpin, value) {
+    vpin.state.value = value;
+    this.expressionInputState[vpin.name] = value;
+  }
+
+  sendUpdate(vpin, value, time) {
+    if (_.isNumber(value)) {
+      value = Math.round(value * 1000) / 1000;
+    }
+
+    if (vpin.log) {
+      this.logSample(vpin.log, value, time);
+    }
+    if (vpin.verboseEmit) {
+      this.logger.info(`${vpin.name} emit: ${value} at ${time}`);
+    }
+
+    // this.diagnostic.writeInput(this.port, vpin.name, time, value);
+    this.emit('update', vpin.name, value, time);
+  }
+
+  logSample(log, value, time) {
+    if (_.isNumber(value)) {
+      value = value.toFixed(3);
+    }
+    log.write(`${time.toFixed(4)}\t${value}\n`);
+  }
+
+  handleAnalogSample(vpin, sampleValue, sampleTime) {
+    const prevSampledValue = vpin.state.filter.value();
+    const prevSampledTime = sampleTime - this.scanInterval;
+
+    vpin.state.filter.addSample(sampleValue);
+    vpin.state.lastSampledValue = prevSampledValue;
+
+    if (vpin.state.lastSampleTime + vpin.sampleInterval > sampleTime) {
+      return;
+    }
+
+    vpin.state.lastSampleTime = sampleTime;
+    this.setVpinState(vpin, vpin.state.filter.value());
+
+    if (Math.abs(vpin.state.lastReportedValue - vpin.state.value) >= vpin.minDelta) {
+      if (vpin.minDelta && vpin.lastEmitTime < prevSampledTime) {
+        this.sendUpdate(vpin, vpin.state.lastReportedValue, prevSampledTime);
+      }
+
+      vpin.state.lastReportedValue = vpin.state.value;
+      vpin.lastEmitTime = sampleTime;
+      this.sendUpdate(vpin, vpin.state.value, sampleTime);
+    }
+  }
+
+  handleDigitalSample(vpin, sampleValue, sampleTime) {
+    let value = sampleValue;
+    if (this.pins[vpin.pinName].mode === 'analog') {
+      value = sampleValue >= vpin.vThresh;
+    } else if (this.pins[vpin.pinName].mode === 'counter') {
+      if (vpin.state.lastCounterValue === undefined) {
+        vpin.state.lastCounterValue = sampleValue;
+      }
+      value = (vpin.state.lastCounterValue !== sampleValue);
+      vpin.state.lastCounterValue = sampleValue;
+    }
+
+    if (vpin.invert) {
+      value = !value;
+    }
+
+    if (!this.handleDigitalCommon(vpin, value, sampleTime)) {
+      return;
+    }
+
+    if (vpin.onLatch && vpin.state.filter.lastChangeOnTime > 0) {
+      const onLatch = vpin.onLatch - vpin.filter;
+      const insideHoldWindow = vpin.state.filter.lastChangeOnTime + onLatch > sampleTime;
+      value = insideHoldWindow;
+    }
+
+    if (vpin.offLatch && vpin.state.filter.lastChangeOffTime > 0) {
+      const offLatch = vpin.offLatch - vpin.filter;
+      const insideHoldWindow = vpin.state.filter.lastChangeOffTime + offLatch > sampleTime;
+      value = !insideHoldWindow;
+    }
+
+    // "reported" value after any filtering or transformation has been applied
+    if (value !== vpin.state.signal) {
+      vpin.state.signal = value;
+      this.setVpinState(vpin, value);
+      vpin.state.lastChangeTime = sampleTime;
+
+      this.sendUpdate(vpin, vpin.state.value, sampleTime);
+    }
+  }
+
+  handleCounterSample(vpin, sampleValue, sampleTime) {
+    let value = sampleValue;
+
+    if (this.pins[vpin.pinName].mode === 'counter') {
+      if (vpin.sourceType === 'digital') {
+        if (vpin.state.lastCounterValue === undefined) {
+          vpin.state.lastCounterValue = sampleValue;
+        }
+        value = (vpin.state.lastCounterValue !== sampleValue);
+        vpin.state.lastCounterValue = sampleValue;
+      } else {
+        if (value !== vpin.state.value) {
+          this.setVpinState(vpin, value);
+          this.sendUpdate(vpin, vpin.state.value, sampleTime);
+        }
+        return;
+      }
+    } else if (this.pins[vpin.pinName].mode === 'analog') {
+      value = sampleValue >= vpin.vThresh;
+    }
+
+    if (vpin.invert) {
+      value = !value;
+    }
+
+    if (!this.handleDigitalCommon(vpin, value, sampleTime)) {
+      return;
+    }
+
+    if (vpin.onLatch && vpin.state.filter.lastChangeOnTime > 0) {
+      const onLatch = vpin.onLatch - vpin.filter;
+      const insideHoldWindow = vpin.state.filter.lastChangeOnTime + onLatch > sampleTime;
+      value = insideHoldWindow;
+    }
+
+    if (vpin.offLatch && vpin.state.filter.lastChangeOffTime > 0) {
+      const offLatch = vpin.offLatch - vpin.filter;
+      const insideHoldWindow = vpin.state.filter.lastChangeOffTime + offLatch > sampleTime;
+      value = !insideHoldWindow;
+    }
+
+    if (value !== vpin.state.signal) {
+      const pulseWidth = sampleTime - vpin.state.lastChangeTime;
+
+      vpin.state.signal = value;
+      vpin.state.lastChangeTime = sampleTime;
+
+      if (vpin.minPulseWidth && pulseWidth < vpin.minPulseWidth) {
+        return;
+      }
+      if (vpin.maxPulseWidth && pulseWidth > vpin.maxPulseWidth) {
+        return;
+      }
+
+      if (vpin.suspend) {
+        try {
+          if (vpin.suspend.evaluate(this.expressionInputState)) {
+            return;
+          }
+        } catch (err) {
+          err.extra = {
+            port: this.port,
+            suspendExpression: vpin.suspendDefinition,
+            suspendScope: this.expressionInputState,
+          };
+          this.logger.error(err);
+        }
+      }
+
+      if ((value && vpin.risingEdge) || (!value && vpin.fallingEdge)) {
+        this.setVpinState(vpin, vpin.state.value + 1);
+        this.sendUpdate(vpin, vpin.state.value, sampleTime);
+      }
+    }
+  }
+
+  handleDigitalCommon(vpin, value, sampleTime) {
+    // "current" value always reflects the latest v-thresh state regardless of applied filters
+    if (value !== vpin.state.current.value) {
+      vpin.state.current.value = value;
+      vpin.state.current.lastChangeTime = sampleTime;
+    }
+
+    // filter: Ignore F->T and T->F transitions if state not held for at least filter seconds
+    if (vpin.filter) {
+      const insideFilterWindow = vpin.state.current.lastChangeTime + vpin.filter > sampleTime;
+      if (insideFilterWindow && !vpin.state.filter.value && vpin.state.current.value) {
+        // console.log(`filtered at ${sampleTime}`);
+        return false;
+      }
+      if (insideFilterWindow && vpin.state.filter.value && !vpin.state.current.value) {
+        // console.log(`filtered at ${sampleTime}`);
+        return false;
+      }
+    }
+
+    if (value !== vpin.state.filter.value) {
+      vpin.state.filter.value = value;
+      vpin.state.filter.lastChangeTime = sampleTime;
+      if (value) {
+        vpin.state.filter.lastChangeOnTime = sampleTime;
+      } else {
+        vpin.state.filter.lastChangeOffTime = sampleTime;
+      }
+    }
+
+    // on-delay: Ignore F->T transitions if T state has not been held for at least on-delay seconds
+    if (vpin.onDelay) {
+      const onDelay = vpin.onDelay - vpin.filter;
+      const insideOnDelayWindow = vpin.state.filter.lastChangeTime + onDelay > sampleTime;
+      if (insideOnDelayWindow && !vpin.state.signal && vpin.state.filter.value) {
+        return false;
+      }
+    }
+
+    // off-delay: Ignore T->F transitions if F state has not been held for at least off-delay seconds
+    if (vpin.offDelay) {
+      const offDelay = vpin.offDelay - vpin.filter;
+      const insideOffDelayWindow = vpin.state.filter.lastChangeTime + offDelay > sampleTime;
+      if (insideOffDelayWindow && vpin.state.signal && !vpin.state.filter.value) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}
+
+function newIdentityFilter() {
+  let sample = 0;
+
+  return {
+    addSample: (value) => {
+      sample = value;
+    },
+    value: () => sample,
+  };
+}
+
+function newSMAFilter(size) {
+  const ringBuffer = newRingBuffer(size);
+  let sma = 0;
+
+  return {
+    addSample: (value) => {
+      value /= size;
+      sma += value;
+      sma -= ringBuffer.get(ringBuffer.getTailIndex());
+      ringBuffer.push(value);
+    },
+    value: () => sma,
+  };
+}
+
+function newMinFilter(size) {
+  const ringBuffer = newRingBuffer(size);
+  let min = 0;
+
+  return {
+    addSample: (value) => {
+      const oldest = ringBuffer.get(ringBuffer.getTailIndex());
+      ringBuffer.push(value);
+
+      if (min === oldest) {
+        min = _.min(ringBuffer.values());
+      } else if (min > value) {
+        min = value;
+      }
+    },
+    value: () => min,
+  };
+}
+
+function newMaxFilter(size) {
+  const ringBuffer = newRingBuffer(size);
+  let max = 0;
+
+  return {
+    addSample: (value) => {
+      const oldest = ringBuffer.get(ringBuffer.getTailIndex());
+      ringBuffer.push(value);
+
+      if (max === oldest) {
+        max = _.max(ringBuffer.values());
+      } else if (max < value) {
+        max = value;
+      }
+    },
+    value: () => max,
+  };
+}
+
+function newRingBuffer(size) {
+  const buffer = _.times(size, _.constant(0));
+  let pointer = 0;
+
+  return {
+    get: key => buffer[key % size],
+    getHeadIndex: () => (pointer + (size - 1)) % size,
+    getTailIndex: () => pointer,
+    push: (value) => {
+      buffer[pointer] = value;
+      pointer = (size + pointer + 1) % size;
+    },
+    values: () => buffer,
+  };
+}
+
+module.exports = EngineV1;