brilliantsole 0.0.26 → 0.0.28

package/src/InformationManager.ts

@@ -1,17 +1,26 @@
+import { ConnectionType } from "./connection/BaseConnectionManager.ts";
 import Device, { SendMessageCallback } from "./Device.ts";
 import { createConsole } from "./utils/Console.ts";
+import { isInBrowser } from "./utils/environment.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 });
+const _console = createConsole("InformationManager", { log: false });
 
-export const DeviceTypes = ["leftInsole", "rightInsole"] as const;
+export const DeviceTypes = [
+  "leftInsole",
+  "rightInsole",
+  "leftGlove",
+  "rightGlove",
+  "glasses",
+  "generic",
+] as const;
 export type DeviceType = (typeof DeviceTypes)[number];
 
-export const InsoleSides = ["left", "right"] as const;
-export type InsoleSide = (typeof InsoleSides)[number];
+export const Sides = ["left", "right"] as const;
+export type Side = (typeof Sides)[number];
 
 export const MinNameLength = 2;
 export const MaxNameLength = 30;
@@ -43,8 +52,13 @@ export interface InformationEventMessages {
   getCurrentTime: { currentTime: number };
 }
 
-export type InformationEventDispatcher = EventDispatcher<Device, InformationEventType, InformationEventMessages>;
-export type SendInformationMessageCallback = SendMessageCallback<InformationMessageType>;
+export type InformationEventDispatcher = EventDispatcher<
+  Device,
+  InformationEventType,
+  InformationEventMessages
+>;
+export type SendInformationMessageCallback =
+  SendMessageCallback<InformationMessageType>;
 
 class InformationManager {
   constructor() {
@@ -88,7 +102,9 @@ class InformationManager {
     _console.assertTypeWithError(updatedBatteryCurrent, "number");
     this.#batteryCurrent = updatedBatteryCurrent;
     _console.log({ batteryCurrent: this.#batteryCurrent });
-    this.#dispatchEvent("getBatteryCurrent", { batteryCurrent: this.#batteryCurrent });
+    this.#dispatchEvent("getBatteryCurrent", {
+      batteryCurrent: this.#batteryCurrent,
+    });
   }
 
   #id!: string;
@@ -115,13 +131,11 @@ class InformationManager {
   }
   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)`
+    _console.assertRangeWithError(
+      "newName",
+      newName.length,
+      MinNameLength,
+      MaxNameLength
     );
     const setNameData = textEncoder.encode(newName);
     _console.log({ setNameData });
@@ -144,7 +158,10 @@ class InformationManager {
   }
   #assertValidDeviceTypeEnum(typeEnum: number) {
     _console.assertTypeWithError(typeEnum, "number");
-    _console.assertWithError(typeEnum in DeviceTypes, `invalid typeEnum ${typeEnum}`);
+    _console.assertWithError(
+      typeEnum in DeviceTypes,
+      `invalid typeEnum ${typeEnum}`
+    );
   }
   updateType(updatedType: DeviceType) {
     this.#assertValidDeviceType(updatedType);
@@ -177,17 +194,30 @@ class InformationManager {
       case "rightInsole":
         return true;
       default:
-        // for future non-insole device types
         return false;
     }
   }
 
-  get insoleSide(): InsoleSide {
+  get isGlove() {
+    switch (this.type) {
+      case "leftGlove":
+      case "rightGlove":
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  get side(): Side {
     switch (this.type) {
       case "leftInsole":
+      case "leftGlove":
         return "left";
       case "rightInsole":
+      case "rightGlove":
         return "right";
+      default:
+        return "left";
     }
   }
 
@@ -213,7 +243,8 @@ class InformationManager {
 
   #onCurrentTime(currentTime: number) {
     _console.log({ currentTime });
-    this.#isCurrentTimeSet = currentTime != 0 || Math.abs(Date.now() - currentTime) < Uint16Max;
+    this.#isCurrentTimeSet =
+      currentTime != 0 || Math.abs(Date.now() - currentTime) < Uint16Max;
     if (!this.#isCurrentTimeSet) {
       this.#setCurrentTime(false);
     }
@@ -223,7 +254,10 @@ class InformationManager {
     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 }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setCurrentTime", data: dataView.buffer }],
+      sendImmediately
+    );
     await promise;
   }
 
@@ -261,7 +295,13 @@ class InformationManager {
         this.updateType(type);
         break;
       case "getMtu":
-        const mtu = dataView.getUint16(0, true);
+        let mtu = dataView.getUint16(0, true);
+        if (
+          this.connectionType != "webSocket" &&
+          this.connectionType != "udp"
+        ) {
+          mtu = Math.min(mtu, 512);
+        }
         _console.log({ mtu });
         this.#updateMtu(mtu);
         break;
@@ -278,6 +318,8 @@ class InformationManager {
   clear() {
     this.#isCurrentTimeSet = false;
   }
+
+  connectionType?: ConnectionType;
 }
 
 export default InformationManager;

package/src/TfliteManager.ts

@@ -8,8 +8,9 @@ import { parseTimestamp } from "./utils/MathUtils.ts";
 import { SensorType } from "./sensor/SensorDataManager.ts";
 import Device, { SendMessageCallback } from "./Device.ts";
 import autoBind from "auto-bind";
+import { FileConfiguration as BaseFileConfiguration } from "./FileTransferManager.ts";
 
-const _console = createConsole("TfliteManager", { log: true });
+const _console = createConsole("TfliteManager", { log: false });
 
 export const TfliteMessageTypes = [
   "getTfliteName",
@@ -34,6 +35,17 @@ export type TfliteMessageType = (typeof TfliteMessageTypes)[number];
 export const TfliteEventTypes = TfliteMessageTypes;
 export type TfliteEventType = (typeof TfliteEventTypes)[number];
 
+export const RequiredTfliteMessageTypes: TfliteMessageType[] = [
+  "getTfliteName",
+  "getTfliteTask",
+  "getTfliteSampleRate",
+  "getTfliteSensorTypes",
+  "tfliteIsReady",
+  "getTfliteCaptureDelay",
+  "getTfliteThreshold",
+  "getTfliteInferencingEnabled",
+];
+
 export const TfliteTasks = ["classification", "regression"] as const;
 export type TfliteTask = (typeof TfliteTasks)[number];
 
@@ -54,14 +66,36 @@ export interface TfliteInference {
   values: number[];
   maxValue?: number;
   maxIndex?: number;
+  maxClass?: string;
+  classValues?: { [key: string]: number };
 }
 
-export type TfliteEventDispatcher = EventDispatcher<Device, TfliteEventType, TfliteEventMessages>;
+export type TfliteEventDispatcher = EventDispatcher<
+  Device,
+  TfliteEventType,
+  TfliteEventMessages
+>;
 export type SendTfliteMessageCallback = SendMessageCallback<TfliteMessageType>;
 
-export const TfliteSensorTypes: SensorType[] = ["pressure", "linearAcceleration", "gyroscope", "magnetometer"] as const;
+export const TfliteSensorTypes = [
+  "pressure",
+  "linearAcceleration",
+  "gyroscope",
+  "magnetometer",
+] as const satisfies readonly SensorType[];
 export type TfliteSensorType = (typeof TfliteSensorTypes)[number];
 
+export interface TfliteFileConfiguration extends BaseFileConfiguration {
+  type: "tflite";
+  name: string;
+  sensorTypes: TfliteSensorType[];
+  task: TfliteTask;
+  sampleRate: number;
+  captureDelay?: number;
+  threshold?: number;
+  classes?: string[];
+}
+
 class TfliteManager {
   constructor() {
     autoBind(this);
@@ -73,7 +107,10 @@ class TfliteManager {
     _console.assertEnumWithError(task, TfliteTasks);
   }
   #assertValidTaskEnum(taskEnum: number) {
-    _console.assertWithError(taskEnum in TfliteTasks, `invalid taskEnum ${taskEnum}`);
+    _console.assertWithError(
+      taskEnum in TfliteTasks,
+      `invalid taskEnum ${taskEnum}`
+    );
   }
 
   eventDispatcher!: TfliteEventDispatcher;
@@ -116,7 +153,10 @@ class TfliteManager {
     const promise = this.waitForEvent("getTfliteName");
 
     const setNameData = textEncoder.encode(newName);
-    this.sendMessage([{ type: "setTfliteName", data: setNameData.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteName", data: setNameData.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -147,7 +187,10 @@ class TfliteManager {
     const promise = this.waitForEvent("getTfliteTask");
 
     const taskEnum = TfliteTasks.indexOf(newTask);
-    this.sendMessage([{ type: "setTfliteTask", data: Uint8Array.from([taskEnum]).buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteTask", data: Uint8Array.from([taskEnum]).buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -164,7 +207,9 @@ class TfliteManager {
   #updateSampleRate(sampleRate: number) {
     _console.log({ sampleRate });
     this.#sampleRate = sampleRate;
-    this.#dispatchEvent("getTfliteSampleRate", { tfliteSampleRate: sampleRate });
+    this.#dispatchEvent("getTfliteSampleRate", {
+      tfliteSampleRate: sampleRate,
+    });
   }
   async setSampleRate(newSampleRate: number, sendImmediately?: boolean) {
     _console.assertTypeWithError(newSampleRate, "number");
@@ -182,40 +227,56 @@ class TfliteManager {
 
     const dataView = new DataView(new ArrayBuffer(2));
     dataView.setUint16(0, newSampleRate, true);
-    this.sendMessage([{ type: "setTfliteSampleRate", data: dataView.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteSampleRate", data: dataView.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
 
   static AssertValidSensorType(sensorType: SensorType) {
     SensorDataManager.AssertValidSensorType(sensorType);
-    _console.assertWithError(TfliteSensorTypes.includes(sensorType), `invalid tflite sensorType "${sensorType}"`);
+    const tfliteSensorType = sensorType as TfliteSensorType;
+    _console.assertWithError(
+      TfliteSensorTypes.includes(tfliteSensorType),
+      `invalid tflite sensorType "${sensorType}"`
+    );
   }
 
-  #sensorTypes: SensorType[] = [];
+  #sensorTypes: TfliteSensorType[] = [];
   get sensorTypes() {
     return this.#sensorTypes.slice();
   }
   #parseSensorTypes(dataView: DataView) {
     _console.log("parseSensorTypes", dataView);
-    const sensorTypes: SensorType[] = [];
+    const sensorTypes: TfliteSensorType[] = [];
     for (let index = 0; index < dataView.byteLength; index++) {
       const sensorTypeEnum = dataView.getUint8(index);
-      const sensorType = SensorTypes[sensorTypeEnum];
+      const sensorType = SensorTypes[sensorTypeEnum] as TfliteSensorType;
       if (sensorType) {
-        sensorTypes.push(sensorType);
+        if (TfliteSensorTypes.includes(sensorType)) {
+          sensorTypes.push(sensorType);
+        } else {
+          _console.error(`invalid tfliteSensorType ${sensorType}`);
+        }
       } else {
         _console.error(`invalid sensorTypeEnum ${sensorTypeEnum}`);
       }
     }
     this.#updateSensorTypes(sensorTypes);
   }
-  #updateSensorTypes(sensorTypes: SensorType[]) {
+  #updateSensorTypes(sensorTypes: TfliteSensorType[]) {
     _console.log({ sensorTypes });
     this.#sensorTypes = sensorTypes;
-    this.#dispatchEvent("getTfliteSensorTypes", { tfliteSensorTypes: sensorTypes });
+    this.#dispatchEvent("getTfliteSensorTypes", {
+      tfliteSensorTypes: sensorTypes,
+    });
   }
-  async setSensorTypes(newSensorTypes: SensorType[], sendImmediately?: boolean) {
+  async setSensorTypes(
+    newSensorTypes: SensorType[],
+    sendImmediately?: boolean
+  ) {
     newSensorTypes.forEach((sensorType) => {
       TfliteManager.AssertValidSensorType(sensorType);
     });
@@ -223,10 +284,17 @@ class TfliteManager {
     const promise = this.waitForEvent("getTfliteSensorTypes");
 
     newSensorTypes = arrayWithoutDuplicates(newSensorTypes);
-    const newSensorTypeEnums = newSensorTypes.map((sensorType) => SensorTypes.indexOf(sensorType)).sort();
+    const newSensorTypeEnums = newSensorTypes
+      .map((sensorType) => SensorTypes.indexOf(sensorType))
+      .sort();
     _console.log(newSensorTypes, newSensorTypeEnums);
     this.sendMessage(
-      [{ type: "setTfliteSensorTypes", data: Uint8Array.from(newSensorTypeEnums).buffer }],
+      [
+        {
+          type: "setTfliteSensorTypes",
+          data: Uint8Array.from(newSensorTypeEnums).buffer,
+        },
+      ],
       sendImmediately
     );
 
@@ -263,7 +331,9 @@ class TfliteManager {
   #updateCaptueDelay(captureDelay: number) {
     _console.log({ captureDelay });
     this.#captureDelay = captureDelay;
-    this.#dispatchEvent("getTfliteCaptureDelay", { tfliteCaptureDelay: captureDelay });
+    this.#dispatchEvent("getTfliteCaptureDelay", {
+      tfliteCaptureDelay: captureDelay,
+    });
   }
   async setCaptureDelay(newCaptureDelay: number, sendImmediately: boolean) {
     _console.assertTypeWithError(newCaptureDelay, "number");
@@ -276,7 +346,10 @@ class TfliteManager {
 
     const dataView = new DataView(new ArrayBuffer(2));
     dataView.setUint16(0, newCaptureDelay, true);
-    this.sendMessage([{ type: "setTfliteCaptureDelay", data: dataView.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteCaptureDelay", data: dataView.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -297,7 +370,10 @@ class TfliteManager {
   }
   async setThreshold(newThreshold: number, sendImmediately: boolean) {
     _console.assertTypeWithError(newThreshold, "number");
-    _console.assertWithError(newThreshold >= 0, `threshold must be positive (got ${newThreshold})`);
+    _console.assertWithError(
+      newThreshold >= 0,
+      `threshold must be positive (got ${newThreshold})`
+    );
     if (this.#threshold == newThreshold) {
       _console.log(`redundant threshold assignment ${newThreshold}`);
       return;
@@ -307,7 +383,10 @@ class TfliteManager {
 
     const dataView = new DataView(new ArrayBuffer(4));
     dataView.setFloat32(0, newThreshold, true);
-    this.sendMessage([{ type: "setTfliteThreshold", data: dataView.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteThreshold", data: dataView.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -324,16 +403,23 @@ class TfliteManager {
   #updateInferencingEnabled(inferencingEnabled: boolean) {
     _console.log({ inferencingEnabled });
     this.#inferencingEnabled = inferencingEnabled;
-    this.#dispatchEvent("getTfliteInferencingEnabled", { tfliteInferencingEnabled: inferencingEnabled });
+    this.#dispatchEvent("getTfliteInferencingEnabled", {
+      tfliteInferencingEnabled: inferencingEnabled,
+    });
   }
-  async setInferencingEnabled(newInferencingEnabled: boolean, sendImmediately: boolean = true) {
+  async setInferencingEnabled(
+    newInferencingEnabled: boolean,
+    sendImmediately: boolean = true
+  ) {
     _console.assertTypeWithError(newInferencingEnabled, "boolean");
     if (!newInferencingEnabled && !this.isReady) {
       return;
     }
     this.#assertIsReady();
     if (this.#inferencingEnabled == newInferencingEnabled) {
-      _console.log(`redundant inferencingEnabled assignment ${newInferencingEnabled}`);
+      _console.log(
+        `redundant inferencingEnabled assignment ${newInferencingEnabled}`
+      );
       return;
     }
 
@@ -375,7 +461,11 @@ class TfliteManager {
     _console.log({ timestamp });
 
     const values: number[] = [];
-    for (let index = 0, byteOffset = 2; byteOffset < dataView.byteLength; index++, byteOffset += 4) {
+    for (
+      let index = 0, byteOffset = 2;
+      byteOffset < dataView.byteLength;
+      index++, byteOffset += 4
+    ) {
       const value = dataView.getFloat32(byteOffset, true);
       values.push(value);
     }
@@ -398,6 +488,15 @@ class TfliteManager {
       _console.log({ maxIndex, maxValue });
       inference.maxIndex = maxIndex;
       inference.maxValue = maxValue;
+      if (this.#configuration?.classes) {
+        const { classes } = this.#configuration;
+        inference.maxClass = classes[maxIndex];
+        inference.classValues = {};
+        values.forEach((value, index) => {
+          const key = classes[index];
+          inference.classValues![key] = value;
+        });
+      }
     }
 
     this.#dispatchEvent("tfliteInference", { tfliteInference: inference });
@@ -445,6 +544,53 @@ class TfliteManager {
         throw Error(`uncaught messageType ${messageType}`);
     }
   }
+
+  #configuration?: TfliteFileConfiguration;
+  get configuration() {
+    return this.#configuration;
+  }
+  sendConfiguration(
+    configuration: TfliteFileConfiguration,
+    sendImmediately?: boolean
+  ) {
+    if (configuration == this.#configuration) {
+      _console.log("redundant tflite configuration assignment");
+      return;
+    }
+    this.#configuration = configuration;
+    _console.log("assigned new tflite configuration", this.configuration);
+    if (!this.configuration) {
+      return;
+    }
+    const { name, task, captureDelay, sampleRate, threshold, sensorTypes } =
+      this.configuration;
+    this.setName(name, false);
+    this.setTask(task, false);
+    if (captureDelay != undefined) {
+      this.setCaptureDelay(captureDelay, false);
+    }
+    this.setSampleRate(sampleRate, false);
+    if (threshold != undefined) {
+      this.setThreshold(threshold, false);
+    }
+    this.setSensorTypes(sensorTypes, sendImmediately);
+  }
+
+  clear() {
+    this.#configuration = undefined;
+    this.#inferencingEnabled = false;
+    this.#sensorTypes = [];
+    this.#sampleRate = 0;
+    this.#isReady = false;
+  }
+
+  requestRequiredInformation() {
+    _console.log("requesting required tflite information");
+    const messages = RequiredTfliteMessageTypes.map((messageType) => ({
+      type: messageType,
+    }));
+    this.sendMessage(messages, false);
+  }
 }
 
 export default TfliteManager;