pxt-microbit 4.1.36 → 4.1.39

package/built/common-sim.d.ts

@@ -728,6 +728,50 @@ declare namespace pxsim {
 }
 declare namespace pxsim.info {
 }
+declare namespace pxsim.keymap {
+    enum Key {
+        None = 0,
+        Left = 1,
+        Up = 2,
+        Right = 3,
+        Down = 4,
+        A = 5,
+        B = 6,
+        Menu = 7,
+        Screenshot = -1,
+        Gif = -2,
+        Reset = -3,
+        TogglePause = -4
+    }
+    function _setPlayerKeys(player: number, // player number is 1-based
+    up: number, down: number, left: number, right: number, A: number, B: number): void;
+    function _setSystemKeys(screenshot: number, gif: number, menu: number, reset: number): void;
+}
+declare namespace pxsim {
+    import Key = pxsim.keymap.Key;
+    interface KeymapBoard extends EventBusBoard {
+        keymapState: KeymapState;
+    }
+    function getKeymapState(): KeymapState;
+    class KeymapState {
+        keymap: {
+            [keyCode: number]: Key;
+        };
+        altmap: {
+            [keyCode: number]: Key;
+        };
+        mappings: {
+            [name: string]: number[];
+        };
+        constructor();
+        setPlayerKeys(player: number, // player number is 1-based
+        up: number, down: number, left: number, right: number, A: number, B: number): void;
+        setSystemKeys(screenshot: number, gif: number, menu: number, reset: number): void;
+        getKey(keyCode: number): Key;
+        private saveMap;
+        private clearMap;
+    }
+}
 declare namespace pxsim.multiplayer {
     function postImage(im: pxsim.RefImage, goal: string): void;
     function getCurrentImage(): pxsim.RefImage;

package/built/common-sim.js

@@ -2395,6 +2395,145 @@ var pxsim;
     pxsim.ToggleState = ToggleState;
 })(pxsim || (pxsim = {}));
 var pxsim;
+(function (pxsim) {
+    var keymap;
+    (function (keymap) {
+        // Keep in sync with pxt-arcade-sim/api.ts
+        let Key;
+        (function (Key) {
+            Key[Key["None"] = 0] = "None";
+            // Player 1
+            Key[Key["Left"] = 1] = "Left";
+            Key[Key["Up"] = 2] = "Up";
+            Key[Key["Right"] = 3] = "Right";
+            Key[Key["Down"] = 4] = "Down";
+            Key[Key["A"] = 5] = "A";
+            Key[Key["B"] = 6] = "B";
+            Key[Key["Menu"] = 7] = "Menu";
+            // Player 2 = Player 1 + 7
+            // Player 3 = Player 2 + 7
+            // Player 4 = Player 3 + 7
+            // system keys
+            Key[Key["Screenshot"] = -1] = "Screenshot";
+            Key[Key["Gif"] = -2] = "Gif";
+            Key[Key["Reset"] = -3] = "Reset";
+            Key[Key["TogglePause"] = -4] = "TogglePause";
+        })(Key = keymap.Key || (keymap.Key = {}));
+        function _setPlayerKeys(player, // player number is 1-based
+        up, down, left, right, A, B) {
+            pxsim.getKeymapState().setPlayerKeys(player, up, down, left, right, A, B);
+        }
+        keymap._setPlayerKeys = _setPlayerKeys;
+        function _setSystemKeys(screenshot, gif, menu, reset) {
+            pxsim.getKeymapState().setSystemKeys(screenshot, gif, menu, reset);
+        }
+        keymap._setSystemKeys = _setSystemKeys;
+    })(keymap = pxsim.keymap || (pxsim.keymap = {}));
+})(pxsim || (pxsim = {}));
+(function (pxsim) {
+    var Key = pxsim.keymap.Key;
+    function getKeymapState() {
+        return pxsim.board().keymapState;
+    }
+    pxsim.getKeymapState = getKeymapState;
+    const reservedKeyCodes = [
+        27,
+        9 // Tab
+    ];
+    class KeymapState {
+        constructor() {
+            this.keymap = {};
+            this.altmap = {};
+            this.mappings = {};
+            // Player 1 keymap
+            this.setPlayerKeys(1, // Player 1
+            87, // W - Up
+            83, // D - Down
+            65, // A - Left
+            83, // S - Right
+            32, // Space - A
+            13 // Enter - B
+            );
+            // Player 2 keymap
+            this.setPlayerKeys(2, // Player 2
+            73, // I - Up
+            75, // K - Down
+            74, // J - Left
+            75, // K - Right
+            85, // U - A
+            79 // O - B
+            );
+            // Note: Player 3 and 4 have no default keyboard mapping
+            // System keymap
+            this.setSystemKeys(80, // P - Screenshot
+            82, // R - Gif
+            0, // Menu - not mapped
+            0 // Reset - not mapped
+            );
+            // Player 1 alternate mapping. This is cleared when the game sets any player keys explicitly
+            this.altmap[38] = Key.Up; // UpArrow
+            this.altmap[37] = Key.Left; // LeftArrow
+            this.altmap[40] = Key.Down; // DownArrow
+            this.altmap[39] = Key.Right; // RightArrow
+            this.altmap[81] = Key.A; // Q
+            this.altmap[90] = Key.A; // Z
+            this.altmap[88] = Key.B; // X
+            this.altmap[69] = Key.B; // E
+        }
+        setPlayerKeys(player, // player number is 1-based
+        up, down, left, right, A, B) {
+            // We only support four players
+            if (player < 1 || player > 4)
+                return;
+            const keyCodes = [up, down, left, right, A, B];
+            // Check for reserved key codes
+            // TODO: How to surface this runtime error to the user?
+            // TODO: Send message to UI: "Keyboard mapping contains a reserved key code"
+            const filtered = keyCodes.filter(keyCode => reservedKeyCodes.includes(keyCode));
+            if (filtered.length)
+                return;
+            // Clear existing mapped keys for player
+            const mapName = `player-${player}`;
+            this.clearMap(mapName);
+            // Clear altmap When explicitly setting the player keys
+            this.altmap = {};
+            // Map the new keys
+            const offset = (player - 1) * 7; // +7 for player 2's keys
+            this.keymap[up] = Key.Up + offset;
+            this.keymap[down] = Key.Down + offset;
+            this.keymap[left] = Key.Left + offset;
+            this.keymap[right] = Key.Right + offset;
+            this.keymap[A] = Key.A + offset;
+            this.keymap[B] = Key.B + offset;
+            // Remember this mapping
+            this.saveMap(mapName, keyCodes);
+        }
+        setSystemKeys(screenshot, gif, menu, reset) {
+            const mapName = "system";
+            // Clear existing mapped keys for system
+            this.clearMap(mapName);
+            this.keymap[screenshot] = Key.Screenshot;
+            this.keymap[gif] = Key.Gif;
+            this.keymap[menu] = Key.Menu;
+            this.keymap[reset] = Key.Reset;
+            // Remember this mapping
+            this.saveMap(mapName, [screenshot, gif, menu, reset]);
+        }
+        getKey(keyCode) {
+            return keyCode ? this.keymap[keyCode] || this.altmap[keyCode] || Key.None : Key.None;
+        }
+        saveMap(name, keyCodes) {
+            this.mappings[name] = keyCodes;
+        }
+        clearMap(name) {
+            const keyCodes = this.mappings[name];
+            keyCodes === null || keyCodes === void 0 ? void 0 : keyCodes.forEach(keyCode => delete this.keymap[keyCode]);
+            delete this.mappings[name];
+        }
+    }
+    pxsim.KeymapState = KeymapState;
+})(pxsim || (pxsim = {}));
+var pxsim;
 (function (pxsim) {
     var multiplayer;
     (function (multiplayer) {

package/built/editor.js

@@ -3160,14 +3160,13 @@ function bufferConcat(a, b) {
 class DAPWrapper {
     constructor(io) {
         this.io = io;
-        this.flashing = false;
         this.flashAborted = false;
-        this.readSerialId = 0;
+        this.connectionId = 0;
         this.pbuf = new pxt.U.PromiseBuffer();
         this.pageSize = 1024;
         this.numPages = 256;
-        this.usesCODAL = false;
-        this.jacdacInHex = false;
+        // we don't know yet if jacdac was compiled in the hex
+        this.jacdacInHex = undefined;
         this.forceFullFlash = /webusbfullflash=1/.test(window.location.href);
         this.onSerial = (buf, isStderr) => { };
         this.onCustomEvent = (type, payload) => { };
@@ -3178,7 +3177,14 @@ class DAPWrapper {
         this.io.onDeviceConnectionChanged = (connect) => {
             log(`device connection changed`);
             this.disconnectAsync()
-                .then(() => connect && this.reconnectAsync());
+                .then(() => {
+                if (!connect)
+                    return;
+                // we don't know what's being connected
+                this.usesCODAL = undefined;
+                this.jacdacInHex = undefined;
+                this.reconnectAsync();
+            });
         };
         this.io.onData = buf => {
             // console.log("RD: " + pxt.Util.toHex(buf))
@@ -3186,9 +3192,6 @@ class DAPWrapper {
         };
         this.allocDAP();
     }
-    get useJACDAC() {
-        return this.jacdacInHex && this.usesCODAL;
-    }
     processSerialLine(line) {
         if (this.onSerial) {
             try {
@@ -3242,26 +3245,25 @@ class DAPWrapper {
         }
         return len;
     }
-    startReadSerial() {
-        const rid = this.readSerialId;
+    startReadSerial(connectionId) {
         const startTime = Date.now();
-        log(`start read serial ${rid}`);
+        log(`start read serial ${connectionId}`);
         const readSerialLoop = async () => {
             try {
-                while (rid === this.readSerialId) {
+                while (connectionId === this.connectionId) {
                     const len = await this.readSerial();
                     const hasData = len > 0;
                     //if (hasData)
                     //    logV(`serial read ${len} bytes`)
                     await this.jacdacProcess(hasData);
                 }
-                log(`stopped serial reader ${rid}`);
+                log(`stopped serial reader ${connectionId}`);
             }
             catch (err) {
-                log(`serial error ${rid}: ${err.message}`);
+                log(`serial error ${connectionId}: ${err.message}`);
                 console.error(err);
-                if (rid != this.readSerialId) {
-                    log(`stopped serial reader ${rid}`);
+                if (connectionId != this.connectionId) {
+                    log(`stopped serial reader ${connectionId}`);
                 }
                 else {
                     pxt.tickEvent("hid.flash.serial.error");
@@ -3277,9 +3279,9 @@ class DAPWrapper {
         };
         readSerialLoop();
     }
-    stopSerialAsync() {
-        log(`cancelling serial reader ${this.readSerialId}`);
-        this.readSerialId++;
+    stopReadersAsync() {
+        log(`cancelling connection ${this.connectionId}`);
+        this.connectionId++;
         return pxt.Util.delay(200);
     }
     allocDAP() {
@@ -3291,7 +3293,6 @@ class DAPWrapper {
             read: () => this.recvPacketAsync(),
             //sendMany: sendMany
         });
-        this.cmsisdap = this.dap.dap;
         this.cortexM = new DapJS.CortexM(this.dap);
     }
     get binName() {
@@ -3309,7 +3310,7 @@ class DAPWrapper {
         function stringResponse(buf) {
             return pxt.U.uint8ArrayToString(buf.slice(2, 2 + buf[1]));
         }
-        await this.stopSerialAsync();
+        await this.stopReadersAsync();
         this.allocDAP(); // clean dap apis
         await this.io.reconnectAsync();
         // before calling into dapjs, we use our dapCmdNums() a few times, which which will make sure the responses
@@ -3337,8 +3338,10 @@ class DAPWrapper {
         this.numPages = res[1];
         log(`page size ${this.pageSize}, num pages ${this.numPages}`);
         await this.checkStateAsync(true);
-        await this.jacdacSetup();
-        this.startReadSerial();
+        // start jacdac, serial async
+        const connectionId = this.connectionId;
+        this.startJacdacSetup(connectionId)
+            .then(() => this.startReadSerial(connectionId));
     }
     async checkStateAsync(resume) {
         const states = ["reset", "lockup", "sleeping", "halted", "running"];
@@ -3361,7 +3364,7 @@ class DAPWrapper {
     disconnectAsync() {
         log(`disconnect`);
         this.flashAborted = true;
-        return this.stopSerialAsync()
+        return this.stopReadersAsync()
             .then(() => this.io.disconnectAsync());
     }
     reflashAsync(resp) {
@@ -3369,13 +3372,12 @@ class DAPWrapper {
         pxt.tickEvent("hid.flash.start");
         log("reflash");
         startTime = 0;
-        const codalJson = resp.outfiles["codal.json"];
         // JACDAC_WEBUSB is defined in microsoft/pxt-jacdac/pxt.json
+        const codalJson = resp.outfiles["codal.json"];
         this.jacdacInHex = codalJson && !!((_b = (_a = pxt.Util.jsonTryParse(codalJson)) === null || _a === void 0 ? void 0 : _a.definitions) === null || _b === void 0 ? void 0 : _b.JACDAC_WEBUSB);
         this.flashAborted = false;
-        this.flashing = true;
         return (this.io.isConnected() ? Promise.resolve() : this.io.reconnectAsync())
-            .then(() => this.stopSerialAsync())
+            .then(() => this.stopReadersAsync())
             .then(() => this.cortexM.init())
             .then(() => this.cortexM.reset(true))
             .then(() => this.checkStateAsync())
@@ -3399,8 +3401,7 @@ class DAPWrapper {
             });
         })
             .then(() => this.checkStateAsync(true))
-            .then(() => pxt.tickEvent("hid.flash.success"))
-            .finally(() => { this.flashing = false; });
+            .then(() => pxt.tickEvent("hid.flash.success"));
         // don't disconnect here
         // the micro:bit will automatically disconnect and reconnect
         // via the webusb events
@@ -3691,76 +3692,88 @@ class DAPWrapper {
     writeWord(addr, val) {
         return this.cortexM.memory.write32(addr, val);
     }
-    async findJacdacXchgAddr() {
+    async findJacdacXchgAddr(cid) {
         const memStart = 536870912;
         const memStop = memStart + 128 * 1024;
-        const checkSize = 1024;
-        let p0 = 0x20006000;
-        let p1 = 0x20006000 + checkSize;
-        const check = async (addr) => {
-            if (addr < memStart)
-                return null;
-            if (addr + checkSize > memStop)
-                return null;
-            const buf = await this.readWords(addr, checkSize >> 2);
-            for (let i = 0; i < buf.length; ++i) {
-                if (buf[i] == 0x786D444A && buf[i + 1] == 0xB0A6C0E9)
-                    return addr + (i << 2);
-            }
-            return 0;
-        };
-        while (true) {
-            const a0 = await check(p0);
-            if (a0)
-                return a0;
-            const a1 = await check(p1);
-            if (a1)
-                return a1;
-            if (a0 === null && a1 === null)
-                return null;
-            p0 -= checkSize;
-            p1 += checkSize;
+        const addr = (await this.readWords(memStop - 4, 1))[0];
+        if (cid != this.connectionId)
+            return null;
+        if (memStart <= addr && addr < memStop) {
+            const buf = await this.readWords(addr, 2);
+            if (buf[0] == 0x786D444A && buf[1] == 0xB0A6C0E9)
+                return addr;
         }
+        return null;
     }
-    async jacdacSetup() {
+    /**
+     * Start trying to connect to Jacdac in the background
+     * and gracefull cancel as needed
+     * @returns
+     */
+    async startJacdacSetup(connectionId) {
         this.xchgAddr = null;
-        if (!this.useJACDAC) {
-            log(`jacdac: disabled`);
+        this.irqn = undefined;
+        this.lastXchg = undefined;
+        if (!this.usesCODAL) {
+            log(`jacdac: CODAL disabled`);
             return;
         }
-        // allow jacdac to boot
-        const now = pxt.U.now();
-        await pxt.Util.delay(1000);
-        let xchgRetry = 0;
-        let xchg;
-        while (xchg == null && xchgRetry++ < 2) {
-            log(`jacdac: finding xchg address (retry ${xchgRetry})`);
-            await pxt.Util.delay(100); // wait for the program to start and setup memory correctly
-            xchg = await this.findJacdacXchgAddr();
-        }
-        log(`jacdac: exchange address 0x${xchg ? xchg.toString(16) : "?"}; ${xchgRetry} retries; ${(pxt.U.now() - now) | 0}ms`);
-        if (xchg == null) {
-            log("jacdac: xchg address not found");
-            pxt.tickEvent("hid.flash.jacdac.error.missingxchg");
+        if (this.jacdacInHex === false) {
+            log(`jacdac: jacdac not compiled in`);
             return;
         }
-        const info = await this.readBytes(xchg, 16);
-        this.irqn = info[8];
-        if (info[12 + 2] != 0xff) {
-            log("jacdac: invalid memory; try power-cycling the micro:bit");
-            pxt.tickEvent("hid.flash.jacdac.error.invalidmemory");
-            console.debug({ info, xchg });
-            return;
+        try {
+            // allow jacdac to boot
+            const now = pxt.U.now();
+            await pxt.Util.delay(1000);
+            let xchgRetry = 0;
+            let xchg;
+            while (xchg == null && xchgRetry++ < 3) {
+                log(`jacdac: finding xchg address (retry ${xchgRetry})`);
+                await pxt.Util.delay(500); // wait for the program to start and setup memory correctly
+                if (connectionId != this.connectionId)
+                    return;
+                xchg = await this.findJacdacXchgAddr(connectionId);
+            }
+            log(`jacdac: exchange address 0x${xchg ? xchg.toString(16) : "?"}; ${xchgRetry} retries; ${(pxt.U.now() - now) | 0}ms`);
+            if (xchg == null) {
+                log("jacdac: xchg address not found");
+                this.jacdacInHex = false;
+                pxt.tickEvent("hid.flash.jacdac.error.missingxchg");
+                return;
+            }
+            if (connectionId != this.connectionId)
+                return;
+            const info = await this.readBytes(xchg, 16);
+            if (info[12 + 2] != 0xff) {
+                log("jacdac: invalid memory; try power-cycling the micro:bit");
+                pxt.tickEvent("hid.flash.jacdac.error.invalidmemory");
+                console.debug({ info, xchg });
+                return;
+            }
+            // make sure connection is not outdated
+            if (connectionId != this.connectionId)
+                return;
+            // clear initial lock
+            await this.writeWord(xchg + 12, 0);
+            // allow serial thread to use jacdac
+            this.irqn = info[8];
+            this.xchgAddr = xchg;
+            log(`jacdac: exchange address 0x${this.xchgAddr.toString(16)}; irqn=${this.irqn}`);
+            pxt.tickEvent("hid.flash.jacdac.connected");
+        }
+        catch (e) {
+            if (connectionId != this.connectionId) {
+                log(`jacdac: setup aborted`);
+                return;
+            }
+            else
+                throw e;
         }
-        this.xchgAddr = xchg;
-        // clear initial lock
-        await this.writeWord(xchg + 12, 0);
-        log(`jacdac: exchange address 0x${xchg.toString(16)}; irqn=${this.irqn}`);
-        pxt.tickEvent("hid.flash.jacdac.connected");
     }
-    async triggerIRQ(irqn) {
-        const addr = 0xE000E200 + (irqn >> 5) * 4;
-        await this.writeWord(addr, 1 << (irqn & 31));
+    async triggerIRQ() {
+        const addr = 0xE000E200 + (this.irqn >> 5) * 4;
+        await this.writeWord(addr, 1 << (this.irqn & 31));
     }
     async jacdacProcess(hadSerial) {
         if (this.xchgAddr == null) {
@@ -3778,7 +3791,7 @@ class DAPWrapper {
         let inp = await this.readBytes(this.xchgAddr + 12, 256);
         if (inp[2]) {
             await this.writeWord(this.xchgAddr + 12, 0);
-            await this.triggerIRQ(this.irqn);
+            await this.triggerIRQ();
             inp = inp.slice(0, inp[2] + 12);
             this.onCustomEvent("jacdac", inp);
             numev++;
@@ -3805,7 +3818,7 @@ class DAPWrapper {
                 await this.writeWords(this.xchgAddr + 12 + 256 + 4, new Uint32Array(bbody.buffer));
                 const bhead = this.currSend.buf.slice(0, 4);
                 await this.writeWords(this.xchgAddr + 12 + 256, new Uint32Array(bhead.buffer));
-                await this.triggerIRQ(this.irqn);
+                await this.triggerIRQ();
                 this.lastSend = Date.now();
                 numev++;
             }

package/built/sim.d.ts

@@ -585,6 +585,7 @@ declare namespace pxsim.serial {
     function setTxBufferSize(size: number): void;
     function readBuffer(length: number): RefBuffer;
     function setBaudRate(rate: number): void;
+    function writeDmesg(): void;
 }
 declare namespace pxsim.music {
     function __playSoundExpression(notes: string, waitTillDone: boolean): void;

package/built/sim.js

@@ -2359,6 +2359,10 @@ var pxsim;
             // TODO
         }
         serial.setBaudRate = setBaudRate;
+        function writeDmesg() {
+            // TODO
+        }
+        serial.writeDmesg = writeDmesg;
     })(serial = pxsim.serial || (pxsim.serial = {}));
 })(pxsim || (pxsim = {}));
 var pxsim;