:recycle: linking controllers to channels to readers | passing callbacks for onRead and onUpdate

src/channel.js

@@ -0,0 +1,64 @@
+/**
+ * @type {Reading}
+ */
+class Reading {
+    constructor({ onRead, unit, min, max }) {
+        this._val = onRead
+        this.unit = unit
+        this.max = max
+        this.min = min
+        this.created = Date.now()
+    }
+    /**
+     * Reach out and grabs the value
+     * from some sensor
+     */
+    get val() {
+        return this._val()
+    }
+}
+
+/**
+ * @type {Channel}
+ */
+class Channel {
+    constructor({ interval = 1, reader = null }) {
+        this._interval = interval
+        this._reader = reader
+    }
+    get interval() {
+        return this._interval
+    }
+    get val() {
+        return this._reader.val
+    }
+    get unit() {
+        return this._reader.unit
+    }
+    get aboveRange() {
+        return this._reader.val > this._reader.max
+    }
+    get belowRange() {
+        return this._reader.val < this._reader.min
+    }
+    get inRange() {
+        return this._reader.val && !this.aboveRange && !this.belowRange
+            ? true
+            : false
+    }
+    /** Always return a new Reading instance with new Channel instances */
+    update() {
+        const reader = new Reading({
+            // !: Setup the callback to return a sensor value
+            onRead: this._reader._val,
+            unit: this._reader.unit,
+            max: this._reader.max,
+            min: this._reader.min,
+        })
+
+        const chan = new Channel({ interval: this.interval, reader })
+        return chan
+    }
+}
+
+export { Channel, Reading }

src/controller.js

@@ -0,0 +1,39 @@
+let allWarnings = []
+
+// const _makeWarning = (msg, channelOrSensor) => ({
+//     created: Date.now(),
+//     warning: `[warning]: ${msg}`,
+//     channelOrSensor,
+// })
+
+const controllerTypes = {
+    temp: 'temperature',
+    level: 'water_level',
+}
+
+/**
+ * Object to link a channel to an action
+ *
+ * @type {Controller} links together channels
+ **/
+class Controller {
+    constructor({ type, channel }) {
+        this._type = type
+        this.channel = channel
+    }
+    get type() {
+        return this._type
+    }
+    get inRange() {
+        return this.channel.inRange
+    }
+    update() {
+        this.channel = this.channel.update()
+        return this.channel.val
+    }
+    onUpdate() {
+        // Not implemented here
+    }
+}
+
+export { Controller, controllerTypes }

src/index.js

@@ -4,10 +4,18 @@ import loop from './loop.js'
 import { System, makeContainerT } from './system.js'
 import { Container } from './container.js'
 
+class InputConf {
+    constructor(type, onRead, readInterval, onUpdate) {
+        ;(this.type = type),
+            (this.onRead = onRead),
+            (this.interval = readInterval),
+            (this.onUpdate = onUpdate)
+    }
+}
 const fromConfig = {
     tank_1: {
-        inputs: [1],
-        outputs: ['foo'],
+        inputs: [],
+        outputs: [],
         dims: { l: 24, w: 12, h: 12 },
     },
     sump_1: {
@@ -36,8 +44,6 @@ const digestConfig = config => {
 }
 
 /** Holds systems or containers */
-class Controller {}
-
 const mySystem = digestConfig(fromConfig)
 
 // Start the loop!
@@ -61,3 +67,5 @@ setTimeout(function () {
     console.log('6000ms passed, stopping the game loop')
     loop.active.splice(loop.active.indexOf(0), 1)
 }, 6000)
+
+export { InputConf }

src/system.js

@@ -1,13 +1,20 @@
-/** Holds systems or containers */
+import { Reading, Channel } from './channel'
+import { Controller } from './controller'
+
+/**
+ * Object that holds each container and their input and outputs
+ *
+ * @type {System}
+ */
 class System {
     constructor() {
         this.inventory = {}
     }
     get inputs() {
-        return Object.values(this.inventory).map(containerT => containerT[0])
+        return Object.values(this.inventory).map(containerT => containerT[0][0])
     }
     get outputs() {
-        return Object.values(this.inventory).map(containerT => containerT[1])
+        return Object.values(this.inventory).map(containerT => containerT[1][0])
     }
     get containers() {
         return Object.values(this.inventory).map(containerT => containerT[2])
@@ -38,10 +45,34 @@ class System {
     }
 }
 
-const makeContainerT = (inputs, outputs, container) => [
-    inputs,
-    outputs,
-    container,
-]
+/**
+ * Take in inputConf objects (see: index.js)
+ * and returns Controllers with an initial reading
+ **/
+const _makeControllerFromInputConfig = ({
+    type,
+    onRead,
+    interval,
+    onUpdate,
+}) => {
+    const reader = new Reading({
+        onRead,
+        unit: 'F',
+        max: 80,
+        min: 72,
+    })
+
+    const controller = new Controller({
+        type,
+        channel: new Channel({ interval, reader }),
+    })
+    controller.onUpdate = onUpdate
+    return controller
+}
+
+const makeContainerT = (inputs, outputs, container) => {
+    const controllers = inputs.map(_makeControllerFromInputConfig)
+    return [controllers, outputs, container]
+}
 
 export { System, makeContainerT }

src/utils.js

@@ -27,4 +27,11 @@ const _changeLevel = (amount, container) => {
 const fill = ({ container, amount }) => _changeLevel(amount, container)
 const drain = ({ container, amount }) => _changeLevel(-1 * amount, container)
 
-export { toLiquid, fromLiquid, fill, drain }
+const interpolate = ({ x, y, from }) => {
+    const [x1, x2] = x
+    const [y1, y2] = y
+    const to = y1 + ((y2 - y1) / (x2 - x1)) * (from - x1)
+    return to
+}
+
+export { toLiquid, fromLiquid, fill, drain, interpolate }

test/system.spec.js

@@ -1,25 +1,55 @@
 import { expect, test } from 'vitest'
-import { System } from '../src/system.js'
+import { System, makeContainerT } from '../src/system.js'
+import { Reading } from '../src/channel.js'
+import { Container } from '../src/container.js'
+import { controllerTypes } from '../src/controller.js'
+import { InputConf } from '../src/index.js'
 
 test('system - instantiates and stores inventory correctly', () => {
     let testSystem = new System()
-    testSystem.add('aaa', ['input_test', 'output_test', { id: 'aaa' }])
-    expect(testSystem.inputs).toStrictEqual(['input_test'])
-    expect(testSystem.outputs).toStrictEqual(['output_test'])
-    expect(testSystem.containers[0].id).toStrictEqual('aaa')
-
-    // Make sure inputs and outputs get reassigned
-    testSystem.replaceContainer({ id: 'aaa' })
+    testSystem.add('aaa', [['input_test'], ['output_test'], { id: 'aaa' }])
     expect(testSystem.inputs).toStrictEqual(['input_test'])
     expect(testSystem.outputs).toStrictEqual(['output_test'])
     expect(testSystem.containers[0].id).toStrictEqual('aaa')
 
     const inputs = testSystem.inputsFor({ id: 'aaa' })
-    expect(inputs).toStrictEqual('input_test')
+    expect(inputs).toStrictEqual(['input_test'])
 
     const outputs = testSystem.outputsFor({ id: 'aaa' })
-    expect(outputs).toStrictEqual('output_test')
+    expect(outputs).toStrictEqual(['output_test'])
 
     testSystem.remove('aaa')
     expect(testSystem.inventory).toStrictEqual({})
 })
+
+test('system - instiantes channels with readers correctly', () => {
+    let testSystem = new System()
+    let testContainer = new Container({ l: 10, w: 10, h: 10 })
+    let mockTemp = 70
+    let testInConf = new InputConf(
+        controllerTypes.temp,
+        () => mockTemp,
+        0.1,
+        () => {
+            console.log('tick')
+            return 'tick'
+        }
+    )
+    const cT = makeContainerT([testInConf], [], testContainer)
+    testSystem.add('aaa', cT)
+
+    expect(testSystem.inputs[0].type).toStrictEqual('temperature')
+
+    let chan = testSystem.inputs[0].channel
+    expect(chan.interval).toStrictEqual(0.1)
+
+    // Test that the channel and channel.reader are working
+    expect(chan.val).toStrictEqual(70)
+    expect(chan.unit).toStrictEqual('F')
+    expect(chan.inRange).toStrictEqual(false)
+    expect(testSystem.inputs[0].onUpdate()).toStrictEqual('tick')
+
+    mockTemp = 79
+    chan = chan.update()
+    expect(chan.val).toStrictEqual(79)
+})