1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// https://github.com/scratchfoundation/scratch-vm/blob/v2.1.16/src/extensions/scratch3_microbit/index.js#L53

/**
 * Enum for micro:bit protocol.
 * https://github.com/scratchfoundation/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'
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

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

...

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

...


/**
     * Send a message to the peripheral BLE socket.
     * @param {number} command - the BLE command hex.
     * @param {Uint8Array} message - the message to write
     */
send(command, message) {
    if (!this.isConnected()) return;
    if (this._busy) return;

    // Set a busy flag so that while we are sending a message and waiting for
    // the response, additional messages are ignored.
    this._busy = true;

    // Set a timeout after which to reset the busy flag. This is used in case
    // a BLE message was sent for which we never received a response, because
    // e.g. the peripheral was turned off after the message was sent. We reset
    // the busy flag after a while so that it is possible to try again later.
    this._busyTimeoutID = window.setTimeout(() => {
        this._busy = false;
    }, 5000);

    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);

    this._ble.write(BLEUUID.service, BLEUUID.txChar, data, 'base64', true).then(
        () => {
            this._busy = false;
            window.clearTimeout(this._busyTimeoutID);
        }
    );
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/**
 * Process the sensor data from the incoming BLE characteristic.
 * @param {object} base64 - the incoming BLE data.
 * @private
 */
_onMessage(base64) {
    // parse data
    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];

    // cancel disconnect timeout and start a new one
    window.clearTimeout(this._timeoutID);
    this._timeoutID = window.setTimeout(
        () => this._ble.handleDisconnectError(BLEDataStoppedError),
        BLETimeout
    );
}

...

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