:sparkles: adding controllers to respond to sensors | adding scanners to group controllers and logging

hardware/controller.js

@@ -0,0 +1,55 @@
+let allWarnings = []
+class Warning {
+    constructor(msg, channelOrSensor) {
+        this.warning = msg
+        this.outOfRange = channelOrSensor.inRange
+        this.value = channelOrSensor.value
+        this.unit = channelOrSensor.unit
+        this.scale = channelOrSensor.scale
+        this.created = Date.now()
+    }
+}
+class Reading {
+    constructor({ from, value, unit, scale }) {
+        this.value = value
+        this.unit = unit
+        this.scale = scale
+        this.from = from
+        this.created = Date.now()
+    }
+}
+
+class Controller {
+    constructor({ type, channel, sensor, action=null }) {
+        this.type = type
+        this.channel = channel
+        this.sensor = sensor
+        this.action = action
+    }
+    get inRange() {
+        return this.channel.inRange && this.sensor.inRange
+    }
+    _checkRanges(all) {
+        all.forEach(channelOrSensor => {
+            if(channelOrSensor.inRange) return
+            allWarnings.push(
+                new Warning(`${channelOrSensor} out of range.`, channelOrSensor)
+            )
+        })
+    }
+    readout() {
+        const value = this.channel.readFrom(this.sensor.update())
+        this._checkRanges([this.channel, this.sensor])
+        return new Reading({
+            value,
+            from: this.channel.name,
+            unit:  this.channel.unit,
+            scale:  this.channel.scale
+        })
+    }
+}
+
+module.exports = {
+    Controller,
+    allWarnings
+}

hardware/index.js

@@ -0,0 +1,46 @@
+const { TempSensor, Channel } = require('./sensor')
+const { Controller } = require('./controller')
+const { Scanner } = require('./scanner')
+
+const unitScale = {
+    dC: { unit: 'degree', scale: 'celcius' },
+    dF: { unit: 'degree', scale: 'fahrenheit' },
+    mV: { unit: 'volt', scale: 'millivolt' },
+    V: { unit: 'volt', scale: 'volt' }
+}
+
+/**
+ * Create a sensor and readout channel as -67 to 257 degrees fahrenheit
+ */
+const tempController = new Controller({
+    type: 'temp',
+    channel: new Channel({ name: 'temperature_channel_00', min: -67, max: 257, interval: 10, unit: unitScale.dF.unit, scale: unitScale.dF.scale }),
+    sensor: new TempSensor({ name: 'temperature_sensor_00', min: -67, max: 257, interval: 10, unit: unitScale.dF.unit, scale: unitScale.dF.scale })
+})
+console.log(tempController.readout) // { value: 78, unit: 'degrees' scale: 'fahrenheit' }
+
+/**
+ * Create a 0-5v sensor and interpolate readout as -67 to 257 degrees fahrenheit
+ */
+const manualTempController = new Controller({
+    type: 'temp',
+    channel: new Channel({ name: 'temperature_channel_01', min: -67, max: 257, interval: 10, unit: unitScale.dF.unit, scale: unitScale.dF.scale }),
+    sensor: new TempSensor({ name: 'temperature_sensor_01', min: 0, max: 5, interval: 100, unit: unitScale.mV.unit, scale: unitScale.mV.scale })
+})
+console.log(manualTempController.readout) // { value: 78, unit: 'degrees' scale: 'fahrenheit' }
+
+/**
+ * A Scanner is made up of controllers
+ * A Controller is made up of an output Channel and input Sensor
+ */
+const mySystem = new Scanner({ controllers: [ tempController, manualTempController ] })
+console.log(mySystem.readAll()) 
+/**
+ * Example: console.log(mySystem.readAll()) 
+ * temperature_channel_00: Reading({ value: 78, unit: 'degrees' scale: 'fahrenheit' }),
+ * temperature_channel_01: Reading({ value: 78, unit: 'degrees' scale: 'fahrenheit' }), 
+ */ 
+
+module.exports = {
+    unitScale
+}

hardware/scanner.js

@@ -0,0 +1,36 @@
+class Scanner {
+    constructor({ controllers }) {
+        this._controllers = controllers
+    }
+    get _controllersByType() {
+        return this._controllers.reduce((byType, controller)=> {
+            const type = controller.type
+            if(byType[type].length < 1) byType[type] = []
+            byType[type].push(controller)
+            return byType
+        }, {})
+    }
+    /**
+     * Example: only temp controllers in range?
+     * const tempControlsOK = allInRange('temp')
+     * 
+     * Example: every controller in range?
+     * const everythingOK = allInRange()
+    */
+    allInRange(type) {
+        const all = type ? this._controllersByType[type] : this._controllers
+        return all.every(controller => controller.inRange === true)
+    }
+    readAll() {
+        const completeReadout = {}
+        this._controllers.forEach(controller => {
+            const readout = controller.readout()
+            completeReadout[readout.from] = readout
+        })
+        return completeReadout
+    }
+}
+
+module.exports = {
+    Scanner
+}

hardware/sensor.js

@@ -0,0 +1,76 @@
+const { unitScale } = require('./index')
+
+const interpolate = ({ x, y, from }) => {
+    const [x1, x2] = x
+    const [y1, y2] = y
+    const to = y1 + (y2-y1) / (x2-x1) * (from-x1)
+    return to
+}
+
+class Base {
+    constructor({ name, min, max, unit, scale }) {
+        this.name = name
+        this.unit = unit
+        this.scale = scale
+        this.max = max
+        this.min = min
+        this._value = null
+    }
+    get value() { return this._value }
+    get aboveRange() {
+        return this._value > this.max
+    }
+    get belowRange() {
+        return this._value < this.max
+    }
+    get inRange() {
+        return this._value && this._value <= this.max && this._value >= this.min ? true : false
+    }
+}
+
+class Channel extends Base {
+    constructor({ name, min, max, interval=1, unit, scale }) {
+        super({ name, min: min * interval, max: max * interval, unit, scale })
+        this._interval = interval
+    }
+    readFrom(sensor) {
+        const from = sensor.value
+        this._value = interpolate({
+            x: [sensor.min, sensor.max],
+            y: [this.min, this.max],
+            from
+        })
+        return Math.round(this.value)
+    }
+}
+
+class Sensor extends Base {
+    constructor({ name, min, max, interval=1, unit=unitScale.mV.unit, scale=unitScale.mV.scale }) {
+        super({ name, min: min * interval, max: max * interval, unit, scale })
+        this._interval = interval
+    }
+}
+class TempSensor extends Sensor {
+    constructor({ min, max, interval, unit, scale }) {
+        super({ name: 'temperature_sensor', min, max, interval, unit, scale })
+    }
+    update() {
+        // Store data in this._value
+        this._value = 300
+        return this
+    }
+}
+class LevelSensor extends Sensor {
+    constructor({ min, max, interval=1, unit="millimeter" }) {
+        super({ name: 'level_sensor', min, max, interval, unit })
+    }
+    update() {
+        // Store data in this._value
+        return this
+    }
+}
+
+module.exports = {
+    Channel,
+    TempSensor,
+}