brilliantsole 0.0.1

package/src/FirmwareManager.ts

@@ -0,0 +1,357 @@
+import Device, { SendSmpMessageCallback } from "./Device.ts";
+import { getFileBuffer } from "./utils/ArrayBufferUtils.ts";
+import { createConsole } from "./utils/Console.ts";
+import EventDispatcher from "./utils/EventDispatcher.ts";
+import { MCUManager, constants } from "./utils/mcumgr.js";
+import { FileLike } from "./utils/ArrayBufferUtils.ts";
+import autoBind from "auto-bind";
+
+const _console = createConsole("FirmwareManager", { log: true });
+
+export const FirmwareMessageTypes = ["smp"] as const;
+export type FirmwareMessageType = (typeof FirmwareMessageTypes)[number];
+
+export const FirmwareEventTypes = [
+  ...FirmwareMessageTypes,
+  "firmwareImages",
+  "firmwareUploadProgress",
+  "firmwareStatus",
+  "firmwareUploadComplete",
+] as const;
+export type FirmwareEventType = (typeof FirmwareEventTypes)[number];
+
+export const FirmwareStatuses = ["idle", "uploading", "uploaded", "pending", "testing", "erasing"] as const;
+export type FirmwareStatus = (typeof FirmwareStatuses)[number];
+
+export interface FirmwareImage {
+  slot: number;
+  active: boolean;
+  confirmed: boolean;
+  pending: boolean;
+  permanent: boolean;
+  bootable: boolean;
+  version: string;
+  hash?: Uint8Array;
+  empty?: boolean;
+}
+
+export interface FirmwareEventMessages {
+  smp: { dataView: DataView };
+  firmwareImages: { firmwareImages: FirmwareImage[] };
+  firmwareUploadProgress: { progress: number };
+  firmwareStatus: { firmwareStatus: FirmwareStatus };
+  //firmwareUploadComplete: {};
+}
+
+export type FirmwareEventDispatcher = EventDispatcher<Device, FirmwareEventType, FirmwareEventMessages>;
+
+class FirmwareManager {
+  sendMessage!: SendSmpMessageCallback;
+
+  constructor() {
+    this.#assignMcuManagerCallbacks();
+    autoBind(this);
+  }
+
+  eventDispatcher!: FirmwareEventDispatcher;
+  get addEventListenter() {
+    return this.eventDispatcher.addEventListener;
+  }
+  get #dispatchEvent() {
+    return this.eventDispatcher.dispatchEvent;
+  }
+  get removeEventListener() {
+    return this.eventDispatcher.removeEventListener;
+  }
+  get waitForEvent() {
+    return this.eventDispatcher.waitForEvent;
+  }
+
+  parseMessage(messageType: FirmwareMessageType, dataView: DataView) {
+    _console.log({ messageType });
+
+    switch (messageType) {
+      case "smp":
+        this.#mcuManager._notification(Array.from(new Uint8Array(dataView.buffer)));
+        this.#dispatchEvent("smp", { dataView });
+        break;
+      default:
+        throw Error(`uncaught messageType ${messageType}`);
+    }
+  }
+
+  async uploadFirmware(file: FileLike) {
+    _console.log("uploadFirmware", file);
+
+    const promise = this.waitForEvent("firmwareUploadComplete");
+
+    await this.getImages();
+
+    const arrayBuffer = await getFileBuffer(file);
+    const imageInfo = await this.#mcuManager.imageInfo(arrayBuffer);
+    _console.log({ imageInfo });
+
+    this.#mcuManager.cmdUpload(arrayBuffer, 1);
+
+    this.#updateStatus("uploading");
+
+    await promise;
+  }
+
+  #status: FirmwareStatus = "idle";
+  get status() {
+    return this.#status;
+  }
+  #updateStatus(newStatus: FirmwareStatus) {
+    _console.assertEnumWithError(newStatus, FirmwareStatuses);
+    if (this.#status == newStatus) {
+      _console.log(`redundant firmwareStatus assignment "${newStatus}"`);
+      return;
+    }
+
+    this.#status = newStatus;
+    _console.log({ firmwareStatus: this.#status });
+    this.#dispatchEvent("firmwareStatus", { firmwareStatus: this.#status });
+  }
+
+  // COMMANDS
+
+  #images!: FirmwareImage[];
+  get images() {
+    return this.#images;
+  }
+  #assertImages() {
+    _console.assertWithError(this.#images, "didn't get imageState");
+  }
+  #assertValidImageIndex(imageIndex: number) {
+    _console.assertTypeWithError(imageIndex, "number");
+    _console.assertWithError(imageIndex == 0 || imageIndex == 1, "imageIndex must be 0 or 1");
+  }
+  async getImages() {
+    const promise = this.waitForEvent("firmwareImages");
+
+    _console.log("getting firmware image state...");
+    this.sendMessage(Uint8Array.from(this.#mcuManager.cmdImageState()).buffer);
+
+    await promise;
+  }
+
+  async testImage(imageIndex: number = 1) {
+    this.#assertValidImageIndex(imageIndex);
+    this.#assertImages();
+    if (!this.#images[imageIndex]) {
+      _console.log(`image ${imageIndex} not found`);
+      return;
+    }
+    if (this.#images[imageIndex].pending == true) {
+      _console.log(`image ${imageIndex} is already pending`);
+      return;
+    }
+    if (this.#images[imageIndex].empty) {
+      _console.log(`image ${imageIndex} is empty`);
+      return;
+    }
+
+    const promise = this.waitForEvent("smp");
+
+    _console.log("testing firmware image...");
+    this.sendMessage(Uint8Array.from(this.#mcuManager.cmdImageTest(this.#images[imageIndex].hash)).buffer);
+
+    await promise;
+  }
+
+  async eraseImage() {
+    this.#assertImages();
+    const promise = this.waitForEvent("smp");
+
+    _console.log("erasing image...");
+    this.sendMessage(Uint8Array.from(this.#mcuManager.cmdImageErase()).buffer);
+
+    this.#updateStatus("erasing");
+
+    await promise;
+    await this.getImages();
+  }
+
+  async confirmImage(imageIndex: number = 0) {
+    this.#assertValidImageIndex(imageIndex);
+    this.#assertImages();
+    if (this.#images[imageIndex].confirmed === true) {
+      _console.log(`image ${imageIndex} is already confirmed`);
+      return;
+    }
+
+    const promise = this.waitForEvent("smp");
+
+    _console.log("confirming image...");
+    this.sendMessage(Uint8Array.from(this.#mcuManager.cmdImageConfirm(this.#images[imageIndex].hash)).buffer);
+
+    await promise;
+  }
+
+  async echo(string: string) {
+    _console.assertTypeWithError(string, "string");
+
+    const promise = this.waitForEvent("smp");
+
+    _console.log("sending echo...");
+    this.sendMessage(Uint8Array.from(this.#mcuManager.smpEcho(string)).buffer);
+
+    await promise;
+  }
+
+  async reset() {
+    const promise = this.waitForEvent("smp");
+
+    _console.log("resetting...");
+    this.sendMessage(Uint8Array.from(this.#mcuManager.cmdReset()).buffer);
+
+    await promise;
+  }
+
+  // MTU
+  #mtu!: number;
+  get mtu() {
+    return this.#mtu;
+  }
+  set mtu(newMtu: number) {
+    this.#mtu = newMtu;
+    this.#mcuManager._mtu = newMtu;
+  }
+
+  // MCUManager
+  #mcuManager = new MCUManager();
+
+  #assignMcuManagerCallbacks() {
+    this.#mcuManager.onMessage(this.#onMcuMessage.bind(this));
+
+    this.#mcuManager.onFileDownloadNext(this.#onMcuFileDownloadNext);
+    this.#mcuManager.onFileDownloadProgress(this.#onMcuFileDownloadProgress.bind(this));
+    this.#mcuManager.onFileDownloadFinished(this.#onMcuFileDownloadFinished.bind(this));
+
+    this.#mcuManager.onFileUploadNext(this.#onMcuFileUploadNext.bind(this));
+    this.#mcuManager.onFileUploadProgress(this.#onMcuFileUploadProgress.bind(this));
+    this.#mcuManager.onFileUploadFinished(this.#onMcuFileUploadFinished.bind(this));
+
+    this.#mcuManager.onImageUploadNext(this.#onMcuImageUploadNext.bind(this));
+    this.#mcuManager.onImageUploadProgress(this.#onMcuImageUploadProgress.bind(this));
+    this.#mcuManager.onImageUploadFinished(this.#onMcuImageUploadFinished.bind(this));
+  }
+
+  #onMcuMessage({ op, group, id, data, length }: { op: number; group: number; id: number; data: any; length: number }) {
+    _console.log("onMcuMessage", ...arguments);
+
+    switch (group) {
+      case constants.MGMT_GROUP_ID_OS:
+        switch (id) {
+          case constants.OS_MGMT_ID_ECHO:
+            _console.log(`echo "${data.r}"`);
+            break;
+          case constants.OS_MGMT_ID_TASKSTAT:
+            _console.table(data.tasks);
+            break;
+          case constants.OS_MGMT_ID_MPSTAT:
+            _console.log(data);
+            break;
+        }
+        break;
+      case constants.MGMT_GROUP_ID_IMAGE:
+        switch (id) {
+          case constants.IMG_MGMT_ID_STATE:
+            this.#onMcuImageState(data);
+        }
+        break;
+      default:
+        throw Error(`uncaught mcuMessage group ${group}`);
+    }
+  }
+
+  #onMcuFileDownloadNext() {
+    _console.log("onMcuFileDownloadNext", ...arguments);
+  }
+  #onMcuFileDownloadProgress() {
+    _console.log("onMcuFileDownloadProgress", ...arguments);
+  }
+  #onMcuFileDownloadFinished() {
+    _console.log("onMcuFileDownloadFinished", ...arguments);
+  }
+
+  #onMcuFileUploadNext() {
+    _console.log("onMcuFileUploadNext");
+  }
+  #onMcuFileUploadProgress() {
+    _console.log("onMcuFileUploadProgress");
+  }
+  #onMcuFileUploadFinished() {
+    _console.log("onMcuFileUploadFinished");
+  }
+
+  #onMcuImageUploadNext({ packet }: { packet: number[] }) {
+    _console.log("onMcuImageUploadNext");
+    this.sendMessage(Uint8Array.from(packet).buffer);
+  }
+  #onMcuImageUploadProgress({ percentage }: { percentage: number }) {
+    const progress = percentage / 100;
+    _console.log("onMcuImageUploadProgress", ...arguments);
+    this.#dispatchEvent("firmwareUploadProgress", { progress });
+  }
+  async #onMcuImageUploadFinished() {
+    _console.log("onMcuImageUploadFinished", ...arguments);
+
+    await this.getImages();
+
+    this.#dispatchEvent("firmwareUploadProgress", { progress: 100 });
+    this.#dispatchEvent("firmwareUploadComplete", {});
+  }
+
+  #onMcuImageState({ images }: { images?: FirmwareImage[] }) {
+    if (images) {
+      this.#images = images;
+      _console.log("images", this.#images);
+    } else {
+      _console.log("no images found");
+      return;
+    }
+
+    let newStatus: FirmwareStatus = "idle";
+
+    if (this.#images.length == 2) {
+      if (!this.#images[1].bootable) {
+        _console.warn('Slot 1 has a invalid image. Click "Erase Image" to erase it or upload a different image');
+      } else if (!this.#images[0].confirmed) {
+        _console.log(
+          'Slot 0 has a valid image. Click "Confirm Image" to confirm it or wait and the device will swap images back.'
+        );
+        newStatus = "testing";
+      } else {
+        if (this.#images[1].pending) {
+          _console.log("reset to upload to the new firmware image");
+          newStatus = "pending";
+        } else {
+          _console.log("Slot 1 has a valid image. run testImage() to test it or upload a different image.");
+          newStatus = "uploaded";
+        }
+      }
+    }
+
+    if (this.#images.length == 1) {
+      this.#images.push({
+        slot: 1,
+        empty: true,
+        version: "Empty",
+        pending: false,
+        confirmed: false,
+        bootable: false,
+        active: false,
+        permanent: false,
+      });
+
+      _console.log("Select a firmware upload image to upload to slot 1.");
+    }
+
+    this.#updateStatus(newStatus);
+    this.#dispatchEvent("firmwareImages", { firmwareImages: this.#images });
+  }
+}
+
+export default FirmwareManager;

package/src/InformationManager.ts

@@ -0,0 +1,283 @@
+import Device, { SendMessageCallback } from "./Device.ts";
+import { createConsole } from "./utils/Console.ts";
+import EventDispatcher from "./utils/EventDispatcher.ts";
+import { Uint16Max } from "./utils/MathUtils.ts";
+import { textDecoder, textEncoder } from "./utils/Text.ts";
+import autoBind from "auto-bind";
+
+const _console = createConsole("InformationManager", { log: true });
+
+export const DeviceTypes = ["leftInsole", "rightInsole"] as const;
+export type DeviceType = (typeof DeviceTypes)[number];
+
+export const InsoleSides = ["left", "right"] as const;
+export type InsoleSide = (typeof InsoleSides)[number];
+
+export const MinNameLength = 2;
+export const MaxNameLength = 30;
+
+export const InformationMessageTypes = [
+  "isCharging",
+  "getBatteryCurrent",
+  "getMtu",
+  "getId",
+  "getName",
+  "setName",
+  "getType",
+  "setType",
+  "getCurrentTime",
+  "setCurrentTime",
+] as const;
+export type InformationMessageType = (typeof InformationMessageTypes)[number];
+
+export const InformationEventTypes = InformationMessageTypes;
+export type InformationEventType = (typeof InformationEventTypes)[number];
+
+export interface InformationEventMessages {
+  isCharging: { isCharging: boolean };
+  getBatteryCurrent: { batteryCurrent: number };
+  getMtu: { mtu: number };
+  getId: { id: string };
+  getName: { name: string };
+  getType: { type: DeviceType };
+  getCurrentTime: { currentTime: number };
+}
+
+export type InformationEventDispatcher = EventDispatcher<Device, InformationEventType, InformationEventMessages>;
+export type SendInformationMessageCallback = SendMessageCallback<InformationMessageType>;
+
+class InformationManager {
+  constructor() {
+    autoBind(this);
+  }
+
+  sendMessage!: SendInformationMessageCallback;
+
+  eventDispatcher!: InformationEventDispatcher;
+  get #dispatchEvent() {
+    return this.eventDispatcher.dispatchEvent;
+  }
+  get waitForEvent() {
+    return this.eventDispatcher.waitForEvent;
+  }
+
+  // PROPERTIES
+
+  #isCharging = false;
+  get isCharging() {
+    return this.#isCharging;
+  }
+  #updateIsCharging(updatedIsCharging: boolean) {
+    _console.assertTypeWithError(updatedIsCharging, "boolean");
+    this.#isCharging = updatedIsCharging;
+    _console.log({ isCharging: this.#isCharging });
+    this.#dispatchEvent("isCharging", { isCharging: this.#isCharging });
+  }
+
+  #batteryCurrent!: number;
+  get batteryCurrent() {
+    return this.#batteryCurrent;
+  }
+  async getBatteryCurrent() {
+    _console.log("getting battery current...");
+    const promise = this.waitForEvent("getBatteryCurrent");
+    this.sendMessage([{ type: "getBatteryCurrent" }]);
+    await promise;
+  }
+  #updateBatteryCurrent(updatedBatteryCurrent: number) {
+    _console.assertTypeWithError(updatedBatteryCurrent, "number");
+    this.#batteryCurrent = updatedBatteryCurrent;
+    _console.log({ batteryCurrent: this.#batteryCurrent });
+    this.#dispatchEvent("getBatteryCurrent", { batteryCurrent: this.#batteryCurrent });
+  }
+
+  #id!: string;
+  get id() {
+    return this.#id;
+  }
+  #updateId(updatedId: string) {
+    _console.assertTypeWithError(updatedId, "string");
+    this.#id = updatedId;
+    _console.log({ id: this.#id });
+    this.#dispatchEvent("getId", { id: this.#id });
+  }
+
+  #name = "";
+  get name() {
+    return this.#name;
+  }
+
+  updateName(updatedName: string) {
+    _console.assertTypeWithError(updatedName, "string");
+    this.#name = updatedName;
+    _console.log({ updatedName: this.#name });
+    this.#dispatchEvent("getName", { name: this.#name });
+  }
+  async setName(newName: string) {
+    _console.assertTypeWithError(newName, "string");
+    _console.assertWithError(
+      newName.length >= MinNameLength,
+      `name must be greater than ${MinNameLength} characters long ("${newName}" is ${newName.length} characters long)`
+    );
+    _console.assertWithError(
+      newName.length < MaxNameLength,
+      `name must be less than ${MaxNameLength} characters long ("${newName}" is ${newName.length} characters long)`
+    );
+    const setNameData = textEncoder.encode(newName);
+    _console.log({ setNameData });
+
+    const promise = this.waitForEvent("getName");
+    this.sendMessage([{ type: "setName", data: setNameData.buffer }]);
+    await promise;
+  }
+
+  // TYPE
+  #type!: DeviceType;
+  get type() {
+    return this.#type;
+  }
+  get typeEnum() {
+    return DeviceTypes.indexOf(this.type);
+  }
+  #assertValidDeviceType(type: DeviceType) {
+    _console.assertEnumWithError(type, DeviceTypes);
+  }
+  #assertValidDeviceTypeEnum(typeEnum: number) {
+    _console.assertTypeWithError(typeEnum, "number");
+    _console.assertWithError(typeEnum in DeviceTypes, `invalid typeEnum ${typeEnum}`);
+  }
+  updateType(updatedType: DeviceType) {
+    this.#assertValidDeviceType(updatedType);
+    if (updatedType == this.type) {
+      _console.log("redundant type assignment");
+      return;
+    }
+    this.#type = updatedType;
+    _console.log({ updatedType: this.#type });
+
+    this.#dispatchEvent("getType", { type: this.#type });
+  }
+  async #setTypeEnum(newTypeEnum: number) {
+    this.#assertValidDeviceTypeEnum(newTypeEnum);
+    const setTypeData = Uint8Array.from([newTypeEnum]);
+    _console.log({ setTypeData });
+    const promise = this.waitForEvent("getType");
+    this.sendMessage([{ type: "setType", data: setTypeData.buffer }]);
+    await promise;
+  }
+  async setType(newType: DeviceType) {
+    this.#assertValidDeviceType(newType);
+    const newTypeEnum = DeviceTypes.indexOf(newType);
+    this.#setTypeEnum(newTypeEnum);
+  }
+
+  get isInsole() {
+    switch (this.type) {
+      case "leftInsole":
+      case "rightInsole":
+        return true;
+      default:
+        // for future non-insole device types
+        return false;
+    }
+  }
+
+  get insoleSide(): InsoleSide {
+    switch (this.type) {
+      case "leftInsole":
+        return "left";
+      case "rightInsole":
+        return "right";
+    }
+  }
+
+  #mtu = 0;
+  get mtu() {
+    return this.#mtu;
+  }
+  #updateMtu(newMtu: number) {
+    _console.assertTypeWithError(newMtu, "number");
+    if (this.#mtu == newMtu) {
+      _console.log("redundant mtu assignment", newMtu);
+      return;
+    }
+    this.#mtu = newMtu;
+
+    this.#dispatchEvent("getMtu", { mtu: this.#mtu });
+  }
+
+  #isCurrentTimeSet = false;
+  get isCurrentTimeSet() {
+    return this.#isCurrentTimeSet;
+  }
+
+  #onCurrentTime(currentTime: number) {
+    _console.log({ currentTime });
+    this.#isCurrentTimeSet = currentTime != 0 || Math.abs(Date.now() - currentTime) < Uint16Max;
+    if (!this.#isCurrentTimeSet) {
+      this.#setCurrentTime();
+    }
+  }
+  async #setCurrentTime() {
+    _console.log("setting current time...");
+    const dataView = new DataView(new ArrayBuffer(8));
+    dataView.setBigUint64(0, BigInt(Date.now()), true);
+    const promise = this.waitForEvent("getCurrentTime");
+    this.sendMessage([{ type: "setCurrentTime", data: dataView.buffer }]);
+    await promise;
+  }
+
+  // MESSAGE
+  parseMessage(messageType: InformationMessageType, dataView: DataView) {
+    _console.log({ messageType });
+
+    switch (messageType) {
+      case "isCharging":
+        const isCharging = Boolean(dataView.getUint8(0));
+        _console.log({ isCharging });
+        this.#updateIsCharging(isCharging);
+        break;
+      case "getBatteryCurrent":
+        const batteryCurrent = dataView.getFloat32(0, true);
+        _console.log({ batteryCurrent });
+        this.#updateBatteryCurrent(batteryCurrent);
+        break;
+      case "getId":
+        const id = textDecoder.decode(dataView.buffer);
+        _console.log({ id });
+        this.#updateId(id);
+        break;
+      case "getName":
+      case "setName":
+        const name = textDecoder.decode(dataView.buffer);
+        _console.log({ name });
+        this.updateName(name);
+        break;
+      case "getType":
+      case "setType":
+        const typeEnum = dataView.getUint8(0);
+        const type = DeviceTypes[typeEnum];
+        _console.log({ typeEnum, type });
+        this.updateType(type);
+        break;
+      case "getMtu":
+        const mtu = dataView.getUint16(0, true);
+        _console.log({ mtu });
+        this.#updateMtu(mtu);
+        break;
+      case "getCurrentTime":
+      case "setCurrentTime":
+        const currentTime = Number(dataView.getBigUint64(0, true));
+        this.#onCurrentTime(currentTime);
+        break;
+      default:
+        throw Error(`uncaught messageType ${messageType}`);
+    }
+  }
+
+  clear() {
+    this.#isCurrentTimeSet = false;
+  }
+}
+
+export default InformationManager;