Bump pxt 12.x and some other changes

editor/deploy.ts

@@ -14,6 +14,7 @@ export function debug() {
 }
 
 // Web Serial API https://wicg.github.io/serial/
+// https://www.npmjs.com/package/@types/web-bluetooth
 // chromium bug https://bugs.chromium.org/p/chromium/issues/detail?id=884928
 // Under experimental features in Chrome Desktop 77+
 enum ParityType {
@@ -23,6 +24,7 @@ enum ParityType {
     "mark",
     "space"
 }
+
 declare interface SerialOptions {
     baudRate?: number;
     databits?: number;
@@ -34,15 +36,18 @@ declare interface SerialOptions {
     xoff?: boolean;
     xany?: boolean;
 }
+
 type SerialPortInfo = pxt.Map<string>;
 type SerialPortRequestOptions = any;
+
 declare class SerialPort {
     open(options?: SerialOptions): Promise<void>;
     close(): void;
     readonly readable: any;
     readonly writable: any;
-    //getInfo(): SerialPortInfo;
+    // getInfo(): SerialPortInfo;
 }
+
 declare interface Serial extends EventTarget {
     onconnect: any;
     ondisconnect: any;
@@ -60,29 +65,40 @@ class WebSerialPackageIO implements pxt.packetio.PacketIO {
     private _writer: any;
 
     constructor(private port: SerialPort, private options: SerialOptions) {
-        console.log(`serial: new io`)
+        console.log(`serial: New io`)
+    }
+
+    bufferSize(buffer: Uint8Array) {
+        return HF2.read16(buffer, 0) + 2;
     }
 
     async readSerialAsync() {
         this._reader = this.port.readable.getReader();
         let buffer: Uint8Array;
         const reader = this._reader;
         while (reader === this._reader) { // will change if we recycle the connection
-            const { done, value } = await this._reader.read()
+            const { done, value } = await this._reader.read();
             if (!buffer) buffer = value;
             else { // concat
-                let tmp = new Uint8Array(buffer.length + value.byteLength)
-                tmp.set(buffer, 0)
-                tmp.set(value, buffer.length)
+                let tmp = new Uint8Array(buffer.length + value.byteLength);
+                tmp.set(buffer, 0);
+                tmp.set(value, buffer.length);
                 buffer = tmp;
             }
             if (buffer) {
-                let size = HF2.read16(buffer, 0);
-                if (buffer.length == size + 2) {
+                let size = this.bufferSize(buffer);
+                if (buffer.length == size) {
                     this.onData(new Uint8Array(buffer));
                     buffer = undefined;
+                } else if (buffer.length > size) {
+                    console.warn(`Received larger buffer than command command: ${buffer.length} received but waiting for ${size}`);
+                    let tmp = buffer.slice(0, size - 1);
+                    this.onData(new Uint8Array(tmp));
+                    tmp = buffer.slice(size, buffer.length - 1);
+                    buffer = tmp;
+                    console.debug(`Next buffer size: ${this.bufferSize(buffer)}`);
                 } else {
-                    console.warn("Incomplete command " + size);
+                    console.warn(`Incomplete command: ${buffer.length} received but waiting for ${size}. Keep waiting...`);
                 }
             }
         }
@@ -93,11 +109,14 @@ class WebSerialPackageIO implements pxt.packetio.PacketIO {
     }
 
     static portIos: WebSerialPackageIO[] = [];
+
     static async mkPacketIOAsync(): Promise<pxt.packetio.PacketIO> {
         const serial = (<any>navigator).serial;
         if (serial) {
             try {
-                const requestOptions: SerialPortRequestOptions = {};
+                const requestOptions: SerialPortRequestOptions = {
+                    // filters: [{ usbVendorId: 0x0694, usbProductId: 0x0005 }],
+                };
                 const port = await serial.requestPort(requestOptions);
 
                 let io = WebSerialPackageIO.portIos.filter(i => i.port == port)[0];
@@ -111,7 +130,7 @@ class WebSerialPackageIO implements pxt.packetio.PacketIO {
                 }
                 return io;
             } catch (e) {
-                console.log(`connection error`, e)
+                console.log(`Connection error`, e)
             }
         }
         throw new Error("could not open serial port");
@@ -123,7 +142,8 @@ class WebSerialPackageIO implements pxt.packetio.PacketIO {
     }
 
     private openAsync() {
-        console.log(`serial: opening port`)
+        console.log(`serial: Opening port`);
+        // this.io.onConnectionChanged();
         if (!!this._reader) return Promise.resolve();
         this._reader = undefined;
         this._writer = undefined;
@@ -189,6 +209,7 @@ function hf2Async() {
 
 let useHID = false;
 let useWebSerial = false;
+
 export function initAsync(): Promise<void> {
     if (pxt.U.isNodeJS) {
         // doesn't seem to work ATM
@@ -234,6 +255,7 @@ async function cleanupAsync() {
 }
 
 let initPromise: Promise<Ev3Wrapper>
+
 function initHidAsync() { // needs to run within a click handler
     if (initPromise)
         return initPromise
@@ -261,6 +283,7 @@ const rbfTemplate = `
 4c45474f580000006d000100000000001c000000000000000e000000821b038405018130813e8053
 74617274696e672e2e2e0084006080XX00448581644886488405018130813e80427965210084000a
 `
+
 export function deployCoreAsync(resp: pxtc.CompileResult) {
     let filename = resp.downloadFileBaseName || "pxt"
     filename = filename.replace(/^lego-/, "")

editor/extension.ts

@@ -1,5 +1,4 @@
 /// <reference path="../node_modules/pxt-core/localtypings/pxtarget.d.ts" />
-/// <reference path="../node_modules/pxt-core/built/pxtblocks.d.ts" />
 /// <reference path="../node_modules/pxt-core/built/pxtcompiler.d.ts" />
 /// <reference path="../node_modules/pxt-core/built/pxtlib.d.ts" />
 /// <reference path="../node_modules/pxt-core/localtypings/pxteditor.d.ts"/>

editor/wrap.ts

@@ -110,14 +110,112 @@ export class Ev3Wrapper {
         })
     }
 
+    dumpInputCmd(buf : Uint8Array) {
+        log(`Reply size: ${HF2.read16(buf, 0)}, Message counter: ${HF2.read16(buf, 2)}, Reply type: ${buf[4]} (${buf[4] === 0x03 ? "System command reply OK" : buf[4] === 0x05 ? "System command reply ERROR" : "Unknown"})`);
+        switch (buf[6]) {
+            case 0x00:
+                log("Reply Status SUCCESS");
+                break;
+            case 0x01:
+                log("Reply Status UNKNOWN_HANDLE");
+                break;
+            case 0x02:
+                log("Reply Status HANDLE_NOT_READY");
+                break;
+            case 0x03:
+                log("Reply Status CORRUPT_FILE");
+                break;
+            case 0x04:
+                log("Reply Status NO_HANDLES_AVAILABLE");
+                break;
+            case 0x05:
+                log("Reply Status NO_PERMISSION");
+                break;
+            case 0x06:
+                log("Reply Status ILLEGAL_PATH");
+                break;
+            case 0x07:
+                log("Reply Status FILE_EXITS");
+                break;
+            case 0x08:
+                log("Reply Status END_OF_FILE");
+                break;
+            case 0x09:
+                log("Reply Status SIZE_ERROR");
+                break;
+            case 0x0A:
+                log("Reply Status UNKNOWN_ERROR");
+                break;
+            case 0x0B:
+                log("Reply Status ILLEGAL_FILENAME");
+                break;
+            case 0x0C:
+                log("Reply Status ILLEGAL_CONNECTION");
+                break;
+        }
+    }
+
+    dumpOutputCmd(buf: Uint8Array) {
+        log(`Command size: ${HF2.read16(buf, 0)}, Message counter: ${HF2.read16(buf, 2)}, Command type: ${buf[4]} (${buf[4] === 0x01 ? "System command, reply required" : buf[4] === 0x81 ? "System command, reply not required" : "Unknown"})`);
+        switch (buf[5]) {
+            case 0x92:
+                log("System command: Begin file download");
+                break;
+            case 0x93:
+                log("System command: Continue file download");
+                break;
+            case 0x94:
+                log("System command: Begin file upload");
+                break;
+            case 0x95:
+                log("System command: Continue file upload");
+                break;
+            case 0x96:
+                log("System command: Begin get bytes from a file (while writing to the file)");
+                break;
+            case 0x97:
+                log("System command: Continue get byte from a file (while writing to the file)");
+                break;
+            case 0x98:
+                log("System command: Close file handle");
+                break;
+            case 0x99:
+                log("System command: List files");
+                break;
+            case 0x9A:
+                log("System command: Continue list files");
+                break;
+            case 0x9B:
+                log("System command: Create directory");
+                break;
+            case 0x9C:
+                log("System command: Delete");
+                break;
+            case 0x9D:
+                log("System command: List handles");
+                break;
+            case 0x9E:
+                log("System command: Write to mailbox");
+                break;
+            case 0x9F:
+                log("System command: Transfer trusted pin code to brick");
+                break;
+            case 0xA0:
+                log("System command: Restart the brick in Firmware update mode");
+                break;
+        }
+    }
+
     talkAsync(buf: Uint8Array, altResponse = 0) {
         return this.lock.enqueue("talk", () => {
             this.msgs.drain()
             if (this.dataDump)
                 log("TALK: " + U.toHex(buf))
+            this.dumpOutputCmd(buf)
             return this.io.sendPacketAsync(buf)
                 .then(() => this.msgs.shiftAsync(5000))
                 .then(resp => {
+                    this.dumpInputCmd(resp)
                     if (resp[2] != buf[2] || resp[3] != buf[3])
                         U.userError("msg count de-sync")
                     if (buf[4] == 1) {
@@ -132,7 +230,7 @@ export class Ev3Wrapper {
     }
 
     flashAsync(path: string, file: Uint8Array) {
-        log(`write ${file.length} bytes to ${path}`)
+        log(`Write ${file.length} bytes to ${path}`)
 
         let handle = -1
 
@@ -274,13 +372,13 @@ export class Ev3Wrapper {
     reconnectAsync(first = false): Promise<void> {
         this.resetState()
         if (first) return this.initAsync()
-        log(`reconnect`);
+        log(`Reconnect`);
         return this.io.reconnectAsync()
             .then(() => this.initAsync())
     }
 
     disconnectAsync() {
-        log(`disconnect`);
+        log(`Disconnect`);
         return this.io.disconnectAsync()
     }
 }

fieldeditors/extension.ts

@@ -1,20 +1,18 @@
 /// <reference path="../node_modules/pxt-core/localtypings/pxteditor.d.ts"/>
 /// <reference path="../node_modules/pxt-core/built/pxtsim.d.ts"/>
 
-import { FieldPorts } from "./field_ports";
+const Blockly = pxt.blocks.requireBlockly();
+
 import { FieldMotors } from "./field_motors";
 import { FieldBrickButtons } from "./field_brickbuttons";
 import { FieldColorEnum } from "./field_color";
 import { FieldMusic } from "./field_music";
 
 pxt.editor.initFieldExtensionsAsync = function (opts: pxt.editor.FieldExtensionOptions): Promise<pxt.editor.FieldExtensionResult> {
-    pxt.debug('loading pxt-ev3 target extensions...')
+    pxt.debug('loading pxt-ev3 target extensions...');
     updateBlocklyShape();
     const res: pxt.editor.FieldExtensionResult = {
         fieldEditors: [{
-            selector: "ports",
-            editor: FieldPorts
-        }, {
             selector: "motors",
             editor: FieldMotors
         }, {
@@ -132,10 +130,4 @@ function updateBlocklyShape() {
      */
     (Blockly as any).Flyout.prototype.MARGIN = 8;
 
-}
-
-// When require()d from node, bind the global pxt namespace
-// namespace pxt {
-//     export const dummyExport = 1;
-// }
-// eval("if (typeof process === 'object' && process + '' === '[object process]') pxt = global.pxt")
+}