pxt-microbit 4.1.5 → 4.1.9

package/built/common-sim.d.ts

@@ -1007,6 +1007,8 @@ declare namespace pxsim.ImageMethods {
     function _fillCircle(img: RefImage, cxy: number, r: number, c: number): void;
     function _blitRow(img: RefImage, xy: number, from: RefImage, xh: number): void;
     function blitRow(img: RefImage, x: number, y: number, from: RefImage, fromX: number, fromH: number): void;
+    function _blit(img: RefImage, src: RefImage, args: RefCollection): void;
+    function blit(dst: RefImage, src: RefImage, args: RefCollection): void;
 }
 declare namespace pxsim.image {
     function byteHeight(h: number, bpp: number): number;
@@ -1075,8 +1077,8 @@ declare namespace pxsim.visuals {
     }
 }
 declare namespace pxsim.settings {
-    function _set(key: string, buf: RefBuffer): 0 | -1;
-    function _remove(key: string): 0 | -1;
+    function _set(key: string, buf: RefBuffer): -1 | 0;
+    function _remove(key: string): -1 | 0;
     function _exists(key: string): boolean;
     function _get(key: string): RefBuffer;
     function _userClean(): void;
@@ -1179,3 +1181,54 @@ declare namespace pxsim.TouchButtonMethods {
 declare namespace pxsim.AnalogInOutPinMethods {
     function touchButton(name: pins.AnalogInOutPin): TouchButton;
 }
+declare namespace pxsim {
+    interface WifiSocketBoard extends CommonBoard {
+        wifiSocketState: WifiSocketState;
+    }
+    class WifiSocket {
+        private fd;
+        ws: WebSocket;
+        _err: number;
+        buffers: Uint8Array[];
+        readers: (() => void)[];
+        bytesAvail: number;
+        reqInit: RequestInit;
+        reqUrl: string;
+        reqSent: boolean;
+        constructor(fd: number);
+        openReq(host: string, port: number): Promise<number>;
+        _queue(data: string | Uint8Array | ArrayBuffer): void;
+        openWS(url: string, proto: string[]): Promise<number>;
+        waitRead(): Promise<void>;
+        read(maxlen: number): number | RefBuffer;
+        private handleFetch;
+        write(buf: RefBuffer): Promise<number>;
+        close(): void;
+    }
+    class WifiSocketState {
+        sockets: WifiSocket[];
+    }
+}
+declare namespace pxsim._wifi {
+    type int32 = number;
+    export function _allowed(): boolean;
+    export function socketAlloc(): int32;
+    export function socketConnectTLS(fd: int32, host: string, port: int32): Promise<int32>;
+    export function socketWrite(fd: int32, data: RefBuffer): Promise<int32>;
+    export function socketRead(fd: int32, size: int32): Promise<number | RefBuffer>;
+    export function socketBytesAvailable(fd: int32): int32;
+    export function socketClose(fd: int32): int32;
+    export function eventID(): int32;
+    export function scanStart(): void;
+    export function scanResults(): RefBuffer;
+    export function connect(ssid: string, pass: string): int32;
+    export function disconnect(): int32;
+    export function isConnected(): boolean;
+    export function ipInfo(): RefBuffer;
+    export function rssi(): number;
+    export function _raiseEvent(id: number): void;
+    export {};
+}
+declare namespace pxsim.crypto {
+    function _sha256(bufs: RefCollection): Promise<RefBuffer>;
+}

package/built/common-sim.js

@@ -604,22 +604,20 @@ var pxsim;
         }
         control.profilingEnabled = profilingEnabled;
         function __log(priority, str) {
-            let prefix = "";
             switch (priority) {
                 case 0:
-                    prefix = "d>";
+                    console.debug("d>" + str);
                     break;
                 case 1:
-                    prefix = "l>";
+                    console.log("l>" + str);
                     break;
                 case 2:
-                    prefix = "w>";
+                    console.warn("w>" + str);
                     break;
                 case 3:
-                    prefix = "e>";
+                    console.error("e>" + str);
                     break;
             }
-            console.log(prefix + str);
             pxsim.runtime.board.writeSerial(str);
         }
         control.__log = __log;
@@ -3906,6 +3904,44 @@ var pxsim;
             }
         }
         ImageMethods.blitRow = blitRow;
+        function _blit(img, src, args) {
+            blit(img, src, args);
+        }
+        ImageMethods._blit = _blit;
+        function blit(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            const wDst = args.getAt(2);
+            const hDst = args.getAt(3);
+            const xSrc = args.getAt(4);
+            const ySrc = args.getAt(5);
+            const wSrc = args.getAt(6);
+            const hSrc = args.getAt(7);
+            const transparent = args.getAt(8);
+            const xSrcStep = ((wSrc << 16) / wDst) | 0;
+            const ySrcStep = ((hSrc << 16) / hDst) | 0;
+            const xDstClip = Math.abs(Math.min(0, xDst));
+            const yDstClip = Math.abs(Math.min(0, yDst));
+            const xDstStart = xDst + xDstClip;
+            const yDstStart = yDst + yDstClip;
+            const xDstEnd = Math.min(dst._width, xDst + wDst);
+            const yDstEnd = Math.min(dst._height, yDst + hDst);
+            const xSrcStart = Math.max(0, (xSrc << 16) + xDstClip * xSrcStep);
+            const ySrcStart = Math.max(0, (ySrc << 16) + yDstClip * ySrcStep);
+            const xSrcEnd = Math.min(src._width, xSrc + wSrc) << 16;
+            const ySrcEnd = Math.min(src._height, ySrc + hSrc) << 16;
+            for (let yDstCur = yDstStart, ySrcCur = ySrcStart; yDstCur < yDstEnd && ySrcCur < ySrcEnd; ++yDstCur, ySrcCur += ySrcStep) {
+                const ySrcCurI = ySrcCur >> 16;
+                for (let xDstCur = xDstStart, xSrcCur = xSrcStart; xDstCur < xDstEnd && xSrcCur < xSrcEnd; ++xDstCur, xSrcCur += xSrcStep) {
+                    const xSrcCurI = xSrcCur >> 16;
+                    const cSrc = getPixel(src, xSrcCurI, ySrcCurI);
+                    if (!transparent || cSrc) {
+                        setPixel(dst, xDstCur, yDstCur, cSrc);
+                    }
+                }
+            }
+        }
+        ImageMethods.blit = blit;
     })(ImageMethods = pxsim.ImageMethods || (pxsim.ImageMethods = {}));
 })(pxsim || (pxsim = {}));
 (function (pxsim) {
@@ -4689,3 +4725,299 @@ var pxsim;
         AnalogInOutPinMethods.touchButton = touchButton;
     })(AnalogInOutPinMethods = pxsim.AnalogInOutPinMethods || (pxsim.AnalogInOutPinMethods = {}));
 })(pxsim || (pxsim = {}));
+var pxsim;
+(function (pxsim) {
+    class WifiSocket {
+        constructor(fd) {
+            this.fd = fd;
+            this.buffers = [];
+            this.readers = [];
+            this.bytesAvail = 0;
+            this.reqInit = {
+                headers: {},
+                credentials: "omit",
+                mode: "cors",
+                cache: "no-cache",
+                redirect: "manual",
+                referrer: "",
+            };
+            this.reqSent = false;
+        }
+        async openReq(host, port) {
+            if (!/^[\w\-\.]+$/.test(host))
+                throw new Error("bad host");
+            this.reqUrl = "https://" + host + ":" + port + "/";
+            return 0;
+        }
+        _queue(data) {
+            let buf;
+            if (data instanceof ArrayBuffer)
+                buf = new Uint8Array(data);
+            else if (data instanceof Uint8Array)
+                buf = data;
+            else
+                buf = pxsim.U.stringToUint8Array(pxsim.U.toUTF8(data));
+            this.buffers.push(buf);
+            if (buf.length && this.bytesAvail == 0)
+                pxsim._wifi._raiseEvent(1000 + this.fd);
+            this.bytesAvail += buf.length;
+            const rr = this.readers;
+            this.readers = [];
+            for (const r of rr)
+                r();
+        }
+        openWS(url, proto) {
+            this.ws = new WebSocket(url, proto);
+            this.ws.binaryType = "arraybuffer";
+            return new Promise((resolve) => {
+                this.ws.onopen = () => {
+                    this.ws.onerror = err => {
+                        console.log("ws error", err);
+                        this._err = -2;
+                    };
+                    resolve(0);
+                };
+                this.ws.onclose = () => {
+                    console.log("ws close");
+                    this._err = -20;
+                };
+                this.ws.onmessage = ev => {
+                    this._queue(ev.data);
+                };
+                this.ws.onerror = () => resolve(-1);
+            });
+        }
+        waitRead() {
+            return new Promise(resolve => {
+                this.readers.push(resolve);
+            });
+        }
+        read(maxlen) {
+            if (this._err)
+                return this._err;
+            let b = this.buffers[0];
+            if (b) {
+                if (b.length <= maxlen) {
+                    this.buffers.shift();
+                }
+                else {
+                    this.buffers[0] = b.slice(maxlen);
+                    b = b.slice(0, maxlen);
+                }
+                this.bytesAvail -= b.length;
+                return new pxsim.RefBuffer(b);
+            }
+            return null;
+        }
+        async handleFetch() {
+            // we ignore post for now
+            this.reqSent = true;
+            const resp = await fetch(this.reqUrl, this.reqInit);
+            this._queue(`HTTP/1.1 ${resp.status} ${resp.statusText}\r\n`);
+            resp.headers.forEach((v, k) => {
+                if (k.toLowerCase() == "content-length")
+                    return;
+                this._queue(`${k}: ${v}\r\n`);
+            });
+            const data = await resp.arrayBuffer();
+            this._queue(`Content-Length: ${data.byteLength}\r\n`);
+            this._queue(`\r\n`);
+            this._queue(data);
+            return 0;
+        }
+        async write(buf) {
+            if (this._err)
+                return this._err;
+            if (this.ws)
+                this.ws.send(buf.data);
+            else {
+                if (this.reqSent)
+                    return -2;
+                let str = pxsim.U.fromUTF8(pxsim.U.uint8ArrayToString(buf.data));
+                if (str == "\r\n") {
+                    const dummy = this.handleFetch();
+                    return 0;
+                }
+                str = str.replace(/\r?\n$/, "");
+                if (!this.reqInit.method) {
+                    const m = /^\s*(\S+)\s+\/(\S+)/.exec(str);
+                    if (m) {
+                        this.reqInit.method = m[1];
+                        this.reqUrl += m[2];
+                    }
+                }
+                else {
+                    const m = /^([^:]+):\s*(.*)/.exec(str);
+                    if (m) {
+                        this.reqInit.headers[m[1]] = m[2];
+                    }
+                }
+            }
+            return 0;
+        }
+        close() {
+            if (this.ws)
+                this.ws.close();
+        }
+    }
+    pxsim.WifiSocket = WifiSocket;
+    class WifiSocketState {
+        constructor() {
+            this.sockets = [null];
+        }
+    }
+    pxsim.WifiSocketState = WifiSocketState;
+})(pxsim || (pxsim = {}));
+(function (pxsim) {
+    var _wifi;
+    (function (_wifi) {
+        const MAX_SOCKET = 16;
+        const WIFI_ID = 1234;
+        function _allowed() {
+            var _a, _b, _c;
+            const bid = (_c = (_b = (_a = pxsim.board()) === null || _a === void 0 ? void 0 : _a.runOptions) === null || _b === void 0 ? void 0 : _b.boardDefinition) === null || _c === void 0 ? void 0 : _c.id;
+            return /esp32|-s2/.test(bid);
+        }
+        _wifi._allowed = _allowed;
+        function getState() {
+            const b = pxsim.board();
+            if (!b.wifiSocketState) {
+                if (!_allowed())
+                    throw new Error("_wifi not enabled");
+                b.wifiSocketState = new pxsim.WifiSocketState();
+            }
+            return b.wifiSocketState;
+        }
+        function getSock(fd) {
+            if (fd < 0 || fd >= MAX_SOCKET)
+                return null;
+            return getState().sockets[fd];
+        }
+        function socketAlloc() {
+            const state = getState();
+            for (let i = 1; i < state.sockets.length; ++i) {
+                if (!state.sockets[i]) {
+                    state.sockets[i] = new pxsim.WifiSocket(i);
+                    return i;
+                }
+            }
+            const idx = state.sockets.length;
+            if (idx > MAX_SOCKET)
+                return -1;
+            state.sockets.push(new pxsim.WifiSocket(idx));
+            return idx;
+        }
+        _wifi.socketAlloc = socketAlloc;
+        function socketConnectTLS(fd, host, port) {
+            const sock = getSock(fd);
+            if (!sock)
+                return Promise.resolve(-11);
+            // TODO loosen this up in future
+            if (port == 8883 && /\.azure-devices.net$/.test(host)) {
+                return sock.openWS("wss://" + host + "/$iothub/websocket?iothub-no-client-cert=true", ["mqtt"]);
+            }
+            else if (port == 443 && host == "microsoft.github.io") {
+                return sock.openReq(host, port);
+            }
+            else {
+                console.log("invalid host: " + host);
+                return Promise.resolve(-1);
+            }
+        }
+        _wifi.socketConnectTLS = socketConnectTLS;
+        async function socketWrite(fd, data) {
+            const sock = getSock(fd);
+            if (!sock)
+                return -11;
+            return sock.write(data);
+        }
+        _wifi.socketWrite = socketWrite;
+        async function socketRead(fd, size) {
+            const sock = getSock(fd);
+            if (!sock)
+                return -11;
+            for (;;) {
+                const buf = sock.read(size);
+                if (buf)
+                    return buf;
+                await sock.waitRead();
+            }
+        }
+        _wifi.socketRead = socketRead;
+        function socketBytesAvailable(fd) {
+            const sock = getSock(fd);
+            if (!sock)
+                return -11;
+            return sock.bytesAvail;
+        }
+        _wifi.socketBytesAvailable = socketBytesAvailable;
+        function socketClose(fd) {
+            const sock = getSock(fd);
+            if (!sock)
+                return -11;
+            sock.close();
+            return 0;
+        }
+        _wifi.socketClose = socketClose;
+        function eventID() {
+            return WIFI_ID;
+        }
+        _wifi.eventID = eventID;
+        function scanStart() {
+            _raiseEvent(1 /* ScanDone */);
+        }
+        _wifi.scanStart = scanStart;
+        function scanResults() {
+            const b = new Uint8Array(7);
+            b[0] = -20; // rssi
+            b[1] = 0; // authmode
+            b.set(pxsim.U.stringToUint8Array("WiFi"), 2);
+            return new pxsim.RefBuffer(b);
+        }
+        _wifi.scanResults = scanResults;
+        function connect(ssid, pass) {
+            _raiseEvent(2 /* GotIP */);
+            return 0;
+        }
+        _wifi.connect = connect;
+        function disconnect() {
+            return 0;
+        }
+        _wifi.disconnect = disconnect;
+        function isConnected() { return true; }
+        _wifi.isConnected = isConnected;
+        function ipInfo() { return new pxsim.RefBuffer(new Uint8Array(4 * 3)); }
+        _wifi.ipInfo = ipInfo;
+        function rssi() { return -24; }
+        _wifi.rssi = rssi;
+        function _raiseEvent(id) {
+            pxsim.control.raiseEvent(_wifi.eventID(), id, undefined);
+        }
+        _wifi._raiseEvent = _raiseEvent;
+    })(_wifi = pxsim._wifi || (pxsim._wifi = {}));
+})(pxsim || (pxsim = {}));
+(function (pxsim) {
+    var crypto;
+    (function (crypto) {
+        function _sha256(bufs) {
+            var _a, _b;
+            let len = 0;
+            const buffers = bufs.toArray().filter(e => e instanceof pxsim.RefBuffer).map((b) => {
+                len += b.data.length;
+                return b.data;
+            });
+            const concat = new Uint8Array(len);
+            len = 0;
+            for (const b of buffers) {
+                concat.set(b, len);
+                len += b.length;
+            }
+            const r = (_b = (_a = window === null || window === void 0 ? void 0 : window.crypto) === null || _a === void 0 ? void 0 : _a.subtle) === null || _b === void 0 ? void 0 : _b.digest("SHA-256", concat);
+            if (r)
+                return r.then(buf => new pxsim.RefBuffer(new Uint8Array(buf)));
+            else
+                return Promise.resolve(undefined);
+        }
+        crypto._sha256 = _sha256;
+    })(crypto = pxsim.crypto || (pxsim.crypto = {}));
+})(pxsim || (pxsim = {}));