@v5x/serial 0.5.0 → 0.5.2

package/dts/VexPacket.js

@@ -0,0 +1,1036 @@
+import { PacketView } from "./VexPacketView";
+import { CrcGenerator } from "./VexCRC";
+import * as AllPackets from "./VexPacket";
+import { AckType, FileInitAction, } from "./Vex";
+import { VexFirmwareVersion } from "./VexFirmwareVersion";
+export class PacketEncoder {
+    static getInstance() {
+        if (Packet.ENCODER === undefined) {
+            Packet.ENCODER = new PacketEncoder();
+        }
+        return Packet.ENCODER;
+    }
+    constructor() {
+        this.allPacketsTable = {};
+        this.vexVersion = 0;
+        this.crcgen = new CrcGenerator();
+        Object.values(AllPackets).forEach((packet) => {
+            if (packet.prototype instanceof HostBoundPacket) {
+                this.allPacketsTable[
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                packet.COMMAND_ID + " " + packet.COMMAND_EXTENDED_ID] = packet;
+            }
+        });
+    }
+    /**
+     * Create the vex CDC header
+     * @param buf the bytes to send
+     */
+    createHeader(buf) {
+        // create a buffer if is is not defined
+        if (buf === undefined || buf.byteLength < PacketEncoder.HEADERS_LENGTH) {
+            buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH);
+        }
+        const h = new Uint8Array(buf);
+        h.set(PacketEncoder.HEADER_TO_DEVICE);
+        return h;
+    }
+    /**
+     * Create the vex CDC simple message
+     * @param cmd the CDC command byte
+     */
+    cdcCommand(cmd) {
+        const buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH + 1);
+        const h = this.createHeader(buf);
+        h.set([cmd], PacketEncoder.HEADERS_LENGTH);
+        return h;
+    }
+    /**
+     * Create the vex CDC simple message
+     * @param cmd the CDC command byte
+     * @param data the data to send
+     */
+    cdcCommandWithData(cmd, data) {
+        const buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH + 2 + data.length);
+        const h = this.createHeader(buf);
+        // add command and length bytes
+        h.set([cmd, data.length], PacketEncoder.HEADERS_LENGTH);
+        // add the message data
+        h.set(data, PacketEncoder.HEADERS_LENGTH + 2);
+        return h;
+    }
+    /**
+     * Create the vex CDC extended message
+     * @param cmd the CDC command byte
+     * @param ext the CDC extended command byte
+     * @return a message
+     */
+    cdc2Command(cmd, ext) {
+        const buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH + 5);
+        const h = this.createHeader(buf);
+        h.set([cmd, ext, 0], PacketEncoder.HEADERS_LENGTH);
+        // Add CRC
+        const crc = this.crcgen.crc16(h.subarray(0, buf.byteLength - 2), 0) >>> 0;
+        h.set([crc >>> 8, crc & 0xff], buf.byteLength - 2);
+        return h;
+    }
+    /**
+     * Calculate buffer length for new CDC extended command
+     * @param data the CDC extended command payload
+     * @returns the required buffer length of the command message
+     */
+    cdc2CommandBufferLength(data) {
+        // New command use header + 1 byte command
+        //                        + 1 byte function
+        //                        + 1 byte data length
+        let length = PacketEncoder.HEADERS_LENGTH + data.length + 3 + 2;
+        // If data length is > 127 bytes then an additional data length byte is added
+        if (data.length > 127)
+            length += 1;
+        return length;
+    }
+    /**
+     * Create the vex CDC extended message with some data
+     * @param cmd the CDC command byte
+     * @param ext the CDC extended command byte
+     * @param data the CDC extended command payload
+     * @return a message
+     */
+    cdc2CommandWithData(cmd, ext, data) {
+        const buf = new ArrayBuffer(this.cdc2CommandBufferLength(data));
+        const h = this.createHeader(buf);
+        // add command and length bytes
+        if (data.length < 128) {
+            h.set([cmd, ext, data.length], PacketEncoder.HEADERS_LENGTH);
+            // add the message data
+            h.set(data, PacketEncoder.HEADERS_LENGTH + 3);
+        }
+        else {
+            const lengthMsb = ((data.length >>> 8) | 0x80) >>> 0;
+            const lengthLsb = (data.length & 0xff) >>> 0;
+            h.set([cmd, ext, lengthMsb, lengthLsb], PacketEncoder.HEADERS_LENGTH);
+            // add the message data
+            h.set(data, PacketEncoder.HEADERS_LENGTH + 4);
+        }
+        // Add CRC (little endian)
+        const crc = this.crcgen.crc16(h.subarray(0, buf.byteLength - 2), 0);
+        h.set([crc >>> 8, crc & 0xff], buf.byteLength - 2);
+        return h;
+    }
+    validateHeader(data) {
+        return !(data[0] !== PacketEncoder.HEADER_TO_HOST[0] ||
+            data[1] !== PacketEncoder.HEADER_TO_HOST[1]);
+    }
+    validateMessageCdc(data) {
+        const message = data.subarray(0, data.byteLength - 2);
+        const lastTwoBytes = (data[data.byteLength - 2] << 8) + data[data.byteLength - 1];
+        return this.crcgen.crc16(message, 0) === lastTwoBytes;
+    }
+    getPayloadSize(data) {
+        let t = 0;
+        let a = data[3];
+        if ((128 & a) !== 0) {
+            t = 127 & a;
+            a = data[4];
+        }
+        return (t << 8) + a;
+    }
+}
+PacketEncoder.HEADERS_LENGTH = 4;
+PacketEncoder.HEADER_TO_DEVICE = [201, 54, 184, 71];
+PacketEncoder.HEADER_TO_HOST = [170, 85];
+PacketEncoder.J2000_EPOCH = 946684800;
+export class Packet {
+    constructor(rawData) {
+        this.data =
+            rawData instanceof ArrayBuffer ? new Uint8Array(rawData) : rawData;
+    }
+}
+export class DeviceBoundPacket extends Packet {
+    constructor(payload) {
+        super(new Uint8Array());
+        // eslint-disable-next-line no-proto, @typescript-eslint/no-explicit-any
+        const me = this.__proto__.constructor;
+        if (me.COMMAND_EXTENDED_ID === undefined) {
+            if (payload === undefined) {
+                this.data = Packet.ENCODER.cdcCommand(me.COMMAND_ID);
+            }
+            else {
+                this.data = Packet.ENCODER.cdcCommandWithData(me.COMMAND_ID, payload);
+            }
+        }
+        else {
+            if (payload === undefined) {
+                this.data = Packet.ENCODER.cdc2Command(me.COMMAND_ID, me.COMMAND_EXTENDED_ID);
+            }
+            else {
+                this.data = Packet.ENCODER.cdc2CommandWithData(me.COMMAND_ID, me.COMMAND_EXTENDED_ID, payload);
+            }
+        }
+    }
+}
+export class Query1H2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+Query1H2DPacket.COMMAND_ID = 33;
+Query1H2DPacket.COMMAND_EXTENDED_ID = undefined;
+export class SystemVersionH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+SystemVersionH2DPacket.COMMAND_ID = 164;
+SystemVersionH2DPacket.COMMAND_EXTENDED_ID = undefined;
+export class UpdateMatchModeH2DPacket extends DeviceBoundPacket {
+    constructor(mode, matchClock) {
+        let bit1;
+        switch (mode) {
+            case "autonomous":
+                bit1 = 10;
+                break;
+            case "driver":
+                bit1 = 8;
+                break;
+            case "disabled":
+                bit1 = 11;
+        }
+        const payload = new Uint8Array(5);
+        const view = new DataView(payload.buffer);
+        payload[0] = (15 & bit1) >>> 0;
+        view.setUint32(1, matchClock, true);
+        super(payload);
+    }
+}
+UpdateMatchModeH2DPacket.COMMAND_ID = 88;
+UpdateMatchModeH2DPacket.COMMAND_EXTENDED_ID = 193;
+export class GetMatchStatusH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+GetMatchStatusH2DPacket.COMMAND_ID = 88;
+GetMatchStatusH2DPacket.COMMAND_EXTENDED_ID = 194;
+export class GetRadioModeH2DPacket extends DeviceBoundPacket {
+    constructor(mode) {
+        const payload = new Uint8Array(1);
+        payload[0] = mode;
+        super(payload);
+    }
+}
+GetRadioModeH2DPacket.COMMAND_ID = 88;
+GetRadioModeH2DPacket.COMMAND_EXTENDED_ID = 65;
+export class FileControlH2DPacket extends DeviceBoundPacket {
+    constructor(a, b) {
+        const payload = new Uint8Array(2);
+        payload.set([a, b], 0);
+        super(payload);
+    }
+}
+FileControlH2DPacket.COMMAND_ID = 86;
+FileControlH2DPacket.COMMAND_EXTENDED_ID = 16;
+export class InitFileTransferH2DPacket extends DeviceBoundPacket {
+    constructor(operation, target, vendor, options, binary, addr, name, type, version = new VexFirmwareVersion(1, 0, 0, 0)) {
+        const payload = new Uint8Array(52);
+        const view = new DataView(payload.buffer);
+        view.setUint8(0, operation);
+        view.setUint8(1, target);
+        view.setUint8(2, vendor);
+        view.setUint8(3, options);
+        view.setUint32(4, binary.length, true);
+        view.setUint32(8, addr, true);
+        view.setUint32(12, operation === FileInitAction.WRITE
+            ? Packet.ENCODER.crcgen.crc32(binary, 0)
+            : 0, true);
+        const re = /(?:\.([^.]+))?$/;
+        const reResult = re.exec(name);
+        let ext = reResult != null ? reResult[1] : undefined;
+        ext !== null && ext !== void 0 ? ext : (ext = "");
+        // files with gz extension are also type bin
+        ext = ext === "gz" ? "bin" : ext;
+        payload.set(new TextEncoder().encode(type !== null && type !== void 0 ? type : ext), 16);
+        const timestamp = ((Date.now() / 1000) >>> 0) - PacketEncoder.J2000_EPOCH;
+        view.setUint32(20, timestamp, true);
+        payload.set(version.toUint8Array(), 24);
+        // filename
+        const nameEncoded = new TextEncoder().encode(name);
+        let offset = nameEncoded.length - 23;
+        if (offset < 0)
+            offset = 0;
+        payload.set(nameEncoded.subarray(offset, offset + 23), 28);
+        view.setUint8(51, 0);
+        super(payload);
+    }
+}
+InitFileTransferH2DPacket.COMMAND_ID = 86;
+InitFileTransferH2DPacket.COMMAND_EXTENDED_ID = 17;
+export class ExitFileTransferH2DPacket extends DeviceBoundPacket {
+    constructor(action) {
+        const payload = new Uint8Array(1);
+        payload[0] = action;
+        super(payload);
+    }
+}
+ExitFileTransferH2DPacket.COMMAND_ID = 86;
+ExitFileTransferH2DPacket.COMMAND_EXTENDED_ID = 18;
+export class WriteFileH2DPacket extends DeviceBoundPacket {
+    constructor(addr, buf) {
+        const payload = new Uint8Array(4 + buf.length);
+        const view = new DataView(payload.buffer);
+        view.setUint32(0, addr, true);
+        payload.set(buf, 4);
+        super(payload);
+    }
+}
+WriteFileH2DPacket.COMMAND_ID = 86;
+WriteFileH2DPacket.COMMAND_EXTENDED_ID = 19;
+export class ReadFileH2DPacket extends DeviceBoundPacket {
+    constructor(addr, size) {
+        const payload = new Uint8Array(6);
+        const view = new DataView(payload.buffer);
+        view.setUint32(0, addr, true);
+        view.setUint16(4, size, true);
+        super(payload);
+    }
+}
+ReadFileH2DPacket.COMMAND_ID = 86;
+ReadFileH2DPacket.COMMAND_EXTENDED_ID = 20;
+export class LinkFileH2DPacket extends DeviceBoundPacket {
+    constructor(vendor, fileName, options) {
+        const str = new TextEncoder().encode(fileName);
+        const payload = new Uint8Array(26);
+        payload.set([vendor, options], 0);
+        payload.set(str.subarray(0, 23), 2);
+        super(payload);
+    }
+}
+LinkFileH2DPacket.COMMAND_ID = 86;
+LinkFileH2DPacket.COMMAND_EXTENDED_ID = 21;
+export class GetDirectoryFileCountH2DPacket extends DeviceBoundPacket {
+    constructor(vendor) {
+        const payload = new Uint8Array(2);
+        payload.set([vendor, 0], 0);
+        super(payload);
+    }
+}
+GetDirectoryFileCountH2DPacket.COMMAND_ID = 86;
+GetDirectoryFileCountH2DPacket.COMMAND_EXTENDED_ID = 22;
+export class GetDirectoryEntryH2DPacket extends DeviceBoundPacket {
+    constructor(index) {
+        const payload = new Uint8Array(2);
+        payload.set([index, 0], 0);
+        super(payload);
+    }
+}
+GetDirectoryEntryH2DPacket.COMMAND_ID = 86;
+GetDirectoryEntryH2DPacket.COMMAND_EXTENDED_ID = 23;
+export class LoadFileActionH2DPacket extends DeviceBoundPacket {
+    constructor(vendor, actionId, fileNameOrSlotNumber) {
+        let fileName;
+        if (typeof fileNameOrSlotNumber === "string") {
+            fileName = fileNameOrSlotNumber;
+        }
+        else {
+            fileName = "___s_" + (fileNameOrSlotNumber - 1) + ".bin";
+        }
+        const encodedName = new TextEncoder().encode(fileName);
+        const payload = new Uint8Array(26);
+        payload.set([vendor, actionId], 0);
+        payload.set(encodedName.subarray(0, 23), 2);
+        super(payload);
+    }
+}
+LoadFileActionH2DPacket.COMMAND_ID = 86;
+LoadFileActionH2DPacket.COMMAND_EXTENDED_ID = 24;
+export class GetFileMetadataH2DPacket extends DeviceBoundPacket {
+    constructor(vendor, fileName, options) {
+        const encodedName = new TextEncoder().encode(fileName);
+        const payload = new Uint8Array(26);
+        payload.set([vendor, options], 0);
+        payload.set(encodedName.subarray(0, 23), 2);
+        super(payload);
+    }
+}
+GetFileMetadataH2DPacket.COMMAND_ID = 86;
+GetFileMetadataH2DPacket.COMMAND_EXTENDED_ID = 25;
+export class SetFileMetadataH2DPacket extends DeviceBoundPacket {
+    constructor(vendor, fileName, fileInfo, options) {
+        const encodedName = new TextEncoder().encode(fileName);
+        const encodedType = new TextEncoder().encode(fileInfo.type);
+        const payload = new Uint8Array(42);
+        const view = new DataView(payload.buffer);
+        view.setUint8(0, vendor);
+        view.setUint8(1, options);
+        view.setUint32(2, fileInfo.loadAddress, true);
+        payload.set(encodedType.subarray(0, 4), 6);
+        const timestamp = fileInfo.timestamp - PacketEncoder.J2000_EPOCH + 100; // XXX: + 100 TEST ONLY
+        view.setUint32(10, timestamp, true);
+        payload.set(fileInfo.version.toUint8Array(), 14);
+        payload.set(encodedName.subarray(0, 23), 18);
+        super(payload);
+    }
+}
+// DOES NOT WORK
+SetFileMetadataH2DPacket.COMMAND_ID = 86;
+SetFileMetadataH2DPacket.COMMAND_EXTENDED_ID = 26;
+export class EraseFileH2DPacket extends DeviceBoundPacket {
+    constructor(vendor, fileName) {
+        const encodedName = new TextEncoder().encode(fileName);
+        const payload = new Uint8Array(26);
+        payload.set([vendor, 128], 0);
+        payload.set(encodedName.subarray(0, 23), 2);
+        super(payload);
+    }
+}
+EraseFileH2DPacket.COMMAND_ID = 86;
+EraseFileH2DPacket.COMMAND_EXTENDED_ID = 27;
+export class GetProgramSlotInfoH2DPacket extends DeviceBoundPacket {
+    constructor(vendor, fileName) {
+        const encodedName = new TextEncoder().encode(fileName);
+        const payload = new Uint8Array(26);
+        payload.set([vendor, 0], 0);
+        payload.set(encodedName.subarray(0, 23), 2);
+        super(payload);
+    }
+}
+GetProgramSlotInfoH2DPacket.COMMAND_ID = 86;
+GetProgramSlotInfoH2DPacket.COMMAND_EXTENDED_ID = 28;
+export class FileClearUpH2DPacket extends DeviceBoundPacket {
+    constructor(vendor) {
+        const payload = new Uint8Array(2);
+        payload.set([vendor, 0], 0);
+        super(payload);
+    }
+}
+FileClearUpH2DPacket.COMMAND_ID = 86;
+FileClearUpH2DPacket.COMMAND_EXTENDED_ID = 30;
+export class FileFormatH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        const payload = new Uint8Array(4);
+        payload.set([68, 67, 66, 65], 0);
+        super(payload);
+    }
+}
+FileFormatH2DPacket.COMMAND_ID = 86;
+FileFormatH2DPacket.COMMAND_EXTENDED_ID = 31;
+export class GetSystemFlagsH2DPacket extends DeviceBoundPacket {
+}
+GetSystemFlagsH2DPacket.COMMAND_ID = 86;
+GetSystemFlagsH2DPacket.COMMAND_EXTENDED_ID = 32;
+export class GetDeviceStatusH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+GetDeviceStatusH2DPacket.COMMAND_ID = 86;
+GetDeviceStatusH2DPacket.COMMAND_EXTENDED_ID = 33;
+export class GetSystemStatusH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+GetSystemStatusH2DPacket.COMMAND_ID = 86;
+GetSystemStatusH2DPacket.COMMAND_EXTENDED_ID = 34;
+export class GetFdtStatusH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+GetFdtStatusH2DPacket.COMMAND_ID = 86;
+GetFdtStatusH2DPacket.COMMAND_EXTENDED_ID = 35;
+export class GetLogCountH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+GetLogCountH2DPacket.COMMAND_ID = 86;
+GetLogCountH2DPacket.COMMAND_EXTENDED_ID = 36;
+export class ReadLogPageH2DPacket extends DeviceBoundPacket {
+    constructor(offset, count) {
+        const payload = new Uint8Array(8);
+        const view = new DataView(payload.buffer);
+        view.setUint32(0, offset, true);
+        view.setUint32(4, count, true);
+        super(payload);
+    }
+}
+ReadLogPageH2DPacket.COMMAND_ID = 86;
+ReadLogPageH2DPacket.COMMAND_EXTENDED_ID = 37;
+export class GetRadioStatusH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+GetRadioStatusH2DPacket.COMMAND_ID = 86;
+GetRadioStatusH2DPacket.COMMAND_EXTENDED_ID = 38;
+export class GetUserDataH2DPacket extends DeviceBoundPacket {
+    constructor(e) {
+        var _a;
+        const input = (_a = e === null || e === void 0 ? void 0 : e.slice(0, 224)) !== null && _a !== void 0 ? _a : new Uint8Array(0);
+        const payload = new Uint8Array(2 + input.length);
+        payload[0] = 1; // stdio channel
+        payload[1] = input.length;
+        payload.set(input, 2);
+        super(payload);
+    }
+}
+// UNCONFIRMED
+GetUserDataH2DPacket.COMMAND_ID = 86;
+GetUserDataH2DPacket.COMMAND_EXTENDED_ID = 39;
+export class ScreenCaptureH2DPacket extends DeviceBoundPacket {
+    constructor(e) {
+        const payload = new Uint8Array(1);
+        payload[0] = e;
+        super(payload);
+    }
+}
+ScreenCaptureH2DPacket.COMMAND_ID = 86;
+ScreenCaptureH2DPacket.COMMAND_EXTENDED_ID = 40;
+export class SendDashTouchH2DPacket extends DeviceBoundPacket {
+    constructor(x, y, press) {
+        const payload = new Uint8Array(6);
+        const view = new DataView(payload.buffer);
+        view.setUint16(0, x, true);
+        view.setUint16(2, y, true);
+        view.setUint16(4, press ? 1 : 0, true);
+        super(payload);
+    }
+}
+SendDashTouchH2DPacket.COMMAND_ID = 86;
+SendDashTouchH2DPacket.COMMAND_EXTENDED_ID = 42;
+export class SelectDashH2DPacket extends DeviceBoundPacket {
+    /** @param port untested */
+    constructor(screen, port) {
+        const payload = new Uint8Array(2);
+        payload[0] = screen;
+        payload[1] = port;
+        super(payload);
+    }
+}
+// UNSURE
+SelectDashH2DPacket.COMMAND_ID = 86;
+SelectDashH2DPacket.COMMAND_EXTENDED_ID = 43;
+export class EnableDashH2DPacket extends DeviceBoundPacket {
+    constructor(unknown1) {
+        if (unknown1 === undefined) {
+            super(undefined);
+        }
+        else {
+            const payload = new Uint8Array(1);
+            payload[0] = unknown1;
+            super(payload);
+        }
+    }
+}
+// UNSURE
+EnableDashH2DPacket.COMMAND_ID = 86;
+EnableDashH2DPacket.COMMAND_EXTENDED_ID = 44;
+export class DisableDashH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+// UNSURE
+DisableDashH2DPacket.COMMAND_ID = 86;
+DisableDashH2DPacket.COMMAND_EXTENDED_ID = 45;
+export class ReadKeyValueH2DPacket extends DeviceBoundPacket {
+    constructor(key) {
+        const payload = new Uint8Array(32);
+        payload.set(new TextEncoder().encode(key), 0);
+        super(payload);
+    }
+}
+// UNSURE
+ReadKeyValueH2DPacket.COMMAND_ID = 86;
+ReadKeyValueH2DPacket.COMMAND_EXTENDED_ID = 46;
+export class WriteKeyValueH2DPacket extends DeviceBoundPacket {
+    constructor(key, value) {
+        let strk = new TextEncoder().encode(key);
+        const strv = new TextEncoder().encode(value);
+        if (strk.byteLength > 31)
+            strk = strk.subarray(0, 31);
+        const payload = new Uint8Array(strk.length + strv.length + 20);
+        payload.set(strk, 0);
+        payload.set(strv, strk.length + 1);
+        super(payload);
+    }
+}
+// UNSURE
+WriteKeyValueH2DPacket.COMMAND_ID = 86;
+WriteKeyValueH2DPacket.COMMAND_EXTENDED_ID = 47;
+export class GetSlot1to4InfoH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+GetSlot1to4InfoH2DPacket.COMMAND_ID = 86;
+GetSlot1to4InfoH2DPacket.COMMAND_EXTENDED_ID = 49;
+export class GetSlot5to8InfoH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        super(undefined);
+    }
+}
+GetSlot5to8InfoH2DPacket.COMMAND_ID = 86;
+GetSlot5to8InfoH2DPacket.COMMAND_EXTENDED_ID = 50;
+export class FactoryStatusH2DPacket extends DeviceBoundPacket {
+}
+FactoryStatusH2DPacket.COMMAND_ID = 86;
+FactoryStatusH2DPacket.COMMAND_EXTENDED_ID = 241;
+export class FactoryEnableH2DPacket extends DeviceBoundPacket {
+    constructor() {
+        const payload = new Uint8Array(4);
+        payload.set([77, 76, 75, 74], 0);
+        super(payload);
+    }
+}
+FactoryEnableH2DPacket.COMMAND_ID = 86;
+FactoryEnableH2DPacket.COMMAND_EXTENDED_ID = 255;
+export class HostBoundPacket extends Packet {
+    constructor(data) {
+        super(data);
+        this.ack = AckType.CDC2_NACK;
+        this.payloadSize = Packet.ENCODER.getPayloadSize(this.data);
+        const n = this.payloadSize > 128 ? 5 : 4;
+        // skip command id check
+        this.ack = this.data[(this.ackIndex = n + 1)];
+    }
+    static isValidPacket(data, n) {
+        const ack = data[n + 1];
+        return ack === AckType.CDC2_ACK || ack === 167; // XXX: got 167 from MatchStatusReplyD2HPacket
+    }
+}
+export class Query1ReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        this.joystickFlag1 = this.data[4];
+        this.joystickFlag2 = this.data[5];
+        this.brainFlag1 = this.data[6]; // a.k.a vex version
+        this.brainFlag2 = this.data[7];
+        this.bootloadFlag1 = this.data[10];
+        this.bootloadFlag2 = this.data[11];
+    }
+}
+Query1ReplyD2HPacket.COMMAND_ID = 33;
+Query1ReplyD2HPacket.COMMAND_EXTENDED_ID = undefined;
+export class SystemVersionReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        this.version = new VexFirmwareVersion(this.data[4], this.data[5], this.data[6], this.data[8]);
+        this.hardware = this.data[7];
+    }
+}
+SystemVersionReplyD2HPacket.COMMAND_ID = 164;
+SystemVersionReplyD2HPacket.COMMAND_EXTENDED_ID = undefined;
+export class MatchModeReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.modebit = dataView.nextUint8();
+    }
+}
+MatchModeReplyD2HPacket.COMMAND_ID = 88;
+MatchModeReplyD2HPacket.COMMAND_EXTENDED_ID = 193;
+export class MatchStatusReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        const n = this.ackIndex;
+        this.rssi = dataView.nextInt8();
+        this.systemStatusBits = dataView.nextUint16();
+        this.radioStatusBits = dataView.nextUint16();
+        this.fieldStatusBits = dataView.nextUint8();
+        this.matchClock = dataView.nextUint8();
+        this.brainBatteryPercent = dataView.nextUint8();
+        this.controllerBatteryPercent = dataView.nextUint8();
+        this.partnerControllerBatteryPercent = dataView.nextUint8();
+        this.pad = dataView.nextUint8();
+        this.buttons = dataView.nextUint16();
+        this.activeProgram = dataView.nextUint8();
+        this.radioType = dataView.nextUint8();
+        this.radioChannel = dataView.nextUint8();
+        this.radioSlot = dataView.nextUint8();
+        this.robotName = dataView.nextNTBS(10);
+        this.controllerFlags = dataView.getUint8(n + 28);
+        this.rxSignalQuality = dataView.getUint8(n + 29);
+        let rawStr = new TextDecoder("UTF-8").decode(data.slice(n + 18, n + this.payloadSize + 28));
+        const endIdx = rawStr.indexOf("\0");
+        if (endIdx > -1) {
+            rawStr = rawStr.substr(0, endIdx);
+        }
+        this.robotName = rawStr;
+    }
+}
+MatchStatusReplyD2HPacket.COMMAND_ID = 88;
+MatchStatusReplyD2HPacket.COMMAND_EXTENDED_ID = 194;
+export class FileControlReplyD2HPacket extends HostBoundPacket {
+}
+FileControlReplyD2HPacket.COMMAND_ID = 86;
+FileControlReplyD2HPacket.COMMAND_EXTENDED_ID = 16;
+export class InitFileTransferReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.windowSize = dataView.nextUint16();
+        this.fileSize = dataView.nextUint32();
+        this.crc32 = dataView.nextUint32();
+    }
+}
+InitFileTransferReplyD2HPacket.COMMAND_ID = 86;
+InitFileTransferReplyD2HPacket.COMMAND_EXTENDED_ID = 17;
+export class ExitFileTransferReplyD2HPacket extends HostBoundPacket {
+}
+ExitFileTransferReplyD2HPacket.COMMAND_ID = 86;
+ExitFileTransferReplyD2HPacket.COMMAND_EXTENDED_ID = 18;
+export class WriteFileReplyD2HPacket extends HostBoundPacket {
+}
+WriteFileReplyD2HPacket.COMMAND_ID = 86;
+WriteFileReplyD2HPacket.COMMAND_EXTENDED_ID = 19;
+export class ReadFileReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        const n = this.ackIndex;
+        this.addr = dataView.getUint32(n, true);
+        this.length = this.payloadSize - 7;
+        this.buf = data.slice(n + 4, n + 4 + this.length);
+    }
+    static isValidPacket(data, n) {
+        return data[4] === 4 ? data[n + 1] === AckType.CDC2_ACK : true;
+    }
+}
+ReadFileReplyD2HPacket.COMMAND_ID = 86;
+ReadFileReplyD2HPacket.COMMAND_EXTENDED_ID = 20;
+export class LinkFileReplyD2HPacket extends HostBoundPacket {
+}
+LinkFileReplyD2HPacket.COMMAND_ID = 86;
+LinkFileReplyD2HPacket.COMMAND_EXTENDED_ID = 21;
+export class GetDirectoryFileCountReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.count = dataView.nextUint16();
+    }
+}
+GetDirectoryFileCountReplyD2HPacket.COMMAND_ID = 86;
+GetDirectoryFileCountReplyD2HPacket.COMMAND_EXTENDED_ID = 22;
+export class GetDirectoryEntryReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        if (this.payloadSize > 4) {
+            this.file = {
+                index: dataView.nextUint8(),
+                size: dataView.nextUint32(),
+                loadAddress: dataView.nextUint32(),
+                crc32: dataView.nextUint32(),
+                type: dataView.nextString(4),
+                timestamp: dataView.nextUint32() + PacketEncoder.J2000_EPOCH,
+                version: dataView.nextVersion(),
+                filename: dataView.nextNTBS(32),
+            };
+        }
+    }
+}
+GetDirectoryEntryReplyD2HPacket.COMMAND_ID = 86;
+GetDirectoryEntryReplyD2HPacket.COMMAND_EXTENDED_ID = 23;
+export class LoadFileActionReplyD2HPacket extends HostBoundPacket {
+}
+LoadFileActionReplyD2HPacket.COMMAND_ID = 86;
+LoadFileActionReplyD2HPacket.COMMAND_EXTENDED_ID = 24;
+export class GetFileMetadataReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        dataView.nextUint8();
+        if (this.payloadSize > 4) {
+            this.file = {
+                size: dataView.nextUint32(),
+                loadAddress: dataView.nextUint32(),
+                crc32: dataView.nextUint32(),
+                type: dataView.nextString(4),
+                timestamp: dataView.nextUint32() + PacketEncoder.J2000_EPOCH,
+                version: dataView.nextVersion(),
+            };
+        }
+    }
+}
+GetFileMetadataReplyD2HPacket.COMMAND_ID = 86;
+GetFileMetadataReplyD2HPacket.COMMAND_EXTENDED_ID = 25;
+export class SetFileMetadataReplyD2HPacket extends HostBoundPacket {
+}
+SetFileMetadataReplyD2HPacket.COMMAND_ID = 86;
+SetFileMetadataReplyD2HPacket.COMMAND_EXTENDED_ID = 26;
+export class EraseFileReplyD2HPacket extends HostBoundPacket {
+}
+EraseFileReplyD2HPacket.COMMAND_ID = 86;
+EraseFileReplyD2HPacket.COMMAND_EXTENDED_ID = 27;
+export class GetProgramSlotInfoReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.slot = dataView.nextUint8();
+        this.requestedSlot = dataView.nextUint8();
+    }
+}
+GetProgramSlotInfoReplyD2HPacket.COMMAND_ID = 86;
+GetProgramSlotInfoReplyD2HPacket.COMMAND_EXTENDED_ID = 28;
+export class FileClearUpReplyD2HPacket extends HostBoundPacket {
+}
+FileClearUpReplyD2HPacket.COMMAND_ID = 86;
+FileClearUpReplyD2HPacket.COMMAND_EXTENDED_ID = 30;
+export class FileFormatReplyD2HPacket extends HostBoundPacket {
+}
+FileFormatReplyD2HPacket.COMMAND_ID = 86;
+FileFormatReplyD2HPacket.COMMAND_EXTENDED_ID = 31;
+export class GetSystemFlagsReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.radioSearching = false;
+        this.currentProgram = 0;
+        this.flags = dataView.nextUint32();
+        const hasPartner = (8192 & this.flags) !== 0;
+        const hasRadio = (1536 & this.flags) === 1536;
+        const byte1 = dataView.nextUint8();
+        const byte2 = dataView.nextUint8();
+        if (this.payloadSize === 11) {
+            this.battery = 8 * (byte1 & 0x0f);
+            if ((this.flags & 0x100) !== 0 || hasRadio)
+                this.controllerBatteryPercent = 8 * ((byte1 >> 4) & 0x0f);
+            if (hasRadio)
+                this.radioQuality = 8 * (byte2 & 0x0f);
+            this.radioSearching = (this.flags & 0x600) === 0x200;
+            if (hasPartner)
+                this.partnerControllerBatteryPercent = 8 * ((byte2 >> 4) & 0x0f);
+            this.currentProgram = dataView.nextUint8();
+            if (this.battery != null && this.battery > 100)
+                this.battery = 100;
+            if (this.controllerBatteryPercent != null &&
+                this.controllerBatteryPercent > 100)
+                this.controllerBatteryPercent = 100;
+            if (this.radioQuality != null && this.radioQuality > 100)
+                this.radioQuality = 100;
+            if (this.partnerControllerBatteryPercent != null &&
+                this.partnerControllerBatteryPercent > 100)
+                this.partnerControllerBatteryPercent = 100;
+        }
+    }
+}
+GetSystemFlagsReplyD2HPacket.COMMAND_ID = 86;
+GetSystemFlagsReplyD2HPacket.COMMAND_EXTENDED_ID = 32;
+export class GetDeviceStatusReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.count = dataView.nextUint8();
+        this.devices = [];
+        for (let i = 0; i < this.count; i++) {
+            this.devices.push({
+                port: dataView.nextUint8(),
+                type: dataView.nextUint8(),
+                status: dataView.nextUint8(),
+                betaversion: dataView.nextUint8(),
+                version: dataView.nextUint16(),
+                bootversion: dataView.nextUint16(),
+            });
+        }
+    }
+}
+GetDeviceStatusReplyD2HPacket.COMMAND_ID = 86;
+GetDeviceStatusReplyD2HPacket.COMMAND_EXTENDED_ID = 33;
+export class GetSystemStatusReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        dataView.nextUint8();
+        this.systemVersion = dataView.nextVersion();
+        this.cpu0Version = dataView.nextVersion();
+        this.cpu1Version = dataView.nextVersion();
+        this.touchVersion = dataView.nextVersion(true);
+        this.uniqueId = 1234;
+        this.sysflags = [0, 0, 0, 0, 0, 0, 0];
+        this.goldenVersion = VexFirmwareVersion.allZero();
+        this.nxpVersion = VexFirmwareVersion.allZero();
+        this.eventBrain = false;
+        this.romBootloaderActive = false;
+        this.ramBootloaderActive = false;
+        if (this.payloadSize > 25) {
+            this.uniqueId = dataView.nextUint32();
+            this.sysflags = [
+                dataView.nextUint8(),
+                dataView.nextUint8(),
+                dataView.nextUint8(),
+                dataView.nextUint8(),
+                dataView.nextUint8(),
+                0,
+                dataView.nextUint8(),
+            ];
+            this.eventBrain = (1 & this.sysflags[6]) !== 0;
+            this.romBootloaderActive = (2 & this.sysflags[6]) !== 0;
+            this.ramBootloaderActive = (4 & this.sysflags[6]) !== 0;
+            dataView.nextUint16();
+            this.goldenVersion = dataView.nextVersion();
+        }
+        if (this.payloadSize > 37) {
+            this.nxpVersion = dataView.nextVersion();
+        }
+    }
+}
+GetSystemStatusReplyD2HPacket.COMMAND_ID = 86;
+GetSystemStatusReplyD2HPacket.COMMAND_EXTENDED_ID = 34;
+export class GetFdtStatusReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.count = dataView.nextUint8();
+        this.status = [];
+        for (let i = 0; i < this.count; i++) {
+            this.status.push({
+                index: dataView.nextUint8(),
+                type: dataView.nextUint8(),
+                status: dataView.nextUint8(),
+                betaversion: dataView.nextUint8(),
+                version: dataView.nextUint16(),
+                bootversion: dataView.nextUint16(),
+            });
+        }
+    }
+}
+GetFdtStatusReplyD2HPacket.COMMAND_ID = 86;
+GetFdtStatusReplyD2HPacket.COMMAND_EXTENDED_ID = 35;
+export class GetLogCountReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        dataView.nextUint8();
+        this.count = dataView.nextUint32();
+    }
+}
+GetLogCountReplyD2HPacket.COMMAND_ID = 86;
+GetLogCountReplyD2HPacket.COMMAND_EXTENDED_ID = 36;
+export class ReadLogPageReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        const n = this.ackIndex;
+        const size = dataView.nextUint8();
+        this.offset = dataView.nextUint32();
+        this.count = dataView.nextUint16();
+        this.entries = [];
+        let j = n + 8;
+        for (let i = 0; i < this.count; i++) {
+            this.entries.push({
+                code: dataView.getUint8(j),
+                type: dataView.getUint8(j + 1),
+                desc: dataView.getUint8(j + 2),
+                spare: dataView.getUint8(j + 3),
+                time: dataView.getUint32(j + 4, true),
+            });
+            j += size;
+        }
+    }
+}
+ReadLogPageReplyD2HPacket.COMMAND_ID = 86;
+ReadLogPageReplyD2HPacket.COMMAND_EXTENDED_ID = 37;
+export class GetRadioStatusReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        const n = this.ackIndex;
+        this.device = dataView.nextUint8();
+        this.quality = dataView.nextUint16();
+        this.strength = dataView.nextInt16();
+        this.channel = this.data[n + 6];
+        this.timeslot = this.data[n + 7];
+    }
+}
+GetRadioStatusReplyD2HPacket.COMMAND_ID = 86;
+GetRadioStatusReplyD2HPacket.COMMAND_EXTENDED_ID = 38;
+export class GetUserDataReplyD2HPacket extends HostBoundPacket {
+}
+GetUserDataReplyD2HPacket.COMMAND_ID = 86;
+GetUserDataReplyD2HPacket.COMMAND_EXTENDED_ID = 39;
+export class ScreenCaptureReplyD2HPacket extends HostBoundPacket {
+}
+ScreenCaptureReplyD2HPacket.COMMAND_ID = 86;
+ScreenCaptureReplyD2HPacket.COMMAND_EXTENDED_ID = 40;
+// export class UserProgramControlReplyD2HPacket extends HostBoundPacket {
+//     static COMMAND_ID = 86;
+//     static COMMAND_EXTENDED_ID = 41;
+// }
+export class SendDashTouchReplyD2HPacket extends HostBoundPacket {
+}
+SendDashTouchReplyD2HPacket.COMMAND_ID = 86;
+SendDashTouchReplyD2HPacket.COMMAND_EXTENDED_ID = 42;
+export class SelectDashReplyD2HPacket extends HostBoundPacket {
+}
+SelectDashReplyD2HPacket.COMMAND_ID = 86;
+SelectDashReplyD2HPacket.COMMAND_EXTENDED_ID = 43;
+export class EnableDashReplyD2HPacket extends HostBoundPacket {
+}
+EnableDashReplyD2HPacket.COMMAND_ID = 86;
+EnableDashReplyD2HPacket.COMMAND_EXTENDED_ID = 44;
+export class DisableDashReplyD2HPacket extends HostBoundPacket {
+}
+DisableDashReplyD2HPacket.COMMAND_ID = 86;
+DisableDashReplyD2HPacket.COMMAND_EXTENDED_ID = 45;
+export class ReadKeyValueReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.value = dataView.nextVarNTBS(255);
+    }
+}
+ReadKeyValueReplyD2HPacket.COMMAND_ID = 86;
+ReadKeyValueReplyD2HPacket.COMMAND_EXTENDED_ID = 46;
+export class WriteKeyValueReplyD2HPacket extends HostBoundPacket {
+}
+WriteKeyValueReplyD2HPacket.COMMAND_ID = 86;
+WriteKeyValueReplyD2HPacket.COMMAND_EXTENDED_ID = 47;
+export class GetSlot1to4InfoReplyD2HPacket extends HostBoundPacket {
+    constructor(data, start = 1) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.slotFlags = dataView.nextUint8();
+        this.slots = [];
+        for (let i = 0; i < 4; i++) {
+            const hasData = (this.slotFlags & Math.pow(2, start - 1 + i)) !== 0;
+            if (!hasData)
+                continue;
+            const iconNum = dataView.nextUint16();
+            const nameLen = dataView.nextUint8();
+            const name = dataView.nextString(nameLen);
+            this.slots.push({
+                slot: start + i,
+                icon: iconNum,
+                name,
+            });
+        }
+    }
+}
+GetSlot1to4InfoReplyD2HPacket.COMMAND_ID = 86;
+GetSlot1to4InfoReplyD2HPacket.COMMAND_EXTENDED_ID = 49;
+export class GetSlot5to8InfoReplyD2HPacket extends GetSlot1to4InfoReplyD2HPacket {
+    constructor(data) {
+        super(data, 5);
+        this.slotStartIndex = 5;
+    }
+}
+GetSlot5to8InfoReplyD2HPacket.COMMAND_ID = 86;
+GetSlot5to8InfoReplyD2HPacket.COMMAND_EXTENDED_ID = 50;
+export class FactoryStatusReplyD2HPacket extends HostBoundPacket {
+    constructor(data) {
+        super(data);
+        const dataView = PacketView.fromPacket(this);
+        this.status = dataView.nextUint8();
+        this.percent = dataView.nextUint8();
+    }
+}
+FactoryStatusReplyD2HPacket.COMMAND_ID = 86;
+FactoryStatusReplyD2HPacket.COMMAND_EXTENDED_ID = 241;
+export class FactoryEnableReplyD2HPacket extends HostBoundPacket {
+}
+FactoryEnableReplyD2HPacket.COMMAND_ID = 86;
+FactoryEnableReplyD2HPacket.COMMAND_EXTENDED_ID = 255;
+//# sourceMappingURL=VexPacket.js.map