host.ts

namespace microcode {
    // mapping of micro:bit and DAL namespace into MicroCode tiles

    type IdMap = { [id: number]: number }

    // see DAL for these values
    const matchPressReleaseTable: IdMap = {
        1: Tid.TID_FILTER_BUTTON_A, // DAL.DEVICE_ID_BUTTON_A
        2: Tid.TID_FILTER_BUTTON_B, // DAL.DEVICE_ID_BUTTON_B
        121: Tid.TID_FILTER_LOGO, // DAL.MICROBIT_ID_LOGO
        100: Tid.TID_FILTER_PIN_0, // DAL.ID_PIN_P0
        101: Tid.TID_FILTER_PIN_1, // DAL.ID_PIN_P1
        102: Tid.TID_FILTER_PIN_2, // DAL.ID_PIN_P2
    }

    const gestures = [
        Gesture.Shake,
        Gesture.LogoUp,
        Gesture.LogoDown,
        Gesture.TiltLeft,
        Gesture.TiltRight,
        Gesture.ScreenUp,
        Gesture.ScreenDown,
    ]

    const gestures2tids = [
        Tid.TID_FILTER_ACCEL_SHAKE,
        Tid.TID_FILTER_ACCEL_TILT_UP,
        Tid.TID_FILTER_ACCEL_TILT_DOWN,
        Tid.TID_FILTER_ACCEL_TILT_LEFT,
        Tid.TID_FILTER_ACCEL_TILT_RIGHT,
        Tid.TID_FILTER_ACCEL_FACE_UP,
        Tid.TID_FILTER_ACCEL_FACE_DOWN,
    ]

    const buttons = [
        DAL.DEVICE_ID_BUTTON_A,
        DAL.DEVICE_ID_BUTTON_B,
        DAL.MICROBIT_ID_LOGO,
    ]

    const pins = [TouchPin.P0, TouchPin.P1, TouchPin.P2]
    const pin2tid = [
        Tid.TID_FILTER_PIN_0,
        Tid.TID_FILTER_PIN_1,
        Tid.TID_FILTER_PIN_2,
    ]

    export class MicrobitHost implements RuntimeHost {
        /** Monotonic token observed by cancellable LED display work. */
        private displayVersion = 0

        constructor() {
            this._handler = (s: number, f: number) => {}

            control.singleSimulator()
            // make sure we have V2 simulator
            input.onLogoEvent(TouchButtonEvent.Pressed, function () {})

            buttons.forEach(b => {
                control.onEvent(b, DAL.DEVICE_EVT_ANY, () => {
                    const ev = control.eventValue()
                    if (isProgramRunning()) {
                        const tid =
                            ev == DAL.DEVICE_BUTTON_EVT_DOWN
                                ? Tid.TID_SENSOR_PRESS
                                : ev == DAL.DEVICE_BUTTON_EVT_UP
                                  ? Tid.TID_SENSOR_RELEASE
                                  : undefined
                        const filter = matchPressReleaseTable[b]
                        this._handler(tid, filter)
                    } else {
                        // start up the program using the editor
                        if (ev == DAL.DEVICE_BUTTON_EVT_DOWN)
                            app.runFromEditor()
                    }
                })
            })

            pins.forEach((p, index) => {
                input.onPinPressed(p, () => {
                    this._handler(Tid.TID_SENSOR_PRESS, pin2tid[index])
                })
                input.onPinReleased(p, () => {
                    this._handler(Tid.TID_SENSOR_RELEASE, pin2tid[index])
                })
            })

            gestures.forEach((g, index) => {
                //TODO: This is a hack to fix the onGesture events not working.
                // In GDB we see that the CPP functions onGesture, MicrobitAccelerometer constructor and the LSM303Accelerometer constructor are invoked.
                // In spite of this the __handler is not invoked. For some reason this basic.pause(0) fixes this issue (possibly because of it briefly yielding?)
                basic.pause(0)
                input.onGesture(g, () => {
                    this._handler(
                        Tid.TID_SENSOR_ACCELEROMETER,
                        gestures2tids[index],
                    )
                })
            })

            radio.onReceivedNumber(radioNum => {
                this._handler(Tid.TID_SENSOR_RADIO_RECEIVE, radioNum)
            })

            input.onSound(DetectedSound.Loud, () => {
                this._handler(Tid.TID_SENSOR_MICROPHONE, Tid.TID_FILTER_LOUD)
            })

            input.onSound(DetectedSound.Quiet, () => {
                this._handler(Tid.TID_SENSOR_MICROPHONE, Tid.TID_FILTER_QUIET)
            })
        }

        public getSensorValue(tid: number, normalized: boolean): number {
            let value = 0
            let min = 0
            let max = 1
            switch (tid) {
                case Tid.TID_SENSOR_LED_LIGHT:
                    value = input.lightLevel()
                    max = 255
                    break
                case Tid.TID_SENSOR_TEMP:
                    value = input.temperature()
                    min = -40
                    max = 100
                    break
                case Tid.TID_SENSOR_MAGNET:
                    value = input.magneticForce(Dimension.Strength)
                    min = -5000
                    max = 5000
                    break
                case Tid.TID_SENSOR_MICROPHONE:
                    value = input.soundLevel()
                    max = 255
                    break
            }
            if (!normalized) return value
            return Math.abs(value) / (Math.abs(min) + max)
        }

        private _handler: (sensorTid: number, filter: number) => void
        registerOnSensorEvent(
            handler: (sensorTid: number, filter: number) => void,
        ) {
            this._handler = (tid, filter) => {
                if (tid >= 0 && filter) handler(tid, filter)
            }
        }

        emitClearScreen() {
            led.stopAnimation()
            const displayVersion = this.beginDisplayOperation()
            control.inBackground(() => {
                const anim = hex`
                    0001000000
                    0000010000
                    0000000100
                    0000000002
                    0000000004
                    0000000008
                    0000001000
                    0000100000
                    0010000000
                    0800000000
                    0400000000
                    0200000000
                    0000000000
                `
                let pos = 0
                while (
                    displayVersion == this.displayVersion &&
                    pos < anim.length
                ) {
                    for (let col = 0; col < 5; col++) {
                        for (let row = 0; row < 5; row++) {
                            if (displayVersion != this.displayVersion) return
                            const onOff =
                                anim[pos + col + (row >> 3)] & (1 << (row & 7))
                            if (onOff) led.plot(col, row)
                            else led.unplot(col, row)
                        }
                    }
                    basic.pause(20)
                    pos = pos + 5
                }
            })
        }

        public stopOngoingActions() {
            this.cancelDisplayOperation()
            music.stopAllSounds()
            led.stopAnimation()
            basic.clearScreen()
        }

        public execute(action: ActionTid, param: any) {
            switch (action) {
                case Tid.TID_ACTUATOR_PAINT:
                    const displayVersion = this.beginDisplayOperation()
                    led.stopAnimation()
                    this.showIcon(param, displayVersion)
                    return
                case Tid.TID_ACTUATOR_SHOW_NUMBER:
                    this.beginDisplayOperation()
                    led.stopAnimation()
                    basic.showNumber(param)
                    return
                case Tid.TID_ACTUATOR_RADIO_SET_GROUP:
                    radio.setGroup(param)
                    return
                case Tid.TID_ACTUATOR_RADIO_SEND:
                    radio.sendNumber(param)
                    return
                case Tid.TID_ACTUATOR_SPEAKER:
                    music.stopAllSounds()
                    music.play(
                        music.builtinPlayableSoundEffect(this.getSound(param)),
                        music.PlaybackMode.UntilDone,
                    )
                    return
                case Tid.TID_ACTUATOR_MUSIC:
                    music.stopAllSounds()
                    music.play(
                        music.stringPlayable(param, 120),
                        music.PlaybackMode.UntilDone,
                    )
                    return
            }
        }

        private beginDisplayOperation(): number {
            this.displayVersion++
            return this.displayVersion
        }

        private cancelDisplayOperation() {
            this.displayVersion++
        }

        private pauseDisplayOperation(durationMs: number, version: number) {
            const stepMs = 25
            let remaining = durationMs
            while (version == this.displayVersion && remaining > 0) {
                const pauseMs = Math.min(stepMs, remaining)
                basic.pause(pauseMs)
                remaining -= pauseMs
            }
        }

        private showIcon(img: Bitmap, displayVersion: number) {
            let s: string[] = []
            for (let row = 0; row < 5; row++) {
                for (let col = 0; col < 5; col++) {
                    if (img.getPixel(col, row)) led.plot(col, row)
                    else led.unplot(col, row)
                }
            }
            // TODO: do want this here? do we really want to yield?
            this.pauseDisplayOperation(400, displayVersion)
        }

        private getSound(sound: Tid) {
            switch (sound) {
                case Tid.TID_MODIFIER_EMOJI_GIGGLE:
                    return soundExpression.giggle
                case Tid.TID_MODIFIER_EMOJI_HAPPY:
                    return soundExpression.happy
                case Tid.TID_MODIFIER_EMOJI_HELLO:
                    return soundExpression.hello
                case Tid.TID_MODIFIER_EMOJI_MYSTERIOUS:
                    return soundExpression.mysterious
                case Tid.TID_MODIFIER_EMOJI_SAD:
                    return soundExpression.sad
                case Tid.TID_MODIFIER_EMOJI_SLIDE:
                    return soundExpression.slide
                case Tid.TID_MODIFIER_EMOJI_SOARING:
                    return soundExpression.soaring
                case Tid.TID_MODIFIER_EMOJI_SPRING:
                    return soundExpression.spring
                case Tid.TID_MODIFIER_EMOJI_TWINKLE:
                    return soundExpression.twinkle
                case Tid.TID_MODIFIER_EMOJI_YAWN:
                    return soundExpression.yawn
            }
            return soundExpression.giggle
        }
    }

    export const runtimeHost: RuntimeHost = new MicrobitHost()
}

/*

                // TODO: convert this to external sensor with events and values
                // TODO: and lift out
                const radioVal = this.getRadioVal()
                if (
                    sensor == Tid.TID_SENSOR_CAR_WALL ||
                    sensor == Tid.TID_SENSOR_LINE
                ) {
                    // this hack separates radio ranges used to communicate with robot car
                    if (
                        robot.robots.RobotCompactCommand.ObstacleState <
                        radioVal
                    )
                        if (sensor == Tid.TID_SENSOR_CAR_WALL)
                            return this.filterOnEvent(
                                radioVal -
                                    robot.robots.RobotCompactCommand
                                        .ObstacleState
                            )
                        else if (
                            robot.robots.RobotCompactCommand.LineState <=
                            radioVal
                        )
                            return this.filterOnEvent(radioVal)
                } else if (
                    radioVal < robot.robots.RobotCompactCommand.ObstacleState
                )
                    return this.filterViaCompare()

*/