Re-work sensor framework

libs/core/analog.ts

@@ -1,5 +1,111 @@
-namespace input {
+const enum IrSensorMode {
+    None = -1,
+    Proximity = 0,
+    Seek = 1,
+    RemoteControl = 2,
+}
 
+const enum IrRemoteChannel {
+    Ch0 = 0, // top
+    Ch1 = 1,
+    Ch2 = 2,
+    Ch3 = 3,
+}
+
+const enum IrRemoteButton {
+    None = 0x00,
+    CenterBeacon = 0x01,
+    TopLeft = 0x02,
+    BottomLeft = 0x04,
+    TopRight = 0x08,
+    BottomRight = 0x10,
+}
+
+namespace core {
+    let nextComponentId = 20000;
+
+    export class Component {
+        protected _id: number;
+        constructor(id = 0) {
+            if (!id) id = ++nextComponentId
+            this._id = id
+        }
+
+        getId() {
+            return this._id;
+        }
+    }
+}
+
+const enum LMS {
+    NUM_INPUTS = 4,
+    LCD_WIDTH = 178,
+    LCD_HEIGHT = 128,
+
+    DEVICE_TYPE_NXT_TOUCH = 1,
+    DEVICE_TYPE_NXT_LIGHT = 2,
+    DEVICE_TYPE_NXT_SOUND = 3,
+    DEVICE_TYPE_NXT_COLOR = 4,
+    DEVICE_TYPE_TACHO = 7,
+    DEVICE_TYPE_MINITACHO = 8,
+    DEVICE_TYPE_NEWTACHO = 9,
+    DEVICE_TYPE_TOUCH = 16,
+    DEVICE_TYPE_THIRD_PARTY_START = 50,
+    DEVICE_TYPE_THIRD_PARTY_END = 99,
+    DEVICE_TYPE_IIC_UNKNOWN = 100,
+    DEVICE_TYPE_NXT_TEST = 101,
+    DEVICE_TYPE_NXT_IIC = 123,
+    DEVICE_TYPE_TERMINAL = 124,
+    DEVICE_TYPE_UNKNOWN = 125,
+    DEVICE_TYPE_NONE = 126,
+    DEVICE_TYPE_ERROR = 127,
+    MAX_DEVICE_DATALENGTH = 32,
+    MAX_DEVICE_MODES = 8,
+    UART_BUFFER_SIZE = 64,
+    TYPE_NAME_LENGTH = 11,
+    SYMBOL_LENGTH = 4,
+    DEVICE_LOGBUF_SIZE = 300,
+    IIC_NAME_LENGTH = 8,
+    CONN_UNKNOWN = 111,
+    CONN_DAISYCHAIN = 117,
+    CONN_NXT_COLOR = 118,
+    CONN_NXT_DUMB = 119,
+    CONN_NXT_IIC = 120,
+    CONN_INPUT_DUMB = 121,
+    CONN_INPUT_UART = 122,
+    CONN_OUTPUT_DUMB = 123,
+    CONN_OUTPUT_INTELLIGENT = 124,
+    CONN_OUTPUT_TACHO = 125,
+    CONN_NONE = 126,
+    CONN_ERROR = 127,
+    opOutputGetType = 0xA0,
+    opOutputSetType = 0xA1,
+    opOutputReset = 0xA2,
+    opOutputStop = 0xA3,
+    opOutputPower = 0xA4,
+    opOutputSpeed = 0xA5,
+    opOutputStart = 0xA6,
+    opOutputPolarity = 0xA7,
+    opOutputRead = 0xA8,
+    opOutputTest = 0xA9,
+    opOutputReady = 0xAA,
+    opOutputPosition = 0xAB,
+    opOutputStepPower = 0xAC,
+    opOutputTimePower = 0xAD,
+    opOutputStepSpeed = 0xAE,
+    opOutputTimeSpeed = 0xAF,
+    opOutputStepSync = 0xB0,
+    opOutputTimeSync = 0xB1,
+    opOutputClearCount = 0xB2,
+    opOutputGetCount = 0xB3,
+    opOutputProgramStop = 0xB4,
+
+    DEVICE_EVT_ANY = 0,
+    DEVICE_ID_NOTIFY = 10000,
+    DEVICE_ID_NOTIFY_ONE = 10001,
+}
+
+namespace inputint {
     //% shim=pxt::unsafePollForChanges
     function unsafePollForChanges(
         periodMs: int32,
@@ -8,6 +114,300 @@ namespace input {
     ) { }
 
     let analogMM: MMap
+    let uartMM: MMap
+    let devcon: Buffer
+    let sensors: SensorInfo[]
+    let autoSensors: Sensor[]
+
+    class SensorInfo {
+        port: number
+        sensor: Sensor
+        connType: number
+        devType: number
+        manual: boolean
+
+        constructor(p: number) {
+            this.port = p
+            this.connType = LMS.CONN_NONE
+            this.devType = LMS.DEVICE_TYPE_NONE
+            this.sensor = null
+            this.manual = false
+        }
+    }
+
+    function init() {
+        if (sensors) return
+        sensors = []
+        for (let i = 0; i < LMS.NUM_INPUTS; ++i) sensors.push(new SensorInfo(i))
+        autoSensors = []
+        devcon = output.createBuffer(DevConOff.Size)
+
+        analogMM = control.mmap("/dev/lms_analog", AnalogOff.Size, 0)
+        if (!analogMM) control.fail("no analog sensor")
+
+        uartMM = control.mmap("/dev/lms_uart", UartOff.Size, 0)
+        if (!uartMM) control.fail("no uart sensor")
+
+        loops.forever(() => {
+            detectDevices()
+            loops.pause(500)
+        })
+
+        for (let info_ of sensors) {
+            let info = info_
+            unsafePollForChanges(50, () => {
+                if (info.sensor) return info.sensor._query()
+                return 0
+            }, (prev, curr) => {
+                if (info.sensor) info.sensor._update(prev, curr)
+            })
+        }
+
+    }
+
+    function readUartInfo(port: number, mode: number) {
+        let buf = output.createBuffer(UartCtlOff.Size)
+        buf[UartCtlOff.Port] = port
+        buf[UartCtlOff.Mode] = mode
+        uartMM.ioctl(IO.UART_READ_MODE_INFO, buf)
+        return buf
+        //let info = `t:${buf[TypesOff.Type]} c:${buf[TypesOff.Connection]} m:${buf[TypesOff.Mode]} n:${buf.slice(0, 12).toHex()}`
+        //serial.writeLine("UART " + port + " / " + mode + " - " + info)
+    }
+
+    function detectDevices() {
+        let conns = analogMM.slice(AnalogOff.InConn, LMS.NUM_INPUTS)
+        let numChanged = 0
+
+        for (let info of sensors) {
+            let newConn = conns[info.port]
+            if (newConn == info.connType)
+                continue
+            numChanged++
+            info.connType = newConn
+            info.devType = LMS.DEVICE_TYPE_NONE
+            if (newConn == LMS.CONN_INPUT_UART) {
+                setUartMode(info.port, 0)
+                let uinfo = readUartInfo(info.port, 0)
+                info.devType = uinfo[TypesOff.Type]
+            } else if (newConn == LMS.CONN_INPUT_DUMB) {
+                // TODO? for now assume touch
+                info.devType = LMS.DEVICE_TYPE_TOUCH
+            } else if (newConn == LMS.CONN_NONE) {
+                // OK
+            } else {
+                // ???
+            }
+        }
+
+        if (numChanged == 0)
+            return
+
+        let autos = sensors.filter(s => !s.manual)
+
+        // first free up disconnected sensors
+        for (let info of autos) {
+            if (info.sensor && info.devType == LMS.DEVICE_TYPE_NONE)
+                info.sensor._setPort(0)
+        }
+
+        for (let info of autos) {
+            if (!info.sensor && info.devType != LMS.DEVICE_TYPE_NONE) {
+                for (let s of autoSensors) {
+                    if (s.getPort() == 0 && s._deviceType() == info.devType) {
+                        s._setPort(info.port + 1)
+                        break
+                    }
+                }
+            }
+        }
+    }
+
+    export class Sensor extends core.Component {
+        protected port: number
+
+        constructor() {
+            super()
+            init()
+            this.port = -1
+            let tp = this._deviceType()
+            if (autoSensors.filter(s => s._deviceType() == tp).length == 0) {
+                autoSensors.push(this)
+            }
+        }
+
+        // 0 - disable, 1-4 port number
+        _setPort(port: number, manual = false) {
+            port = Math.clamp(0, 4, port | 0) - 1;
+            if (port == this.port) return
+            for (let i = 0; i < sensors.length; ++i) {
+                if (i != this.port && sensors[i].sensor == this) {
+                    sensors[i] = null
+                    sensors[i].manual = false
+                }
+            }
+            if (this.port > 0) {
+                let prev = sensors[this.port].sensor
+                if (prev && prev != this)
+                    prev._setPort(0)
+                sensors[this.port].sensor = this
+                sensors[this.port].manual = manual
+            }
+            this._portUpdated()
+        }
+
+        protected _portUpdated() { }
+
+        setPort(port: number) {
+            this._setPort(port, true)
+        }
+
+        getPort() {
+            return this.port + 1
+        }
+
+        isManual() {
+            return this.port >= 0 && sensors[this.port].manual
+        }
+
+        _query() {
+            return 0
+        }
+
+        _update(prev: number, curr: number) {
+        }
+
+        _deviceType() {
+            return 0
+        }
+    }
+
+    export class AnalogSensor extends Sensor {
+        constructor() {
+            super()
+        }
+
+        _readPin6() {
+            if (this.port < 0) return 0
+            return analogMM.getNumber(NumberFormat.Int16LE, AnalogOff.InPin6 + 2 * this.port)
+        }
+    }
+
+
+
+    export class UartSensor extends Sensor {
+        protected mode: number
+
+        constructor() {
+            super()
+        }
+
+        protected _portUpdated() {
+            this.mode = -1
+            if (this.port > 0) {
+                if (this.isManual()) {
+                    uartReset(this.port)
+                } else {
+                    this.mode = 0
+                }
+            }
+        }
+
+        protected _setMode(m: number) {
+            if (this.port < 0) return
+            let v = m | 0
+            if (v != this.mode) {
+                this.mode = v
+                setUartMode(this.port, v)
+            }
+        }
+
+        getBytes(): Buffer {
+            return getUartBytes(this.port)
+        }
+
+        getNumber(fmt: NumberFormat, off: number) {
+            return getUartNumber(fmt, off, this.port)
+        }
+    }
+
+    function uartReset(port: number) {
+        if (port < 0) return
+        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, LMS.CONN_NONE)
+        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 0)
+        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, 0)
+        uartMM.ioctl(IO.UART_SET_CONN, devcon)
+    }
+
+    function getUartStatus(port: number) {
+        if (port < 0) return 0
+        return uartMM.getNumber(NumberFormat.Int8LE, UartOff.Status + port)
+    }
+
+    function waitNonZeroUartStatus(port: number) {
+        while (true) {
+            if (port < 0) return 0
+            let s = getUartStatus(port)
+            if (s) return s
+            loops.pause(25)
+        }
+    }
+
+    function uartClearChange(port: number) {
+        const UART_DATA_READY = 8
+        const UART_PORT_CHANGED = 1
+        while (true) {
+            let status = getUartStatus(port)
+            if (port < 0) break
+
+            if ((status & UART_DATA_READY) != 0 && (status & UART_PORT_CHANGED) == 0)
+                break
+
+            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, LMS.CONN_INPUT_UART)
+            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 0)
+            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, 0)
+
+            uartMM.ioctl(IO.UART_CLEAR_CHANGED, devcon)
+
+            uartMM.setNumber(NumberFormat.Int8LE, UartOff.Status + port,
+                getUartStatus(port) & 0xfffe)
+            loops.pause(10)
+        }
+    }
+
+    function setUartMode(port: number, mode: number) {
+        const UART_PORT_CHANGED = 1
+        while (true) {
+            if (port < 0) return
+            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, LMS.CONN_INPUT_UART)
+            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 33)
+            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, mode)
+            uartMM.ioctl(IO.UART_SET_CONN, devcon)
+            let status = waitNonZeroUartStatus(port)
+            if (status & UART_PORT_CHANGED) {
+                uartClearChange(port)
+            } else {
+                break
+            }
+            loops.pause(10)
+        }
+    }
+
+    function getUartBytes(port: number): Buffer {
+        if (port < 0) return output.createBuffer(LMS.MAX_DEVICE_DATALENGTH)
+        let index = uartMM.getNumber(NumberFormat.UInt16LE, UartOff.Actual + port * 2)
+        return uartMM.slice(
+            UartOff.Raw + LMS.MAX_DEVICE_DATALENGTH * 300 * port + LMS.MAX_DEVICE_DATALENGTH * index,
+            LMS.MAX_DEVICE_DATALENGTH)
+    }
+
+    function getUartNumber(fmt: NumberFormat, off: number, port: number) {
+        if (port < 0) return 0
+        let index = uartMM.getNumber(NumberFormat.UInt16LE, UartOff.Actual + port * 2)
+        return uartMM.getNumber(fmt,
+            UartOff.Raw + LMS.MAX_DEVICE_DATALENGTH * 300 * port + LMS.MAX_DEVICE_DATALENGTH * index + off)
+    }
+
 
     const enum NxtColOff {
         Calibration = 0, // uint32[4][3]
@@ -41,104 +441,6 @@ namespace input {
         Size = 5172
     }
 
-    function init() {
-        if (analogMM) return
-        analogMM = control.mmap("/dev/lms_analog", AnalogOff.Size, 0)
-        if (!analogMM) control.fail("no analog sensor")
-    }
-
-    export function portState() {
-        init()
-        return analogMM.slice(AnalogOff.Updated, 12)
-    }
-
-    export class AnalogSensor {
-        protected port: number
-        protected id: number
-
-        protected getPin6() {
-            return readAnalogPin6(this.port)
-        }
-
-        constructor(port: number) {
-            this.port = Math.clamp(1, 4, port | 0) - 1;
-            this.id = 200 + port;
-            init()
-        }
-    }
-
-    export class TouchSensor extends AnalogSensor {
-        private downTime: number;
-
-        constructor(port: number) {
-            super(port)
-            unsafePollForChanges(50,
-                () => this.isPressed() ? 1 : 0,
-                (prev, curr) => {
-                    if (prev == curr) return
-                    if (curr) {
-                        this.downTime = control.millis()
-                        control.raiseEvent(this.id, ButtonEvent.Down)
-                    } else {
-                        control.raiseEvent(this.id, ButtonEvent.Up)
-                        let delta = control.millis() - this.downTime
-                        control.raiseEvent(this.id, delta > 500 ? ButtonEvent.LongClick : ButtonEvent.Click)
-                    }
-                })
-        }
-
-        isPressed() {
-            return this.getPin6() > 2500
-        }
-
-        /**
-         * Do something when a touch sensor is clicked, double clicked, etc...
-         * @param button the button that needs to be clicked or used
-         * @param event the kind of button gesture that needs to be detected
-         * @param body code to run when the event is raised
-         */
-        onEvent(ev: ButtonEvent, body: () => void) {
-            control.onEvent(this.id, ev, body)
-        }
-    }
-
-    function readAnalogPin6(port: number) {
-        init()
-        port--
-        port = Math.clamp(0, 3, port | 0)
-        return analogMM.getNumber(NumberFormat.Int16LE, AnalogOff.InPin6 + 2 * port)
-    }
-
-}
-
-const enum IrSensorMode {
-    None = -1,
-    Proximity = 0,
-    Seek = 1,
-    RemoteControl = 2,
-}
-
-
-const enum IrRemoteChannel {
-    Ch0 = 0, // top
-    Ch1 = 1,
-    Ch2 = 2,
-    Ch3 = 3,
-}
-
-const enum IrRemoteButton {
-    None = 0x00,
-    CenterBeacon = 0x01,
-    TopLeft = 0x02,
-    BottomLeft = 0x04,
-    TopRight = 0x08,
-    BottomRight = 0x10,
-}
-
-namespace input {
-    let uartMM: MMap
-    let devcon: Buffer
-
     const enum DevConOff {
         Connection = 0, // int8[4]
         Type = 4, // int8[4]
@@ -209,94 +511,76 @@ namespace input {
         TST_UART_READ = 0xc0487409,
         TST_UART_WRITE = 0xc048740a,
     }
+}
 
-    function init() {
+namespace input {
-        if (uartMM) return
+    export class TouchSensor extends inputint.AnalogSensor {
-        uartMM = control.mmap("/dev/lms_uart", UartOff.Size, 0)
+        button: ButtonWrapper;
-        if (!uartMM) control.fail("no uart sensor")
-        devcon = output.createBuffer(DevConOff.Size)
-    }
 
-    function uartReset(port: number) {
+        constructor() {
-        port = Math.clamp(0, 3, port)
+            super()
-        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_NONE)
+            this.button = new ButtonWrapper()
-        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 0)
+        }
-        devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, 0)
-        uartMM.ioctl(IO.UART_SET_CONN, devcon)
-    }
 
-    function getUartStatus(port: number) {
+        _query() {
-        return uartMM.getNumber(NumberFormat.Int8LE, UartOff.Status + port)
+            return this._readPin6() > 2500 ? 1 : 0
-    }
+        }
 
-    function waitNonZeroUartStatus(port: number) {
+        _update(prev: number, curr: number) {
-        while (true) {
+            this.button.update(curr > 0)
-            let s = getUartStatus(port)
-            if (s) return s
-            loops.pause(25)
         }
     }
 
-    function uartClearChange(port: number) {
+    export class ButtonWrapper extends core.Component {
-        const UART_DATA_READY = 8
+        private downTime: number;
-        const UART_PORT_CHANGED = 1
+        private _isPressed: boolean;
-        while (true) {
+        private _wasPressed: boolean;
-            let status = getUartStatus(port)
 
-            if ((status & UART_DATA_READY) != 0 && (status & UART_PORT_CHANGED) == 0)
+        constructor() {
-                break
+            super()
-
+            this.downTime = 0
-            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_INPUT_UART)
+            this._isPressed = false
-            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 0)
+            this._wasPressed = false
-            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, 0)
-
-            uartMM.ioctl(IO.UART_CLEAR_CHANGED, devcon)
-
-            uartMM.setNumber(NumberFormat.Int8LE, UartOff.Status + port,
-                getUartStatus(port) & 0xfffe)
-            loops.pause(10)
         }
-    }
 
-    function setUartMode(port: number, mode: number) {
+        //% hidden
-        const UART_PORT_CHANGED = 1
+        update(curr: boolean) {
-        port = Math.clamp(0, 3, port)
+            if (this._isPressed == curr) return
-        loops.pause(100)
+            this._isPressed = curr
-        while (true) {
+            if (curr) {
-            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Connection + port, DAL.CONN_INPUT_UART)
+                this.downTime = control.millis()
-            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Type + port, 33)
+                control.raiseEvent(this._id, ButtonEvent.Down)
-            devcon.setNumber(NumberFormat.Int8LE, DevConOff.Mode + port, mode)
-            uartMM.ioctl(IO.UART_SET_CONN, devcon)
-            let status = waitNonZeroUartStatus(port)
-            if (status & UART_PORT_CHANGED) {
-                uartClearChange(port)
             } else {
-                break
+                control.raiseEvent(this._id, ButtonEvent.Up)
+                let delta = control.millis() - this.downTime
+                control.raiseEvent(this._id, delta > 500 ? ButtonEvent.LongClick : ButtonEvent.Click)
             }
-            loops.pause(10)
         }
-    }
 
-    function getUartBytes(port: number): Buffer {
+        /**
-        let index = uartMM.getNumber(NumberFormat.UInt16LE, UartOff.Actual + port * 2)
+         * Check if button is currently pressed.
-        return uartMM.slice(UartOff.Raw + 32 * 300 * port + 32 * index, 32)
+         */
-    }
+        isPressed() {
+            return this._isPressed
+        }
 
-    function getUartNumber(fmt: NumberFormat, off: number, port: number) {
+        /**
-        let index = uartMM.getNumber(NumberFormat.UInt16LE, UartOff.Actual + port * 2)
+         * Check if button was pressed since last check.
-        return uartMM.getNumber(fmt, UartOff.Raw + 32 * 300 * port + 32 * index + off)
+         */
-    }
+        wasPressed() {
+            const r = this._wasPressed
+            this._wasPressed = false
+            return r
+        }
 
-
+        /**
-    export class UartSensor {
+         * Do something when a touch sensor is clicked, double clicked, etc...
-        port: number
+         * @param button the button that needs to be clicked or used
-        id: number
+         * @param event the kind of button gesture that needs to be detected
-
+         * @param body code to run when the event is raised
-        constructor(port: number) {
+         */
-            this.port = Math.clamp(1, 4, port | 0) - 1;
+        onEvent(ev: ButtonEvent, body: () => void) {
-            this.id = 210 + port;
+            control.onEvent(this._id, ev, body)
-            init()
-            uartReset(this.port)
         }
     }
 
@@ -318,16 +602,41 @@ namespace input {
         }
     }
 
-    export class IrSensor extends UartSensor {
+    export class IrSensor extends inputint.UartSensor {
-        private mode: IrSensorMode
         private channel: IrRemoteChannel
         private pollRunning: boolean
+        private buttons: ButtonWrapper[];
 
-        constructor(port: number) {
+        constructor() {
-            super(port)
+            super()
-            this.mode = IrSensorMode.None
             this.channel = IrRemoteChannel.Ch0
-            this.pollRunning = false
+            this.buttons = []
+            for (let i = 0; i < 5; ++i) {
+                this.buttons.push(new ButtonWrapper())
+            }
+        }
+
+        button(id: IrRemoteButton) {
+            let num = -1
+            while (id) {
+                id >>= 1;
+                num++;
+            }
+            num = Math.clamp(0, this.buttons.length - 1, num)
+            return this.buttons[num]
+        }
+
+        _query() {
+            if (this.mode == IrSensorMode.RemoteControl)
+                return mapButton(this.getNumber(NumberFormat.UInt8LE, this.channel))
+            return 0
+        }
+
+        _update(prev: number, curr: number) {
+            for (let i = 0; i < this.buttons.length; ++i) {
+                let v = !!(curr & (1 << i))
+                this.buttons[i].update(v)
+            }
         }
 
         setRemoteChannel(c: IrRemoteChannel) {
@@ -337,29 +646,28 @@ namespace input {
         }
 
         setMode(m: IrSensorMode) {
-            let v = Math.clamp(0, 2, m | 0)
+            this._setMode(m)
-            if (v != this.mode) {
-                this.mode = v
-                setUartMode(this.port, v)
-            }
         }
 
         getDistance() {
             this.setMode(IrSensorMode.Proximity)
-            return getUartNumber(NumberFormat.UInt8LE, 0, this.port)
+            return this.getNumber(NumberFormat.UInt8LE, 0)
         }
 
         getRemoteCommand() {
             this.setMode(IrSensorMode.RemoteControl)
-            let v = getUartNumber(NumberFormat.UInt8LE, this.channel, this.port)
+            return this.getNumber(NumberFormat.UInt8LE, this.channel)
-            return v
         }
 
         getDirectionAndDistance() {
             this.setMode(IrSensorMode.Seek)
-            return getUartNumber(NumberFormat.UInt16LE, this.channel * 2, this.port)
+            return this.getNumber(NumberFormat.UInt16LE, this.channel * 2)
         }
     }
 
 
+    //% whenUsed
+    export const touch: TouchSensor = new TouchSensor()
+    //% whenUsed
+    export const ir: IrSensor = new IrSensor()
 }

libs/core/output.ts

@@ -24,35 +24,35 @@ namespace output {
     }
 
     export function stop(out: Output, useBreak = false) {
-        let b = mkCmd(out, DAL.opOutputStop, 1)
+        let b = mkCmd(out, LMS.opOutputStop, 1)
         b.setNumber(NumberFormat.UInt8LE, 2, useBreak ? 1 : 0)
         writePWM(b)
     }
 
     export function start(out: Output) {
-        let b = mkCmd(out, DAL.opOutputStart, 0)
+        let b = mkCmd(out, LMS.opOutputStart, 0)
         writePWM(b)
     }
 
     export function reset(out: Output) {
-        let b = mkCmd(out, DAL.opOutputReset, 0)
+        let b = mkCmd(out, LMS.opOutputReset, 0)
         writePWM(b)
     }
 
     export function setSpeed(out: Output, speed: number) {
-        let b = mkCmd(out, DAL.opOutputSpeed, 1)
+        let b = mkCmd(out, LMS.opOutputSpeed, 1)
         b.setNumber(NumberFormat.Int8LE, 2, Math.clamp(-100, 100, speed))
         writePWM(b)
     }
 
     export function setPower(out: Output, power: number) {
-        let b = mkCmd(out, DAL.opOutputPower, 1)
+        let b = mkCmd(out, LMS.opOutputPower, 1)
         b.setNumber(NumberFormat.Int8LE, 2, Math.clamp(-100, 100, power))
         writePWM(b)
     }
 
     export function setPolarity(out: Output, polarity: number) {
-        let b = mkCmd(out, DAL.opOutputPolarity, 1)
+        let b = mkCmd(out, LMS.opOutputPolarity, 1)
         b.setNumber(NumberFormat.Int8LE, 2, Math.clamp(-1, 1, polarity))
         writePWM(b)
     }
@@ -68,11 +68,11 @@ namespace output {
     }
 
     export function step(out: Output, opts: StepOptions) {
-        let op = opts.useSteps ? DAL.opOutputStepSpeed : DAL.opOutputTimeSpeed
+        let op = opts.useSteps ? LMS.opOutputStepSpeed : LMS.opOutputTimeSpeed
         let speed = opts.speed
         if (speed == null) {
             speed = opts.power
-            op = opts.useSteps ? DAL.opOutputStepPower : DAL.opOutputTimePower
+            op = opts.useSteps ? LMS.opOutputStepPower : LMS.opOutputTimePower
             if (speed == null)
                 return
         }
@@ -90,7 +90,7 @@ namespace output {
 
     const types = [0, 0, 0, 0]
     export function setType(out: Output, type: OutputType) {
-        let b = mkCmd(out, DAL.opOutputSetType, 3)
+        let b = mkCmd(out, LMS.opOutputSetType, 3)
         for (let i = 0; i < 4; ++i) {
             if (out & (1 << i)) {
                 types[i] = type