scratch-vm/src/extensions/scratch3_microbit/index.js

const ArgumentType = require('../../extension-support/argument-type');
const BlockType = require('../../extension-support/block-type');
const log = require('../../util/log');
const BLESession = require('../../io/bleSession');
const Base64Util = require('../../util/base64-util');

/**
 * Icon svg to be displayed at the left edge of each extension block, encoded as a data URI.
 * @type {string}
 */
// eslint-disable-next-line max-len
const blockIconURI = 'data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB3aWR0aD0iNDBweCIgaGVpZ2h0PSI0MHB4IiB2aWV3Qm94PSIwIDAgNDAgNDAiIHZlcnNpb249IjEuMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayI+CiAgICA8IS0tIEdlbmVyYXRvcjogU2tldGNoIDUwLjIgKDU1MDQ3KSAtIGh0dHA6Ly93d3cuYm9oZW1pYW5jb2RpbmcuY29tL3NrZXRjaCAtLT4KICAgIDx0aXRsZT5taWNyb2JpdC1ibG9jay1pY29uPC90aXRsZT4KICAgIDxkZXNjPkNyZWF0ZWQgd2l0aCBTa2V0Y2guPC9kZXNjPgogICAgPGRlZnM+PC9kZWZzPgogICAgPGcgaWQ9Im1pY3JvYml0LWJsb2NrLWljb24iIHN0cm9rZT0ibm9uZSIgc3Ryb2tlLXdpZHRoPSIxIiBmaWxsPSJub25lIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiPgogICAgICAgIDxnIGlkPSJtaWNyb2JpdCIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMy41MDAwMDAsIDYuMDAwMDAwKSI+CiAgICAgICAgICAgIDxwb2x5Z29uIGlkPSJTaGFwZSIgc3Ryb2tlPSIjN0M4N0E1IiBzdHJva2Utd2lkdGg9IjAuMjIiIGZpbGw9IiNFNkU3RTgiIGZpbGwtcnVsZT0ibm9uemVybyIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIiBwb2ludHM9IjE5LjExIDAuMTEgMTkuMTEgMSAxMy43OCAxIDEzLjc4IDAuMTEgMTQuMjIgMC4xMSAxNC4yMiAwLjMzIDE0LjY3IDAuMzMgMTQuNjcgMC4xMSAxOC4yMiAwLjExIDE4LjIyIDAuMzMgMTguNjcgMC4zMyAxOC42NyAwLjExIj48L3BvbHlnb24+CiAgICAgICAgICAgIDxwYXRoIGQ9Ik0zMC42NiwxIEwyLjIyLDEgQzEuMjQwODI1MTgsMC45OTk5ODQ1NDggMC40NDU1MDA5ODIsMS43OTA4NDA2NCAwLjQ0LDIuNzcgTDAuNDQsMjUgQzAuNDQxMjUzNjUxLDI1Ljc3MDA5NDQgMC45Mzc1ODgzNiwyNi40NTIwNTAyIDEuNjcsMjYuNjkgQzEuODQ4NzE2NTEsMjYuNzQyMTM0NSAyLjAzMzgzNjg3LDI2Ljc2OTA2MTEgMi4yMiwyNi43NyBMMzAuNjYsMjYuNzcgQzMwLjg0NjE2MzEsMjYuNzY5MDYxMSAzMS4wMzEyODM1LDI2Ljc0MjEzNDUgMzEuMjEsMjYuNjkgQzMxLjk0MjQxMTYsMjYuNDUyMDUwMiAzMi40Mzg3NDYzLDI1Ljc3MDA5NDQgMzIuNDQsMjUgTDMyLjQ0LDIuNzcgQzMyLjQzNDQ5OSwxLjc5MDg0MDY0IDMxLjYzOTE3NDgsMC45OTk5ODQ1NDggMzAuNjYsMSBaIE0zLjExLDIzLjU0IEMyLjcxMzQzNTE4LDIzLjU0IDIuMzQ2OTk0MTYsMjMuMzI4NDM1MiAyLjE0ODcxMTc1LDIyLjk4NSBDMS45NTA0MjkzMywyMi42NDE1NjQ4IDEuOTUwNDI5MzMsMjIuMjE4NDM1MiAyLjE0ODcxMTc1LDIxLjg3NSBDMi4zNDY5OTQxNiwyMS41MzE1NjQ4IDIuNzEzNDM1MTgsMjEuMzIgMy4xMSwyMS4zMiBDMy41MDY1NjQ4MiwyMS4zMiAzLjg3MzAwNTg0LDIxLjUzMTU2NDggNC4wNzEyODgyNSwyMS44NzUgQzQuMjY5NTcwNjcsMjIuMjE4NDM1MiA0LjI2OTU3MDY3LDIyLjY0MTU2NDggNC4wNzEyODgyNSwyMi45ODUgQzMuODczMDA1ODQsMjMuMzI4NDM1MiAzLjUwNjU2NDgyLDIzLjU0IDMuMTEsMjMuNTQgWiBNOS4zOCwyMy41NCBDOC45MzAxNDA4MywyMy41Mzk5ODE3IDguNTI0Nzc2MjYsMjMuMjY4NDQ0MSA4LjM1MzU3MTc5LDIyLjg1MjQzNjYgQzguMTgyMzY3MzIsMjIuNDM2NDI5IDguMjc5MTgxNDksMjEuOTU4MjIzOSA4LjU5ODcxNjA1LDIxLjY0MTU2OCBDOC45MTgyNTA2MSwyMS4zMjQ5MTIxIDkuMzk3MzEyMjYsMjEuMjMyNDI5NSA5LjgxMTc1MzQ3LDIxLjQwNzM5MTcgQzEwLjIyNjE5NDcsMjEuNTgyMzUzOCAxMC40OTQwNTI4LDIxLjk5MDE1OTEgMTAuNDksMjIuNDQgQzEwLjQ4NDUxMjEsMjMuMDQ5MTI3MiA5Ljk4OTE1MTk3LDIzLjU0MDAyNDcgOS4zOCwyMy41NCBaIE0xNi40NCwyMy41NCBDMTUuOTkwMTQwOCwyMy41Mzk5ODE3IDE1LjU4NDc3NjMsMjMuMjY4NDQ0MSAxNS40MTM1NzE4LDIyLjg1MjQzNjYgQzE1LjI0MjM2NzMsMjIuNDM2NDI5IDE1LjMzOTE4MTUsMjEuOTU4MjIzOSAxNS42NTg3MTYsMjEuNjQxNTY4IEMxNS45NzgyNTA2LDIxLjMyNDkxMjEgMTYuNDU3MzEyMywyMS4yMzI0Mjk1IDE2Ljg3MTc1MzUsMjEuNDA3MzkxNyBDMTcuMjg2MTk0NywyMS41ODIzNTM4IDE3LjU1NDA1MjgsMjEuOTkwMTU5MSAxNy41NSwyMi40NCBDMTcuNTQ0NTEyMSwyMy4wNDkxMjcyIDE3LjA0OTE1MiwyMy41NDAwMjQ3IDE2LjQ0LDIzLjU0IFogTTIzLjUsMjMuNTQgQzIzLjEwMzQzNTIsMjMuNTQgMjIuNzM2OTk0MiwyMy4zMjg0MzUyIDIyLjUzODcxMTcsMjIuOTg1IEMyMi4zNDA0MjkzLDIyLjY0MTU2NDggMjIuMzQwNDI5MywyMi4yMTg0MzUyIDIyLjUzODcxMTcsMjEuODc1IEMyMi43MzY5OTQyLDIxLjUzMTU2NDggMjMuMTAzNDM1MiwyMS4zMiAyMy41LDIxLjMyIEMyMy44OTY1NjQ4LDIxLjMyIDI0LjI2MzAwNTgsMjEuNTMxNTY0OCAyNC40NjEyODgzLDIxLjg3NSBDMjQuNjU5NTcwNywyMi4yMTg0MzUyIDI0LjY1OTU3MDcsMjIuNjQxNTY0OCAyNC40NjEyODgzLDIyLjk4NSBDMjQuMjYzMDA1OCwyMy4zMjg0MzUyIDIzLjg5NjU2NDgsMjMuNTQgMjMuNSwyMy41NCBaIE0yOS43NywyMy41NCBDMjkuMzIwMTQwOCwyMy41Mzk5ODE3IDI4LjkxNDc3NjMsMjMuMjY4NDQ0MSAyOC43NDM1NzE4LDIyLjg1MjQzNjYgQzI4LjU3MjM2NzMsMjIuNDM2NDI5IDI4LjY2OTE4MTUsMjEuOTU4MjIzOSAyOC45ODg3MTYsMjEuNjQxNTY4IEMyOS4zMDgyNTA2LDIxLjMyNDkxMjEgMjkuNzg3MzEyMywyMS4yMzI0Mjk1IDMwLjIwMTc1MzUsMjEuNDA3MzkxNyBDMzAuNjE2MTk0NywyMS41ODIzNTM4IDMwLjg4NDA1MjgsMjEuOTkwMTU5MSAzMC44OCwyMi40NCBDMzAuODc0NTEyMSwyMy4wNDkxMjcyIDMwLjM3OTE1MiwyMy41NDAwMjQ3IDI5Ljc3LDIzLjU0IFoiIGlkPSJTaGFwZSIgc3Ryb2tlPSIjMjMxRjIwIiBzdHJva2Utd2lkdGg9IjAuODkiIGZpbGw9IiMyMzFGMjAiIGZpbGwtcnVsZT0ibm9uemVybyIgb3BhY2l0eT0iMC4xIj48L3BhdGg+CiAgICA

/**
 * Icon svg to be displayed in the menu encoded as a data URI.
 * @type {string}
 */
// eslint-disable-next-line max-len
const menuIconURI = 'data:image/svg+xml;base64,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

/**
 * Enum for micro:bit BLE command protocol.
 * https://github.com/LLK/scratch-microbit-firmware/blob/master/protocol.md
 * @readonly
 * @enum {number}
 */
const BLECommand = {
    CMD_PIN_CONFIG: 0x80,
    CMD_DISPLAY_TEXT: 0x81,
    CMD_DISPLAY_LED: 0x82
};

/**
 * Enum for micro:bit protocol.
 * https://github.com/LLK/scratch-microbit-firmware/blob/master/protocol.md
 * @readonly
 * @enum {string}
 */
const BLEUUID = {
    service: 0xf005,
    rxChar: '5261da01-fa7e-42ab-850b-7c80220097cc',
    txChar: '5261da02-fa7e-42ab-850b-7c80220097cc'
};

/**
 * Manage communication with a MicroBit device over a Scrath Link client socket.
 */
class MicroBit {

    /**
     * Construct a MicroBit communication object.
     * @param {Runtime} runtime - the Scratch 3.0 runtime
     * @param {string} extensionId - the id of the extension
     */
    constructor (runtime, extensionId) {

        /**
         * The Scratch 3.0 runtime used to trigger the green flag button.
         * @type {Runtime}
         * @private
         */
        this._runtime = runtime;

        /**
         * The BluetoothLowEnergy connection session for reading/writing device data.
         * @type {BLESession}
         * @private
         */
        this._ble = null;
        this._runtime.registerExtensionDevice(extensionId, this);

        /**
         * The most recently received value for each sensor.
         * @type {Object.<string, number>}
         * @private
         */
        this._sensors = {
            tiltX: 0,
            tiltY: 0,
            buttonA: 0,
            buttonB: 0,
            touchPins: [0, 0, 0],
            gestureState: 0,
            ledMatrixState: new Uint8Array(5)
        };

        /**
         * The most recently received value for each gesture.
         * @type {Object.<string, Object>}
         * @private
         */
        this._gestures = {
            moving: false,
            move: {
                active: false,
                timeout: false
            },
            shake: {
                active: false,
                timeout: false
            },
            jump: {
                active: false,
                timeout: false
            }
        };
    }

    // TODO: keep here?
    /**
     * Called by the runtime when user wants to scan for a device.
     */
    startDeviceScan () {
        log.info('making a new BLE session');
        this._ble = new BLESession(this._runtime, {
            filters: [
                {services: [BLEUUID.service]}
            ]
        }, this._onSessionConnect.bind(this));
    }

    // TODO: keep here?
    /**
     * Called by the runtime when user wants to connect to a certain device.
     * @param {number} id - the id of the device to connect to.
     */
    connectDevice (id) {
        this._ble.connectDevice(id);
    }

    disconnectSession () {
        this._ble.disconnectSession();
    }

    getPeripheralIsConnected () {
        let connected = false;
        if (this._ble) {
            connected = this._ble.getPeripheralIsConnected();
        }
        return connected;
    }

    /**
     * @param {string} text - the text to display.
     * @return {Promise} - a Promise that resolves when writing to device.
     */
    displayText (text) {
        const output = new Uint8Array(text.length);
        for (let i = 0; i < text.length; i++) {
            output[i] = text.charCodeAt(i);
        }
        return this._writeSessionData(BLECommand.CMD_DISPLAY_TEXT, output);
    }

    /**
     * @param {Uint8Array} matrix - the matrix to display.
     * @return {Promise} - a Promise that resolves when writing to device.
     */
    displayMatrix (matrix) {
        return this._writeSessionData(BLECommand.CMD_DISPLAY_LED, matrix);
    }

    /**
     * @return {number} - the latest value received for the tilt sensor's tilt about the X axis.
     */
    get tiltX () {
        return this._sensors.tiltX;
    }

    /**
     * @return {number} - the latest value received for the tilt sensor's tilt about the Y axis.
     */
    get tiltY () {
        return this._sensors.tiltY;
    }

    /**
     * @return {boolean} - the latest value received for the A button.
     */
    get buttonA () {
        return this._sensors.buttonA;
    }

    /**
     * @return {boolean} - the latest value received for the B button.
     */
    get buttonB () {
        return this._sensors.buttonB;
    }

    /**
     * @return {number} - the latest value received for the motion gesture states.
     */
    get gestureState () {
        return this._sensors.gestureState;
    }

    /**
     * @return {Uint8Array} - the current state of the 5x5 LED matrix.
     */
    get ledMatrixState () {
        return this._sensors.ledMatrixState;
    }

    /**
     * @param {number} pin - the pin to check touch state.
     * @return {number} - the latest value received for the touch pin states.
     */
    _checkPinState (pin) {
        return this._sensors.touchPins[pin];
    }

    /**
     * Starts reading data from device after BLE has connected to it.
     */
    _onSessionConnect () {
        const callback = this._processSessionData.bind(this);
        this._ble.read(BLEUUID.service, BLEUUID.rxChar, true, callback);
    }

    /**
     * Process the sensor data from the incoming BLE characteristic.
     * @param {object} base64 - the incoming BLE data.
     * @private
     */
    _processSessionData (base64) {
        const data = Base64Util.base64ToUint8Array(base64);

        this._sensors.tiltX = data[1] | (data[0] << 8);
        if (this._sensors.tiltX > (1 << 15)) this._sensors.tiltX -= (1 << 16);
        this._sensors.tiltY = data[3] | (data[2] << 8);
        if (this._sensors.tiltY > (1 << 15)) this._sensors.tiltY -= (1 << 16);

        this._sensors.buttonA = data[4];
        this._sensors.buttonB = data[5];

        this._sensors.touchPins[0] = data[6];
        this._sensors.touchPins[1] = data[7];
        this._sensors.touchPins[2] = data[8];

        this._sensors.gestureState = data[9];
    }

    /**
     * Write a message to the device BLE session.
     * @param {number} command - the BLE command hex.
     * @param {Uint8Array} message - the message to write.
     * @return {Promise} - a Promise that resolves when writing to device.
     * @private
     */
    _writeSessionData (command, message) {
        const output = new Uint8Array(message.length + 1);
        output[0] = command; // attach command to beginning of message
        for (let i = 0; i < message.length; i++) {
            output[i + 1] = message[i];
        }
        const data = Base64Util.uint8ArrayToBase64(output);
        return this._ble.write(BLEUUID.service, BLEUUID.txChar, data, 'base64');
    }
}

/**
 * Enum for tilt sensor direction.
 * @readonly
 * @enum {string}
 */
const TiltDirection = {
    FRONT: 'front',
    BACK: 'back',
    LEFT: 'left',
    RIGHT: 'right',
    ANY: 'any'
};

/**
 * Converting symbols to hex values
 * @readonly
 */
const symbols2hex = {
    '❤': 0xAAC544,
    '♫': 0xF4AF78,
    '☓': 0x1151151,
    '✓': 0x8A88,
    '↑': 0x477C84,
    '↓': 0x427DC4,
    '←': 0x467D84,
    '→': 0x437CC4,
    '◯': 0xE8C62E,
    '☀': 0x1577DD5,
    '☺': 0x5022E,
    '!': 0x421004,
    '?': 0xC91004
};

/**
 * Scratch 3.0 blocks to interact with a MicroBit device.
 */
class Scratch3MicroBitBlocks {

    /**
     * @return {string} - the name of this extension.
     */
    static get EXTENSION_NAME () {
        return 'MicroBit';
    }

    /**
     * @return {string} - the ID of this extension.
     */
    static get EXTENSION_ID () {
        return 'microbit';
    }

    /**
     * @return {number} - the tilt sensor counts as "tilted" if its tilt angle meets or exceeds this threshold.
     */
    static get TILT_THRESHOLD () {
        return 15;
    }

    /**
     * Construct a set of MicroBit blocks.
     * @param {Runtime} runtime - the Scratch 3.0 runtime.
     */
    constructor (runtime) {
        /**
         * The Scratch 3.0 runtime.
         * @type {Runtime}
         */
        this.runtime = runtime;

        // Create a new MicroBit device instance
        this._device = new MicroBit(this.runtime, Scratch3MicroBitBlocks.EXTENSION_ID);
    }

    /**
     * @returns {object} metadata for this extension and its blocks.
     */
    getInfo () {
        return {
            id: Scratch3MicroBitBlocks.EXTENSION_ID,
            name: Scratch3MicroBitBlocks.EXTENSION_NAME,
            menuIconURI: menuIconURI,
            blockIconURI: blockIconURI,
            showStatusButton: true,
            blocks: [
                {
                    opcode: 'whenButtonPressed',
                    text: 'when [BTN] button pressed',
                    blockType: BlockType.HAT,
                    arguments: {
                        BTN: {
                            type: ArgumentType.STRING,
                            menu: 'buttons',
                            defaultValue: 'A'
                        }
                    }
                },
                {
                    opcode: 'whenMoved',
                    text: 'when moved',
                    blockType: BlockType.HAT
                },
                {
                    opcode: 'whenShaken',
                    text: 'when shaken',
                    blockType: BlockType.HAT
                },
                {
                    opcode: 'whenJumped',
                    text: 'when jumped',
                    blockType: BlockType.HAT
                },
                {
                    opcode: 'displayText',
                    text: 'display [TEXT]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        TEXT: {
                            type: ArgumentType.STRING,
                            defaultValue: 'Hello!'
                        }
                    }
                },
                {
                    opcode: 'displaySymbol',
                    text: 'display [SYMBOL]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        SYMBOL: {
                            type: ArgumentType.STRING,
                            menu: 'symbols',
                            defaultValue: '❤'
                        }
                    }
                },
                {
                    opcode: 'displayMatrix',
                    text: 'set light x:[X] y:[Y] [STATE]',
                    blockType: BlockType.COMMAND,
                    arguments: {
                        X: {
                            type: ArgumentType.STRING,
                            menu: 'rowcol',
                            defaultValue: '1'
                        },
                        Y: {
                            type: ArgumentType.STRING,
                            menu: 'rowcol',
                            defaultValue: '1'
                        },
                        STATE: {
                            type: ArgumentType.STRING,
                            menu: 'pinState',
                            defaultValue: 'on'
                        }
                    }
                },
                {
                    opcode: 'displayClear',
                    text: 'set all lights off',
                    blockType: BlockType.COMMAND
                },
                {
                    opcode: 'whenTilted',
                    text: 'when tilted [DIRECTION]',
                    blockType: BlockType.HAT,
                    arguments: {
                        DIRECTION: {
                            type: ArgumentType.STRING,
                            menu: 'tiltDirectionAny',
                            defaultValue: TiltDirection.ANY
                        }
                    }
                },
                {
                    opcode: 'isTilted',
                    text: 'tilted [DIRECTION]?',
                    blockType: BlockType.BOOLEAN,
                    arguments: {
                        DIRECTION: {
                            type: ArgumentType.STRING,
                            menu: 'tiltDirectionAny',
                            defaultValue: TiltDirection.ANY
                        }
                    }
                },
                {
                    opcode: 'getTiltAngle',
                    text: 'tilt angle [DIRECTION]',
                    blockType: BlockType.REPORTER,
                    arguments: {
                        DIRECTION: {
                            type: ArgumentType.STRING,
                            menu: 'tiltDirection',
                            defaultValue: TiltDirection.FRONT
                        }
                    }
                },
                {
                    opcode: 'whenPinConnected',
                    text: 'when pin [PIN] connected',
                    blockType: BlockType.HAT,
                    arguments: {
                        PIN: {
                            type: ArgumentType.STRING,
                            menu: 'touchPins',
                            defaultValue: '0'
                        }
                    }
                }
            ],
            menus: {
                buttons: ['A', 'B', 'any'],
                rowcol: ['1', '2', '3', '4', '5'],
                pinState: ['on', 'off'],
                symbols: Object.keys(symbols2hex),
                tiltDirection: [TiltDirection.FRONT, TiltDirection.BACK, TiltDirection.LEFT, TiltDirection.RIGHT],
                tiltDirectionAny: [
                    TiltDirection.FRONT, TiltDirection.BACK, TiltDirection.LEFT,
                    TiltDirection.RIGHT, TiltDirection.ANY
                ],
                touchPins: ['0', '1', '2']
            }
        };
    }

    /**
     * Test whether the A or B button is pressed
     * @param {object} args - the block's arguments.
     * @return {boolean} - true if the button is pressed.
     */
    whenButtonPressed (args) {
        if (args.BTN === 'any') {
            return this._device.buttonA | this._device.buttonB;
        } else if (args.BTN === 'A') {
            return this._device.buttonA;
        } else if (args.BTN === 'B') {
            return this._device.buttonB;
        }
        return false;
    }

    /**
     * Test whether the micro:bit is moving
     * @return {boolean} - true if the micro:bit is moving.
     */
    whenMoved () {
        return (this._device.gestureState >> 2) & 1;
    }

    /**
     * Test whether the micro:bit is shaken
     * @return {boolean} - true if the micro:bit is shaken.
     */
    whenShaken () {
        return this._device.gestureState & 1;
    }

    /**
     * Test whether the micro:bit is free falling
     * @return {boolean} - true if the micro:bit is free falling.
     */
    whenJumped () {
        return (this._device.gestureState >> 1) & 1;
    }

    /**
     * Display text on the 5x5 LED matrix.
     * @param {object} args - the block's arguments.
     * @return {Promise} - a Promise that resolves when writing to device.
     * Note the limit is 19 characters
     */
    displayText (args) {
        const text = String(args.TEXT).substring(0, 19);
        return this._device.displayText(text);
    }

    /**
     * Display a predefined symbol on the 5x5 LED matrix.
     * @param {object} args - the block's arguments.
     * @return {Promise} - a Promise that resolves when writing to device.
     */
    displaySymbol (args) {
        const hex = symbols2hex[args.SYMBOL];
        if (!hex) return;
        this._device.ledMatrixState[0] = (hex >> 20) & 0x1F;
        this._device.ledMatrixState[1] = (hex >> 15) & 0x1F;
        this._device.ledMatrixState[2] = (hex >> 10) & 0x1F;
        this._device.ledMatrixState[3] = (hex >> 5) & 0x1F;
        this._device.ledMatrixState[4] = hex & 0x1F;
        return this._device.displayMatrix(this._device.ledMatrixState);
    }

    /**
     * Control individual LEDs on the 5x5 matrix.
     * @param {object} args - the block's arguments.
     */
    displayMatrix (args) {
        if (args.STATE === 'on') {
            this._device.ledMatrixState[args.Y - 1] |= 1 << 5 - args.X;
        } else if (args.STATE === 'off') {
            this._device.ledMatrixState[args.Y - 1] &= ~(1 << 5 - args.X);
        } else return;
        this._device.displayMatrix(this._device.ledMatrixState);
        return;
    }

    /**
     * Turn all 5x5 matrix LEDs off.
     */
    displayClear () {
        for (let i = 0; i < 5; i++) {
            this._device.ledMatrixState[i] = 0;
        }
        this._device.displayMatrix(this._device.ledMatrixState);
        return;
    }

    /**
     * Test whether the tilt sensor is currently tilted.
     * @param {object} args - the block's arguments.
     * @property {TiltDirection} DIRECTION - the tilt direction to test (front, back, left, right, or any).
     * @return {boolean} - true if the tilt sensor is tilted past a threshold in the specified direction.
     */
    whenTilted (args) {
        return this._isTilted(args.DIRECTION);
    }

    /**
     * Test whether the tilt sensor is currently tilted.
     * @param {object} args - the block's arguments.
     * @property {TiltDirection} DIRECTION - the tilt direction to test (front, back, left, right, or any).
     * @return {boolean} - true if the tilt sensor is tilted past a threshold in the specified direction.
     */
    isTilted (args) {
        return this._isTilted(args.DIRECTION);
    }

    /**
     * @param {object} args - the block's arguments.
     * @property {TiltDirection} DIRECTION - the direction (front, back, left, right) to check.
     * @return {number} - the tilt sensor's angle in the specified direction.
     * Note that getTiltAngle(front) = -getTiltAngle(back) and getTiltAngle(left) = -getTiltAngle(right).
     */
    getTiltAngle (args) {
        return this._getTiltAngle(args.DIRECTION);
    }

    /**
     * Test whether the tilt sensor is currently tilted.
     * @param {TiltDirection} direction - the tilt direction to test (front, back, left, right, or any).
     * @return {boolean} - true if the tilt sensor is tilted past a threshold in the specified direction.
     * @private
     */
    _isTilted (direction) {
        switch (direction) {
        case TiltDirection.ANY:
            return (Math.abs(this._device.tiltX / 10) >= Scratch3MicroBitBlocks.TILT_THRESHOLD) ||
                (Math.abs(this._device.tiltY / 10) >= Scratch3MicroBitBlocks.TILT_THRESHOLD);
        default:
            return this._getTiltAngle(direction) >= Scratch3MicroBitBlocks.TILT_THRESHOLD;
        }
    }

    /**
     * @param {TiltDirection} direction - the direction (front, back, left, right) to check.
     * @return {number} - the tilt sensor's angle in the specified direction.
     * Note that getTiltAngle(front) = -getTiltAngle(back) and getTiltAngle(left) = -getTiltAngle(right).
     * @private
     */
    _getTiltAngle (direction) {
        switch (direction) {
        case TiltDirection.FRONT:
            return Math.round(this._device.tiltY / -10);
        case TiltDirection.BACK:
            return Math.round(this._device.tiltY / 10);
        case TiltDirection.LEFT:
            return Math.round(this._device.tiltX / -10);
        case TiltDirection.RIGHT:
            return Math.round(this._device.tiltX / 10);
        default:
            log.warn(`Unknown tilt direction in _getTiltAngle: ${direction}`);
        }
    }

    /**
     * @param {object} args - the block's arguments.
     * @return {boolean} - the touch pin state.
     * @private
     */
    whenPinConnected (args) {
        const pin = parseInt(args.PIN, 10);
        if (isNaN(pin)) return;
        if (pin < 0 || pin > 2) return false;
        return this._device._checkPinState(pin);
    }
}

module.exports = Scratch3MicroBitBlocks;