brilliantsole 0.0.1

package/src/TfliteManager.ts

@@ -0,0 +1,450 @@
+import { createConsole } from "./utils/Console.ts";
+import EventDispatcher from "./utils/EventDispatcher.ts";
+import { textDecoder, textEncoder } from "./utils/Text.ts";
+import SensorDataManager, { SensorTypes } from "./sensor/SensorDataManager.ts";
+import { arrayWithoutDuplicates } from "./utils/ArrayUtils.ts";
+import { SensorRateStep } from "./sensor/SensorConfigurationManager.ts";
+import { parseTimestamp } from "./utils/MathUtils.ts";
+import { SensorType } from "./sensor/SensorDataManager.ts";
+import Device, { SendMessageCallback } from "./Device.ts";
+import autoBind from "auto-bind";
+
+const _console = createConsole("TfliteManager", { log: true });
+
+export const TfliteMessageTypes = [
+  "getTfliteName",
+  "setTfliteName",
+  "getTfliteTask",
+  "setTfliteTask",
+  "getTfliteSampleRate",
+  "setTfliteSampleRate",
+  "getTfliteSensorTypes",
+  "setTfliteSensorTypes",
+  "tfliteIsReady",
+  "getTfliteCaptureDelay",
+  "setTfliteCaptureDelay",
+  "getTfliteThreshold",
+  "setTfliteThreshold",
+  "getTfliteInferencingEnabled",
+  "setTfliteInferencingEnabled",
+  "tfliteInference",
+] as const;
+export type TfliteMessageType = (typeof TfliteMessageTypes)[number];
+
+export const TfliteEventTypes = TfliteMessageTypes;
+export type TfliteEventType = (typeof TfliteEventTypes)[number];
+
+export const TfliteTasks = ["classification", "regression"] as const;
+export type TfliteTask = (typeof TfliteTasks)[number];
+
+export interface TfliteEventMessages {
+  getTfliteName: { tfliteName: string };
+  getTfliteTask: { tfliteTask: TfliteTask };
+  getTfliteSampleRate: { tfliteSampleRate: number };
+  getTfliteSensorTypes: { tfliteSensorTypes: SensorType[] };
+  tfliteIsReady: { tfliteIsReady: boolean };
+  getTfliteCaptureDelay: { tfliteCaptureDelay: number };
+  getTfliteThreshold: { tfliteThreshold: number };
+  getTfliteInferencingEnabled: { tfliteInferencingEnabled: boolean };
+  tfliteInference: { tfliteInference: TfliteInference };
+}
+
+export interface TfliteInference {
+  timestamp: number;
+  values: number[];
+  maxValue?: number;
+  maxIndex?: number;
+}
+
+export type TfliteEventDispatcher = EventDispatcher<Device, TfliteEventType, TfliteEventMessages>;
+export type SendTfliteMessageCallback = SendMessageCallback<TfliteMessageType>;
+
+export const TfliteSensorTypes: SensorType[] = ["pressure", "linearAcceleration", "gyroscope", "magnetometer"] as const;
+export type TfliteSensorType = (typeof TfliteSensorTypes)[number];
+
+class TfliteManager {
+  constructor() {
+    autoBind(this);
+  }
+
+  sendMessage!: SendTfliteMessageCallback;
+
+  #assertValidTask(task: TfliteTask) {
+    _console.assertEnumWithError(task, TfliteTasks);
+  }
+  #assertValidTaskEnum(taskEnum: number) {
+    _console.assertWithError(taskEnum in TfliteTasks, `invalid taskEnum ${taskEnum}`);
+  }
+
+  eventDispatcher!: TfliteEventDispatcher;
+  get addEventListenter() {
+    return this.eventDispatcher.addEventListener;
+  }
+  get #dispatchEvent() {
+    return this.eventDispatcher.dispatchEvent;
+  }
+  get removeEventListener() {
+    return this.eventDispatcher.removeEventListener;
+  }
+  get waitForEvent() {
+    return this.eventDispatcher.waitForEvent;
+  }
+
+  // PROPERTIES
+
+  #name!: string;
+  get name() {
+    return this.#name;
+  }
+  #parseName(dataView: DataView) {
+    _console.log("parseName", dataView);
+    const name = textDecoder.decode(dataView.buffer);
+    this.#updateName(name);
+  }
+  #updateName(name: string) {
+    _console.log({ name });
+    this.#name = name;
+    this.#dispatchEvent("getTfliteName", { tfliteName: name });
+  }
+  async setName(newName: string, sendImmediately?: boolean) {
+    _console.assertTypeWithError(newName, "string");
+    if (this.name == newName) {
+      _console.log(`redundant name assignment ${newName}`);
+      return;
+    }
+
+    const promise = this.waitForEvent("getTfliteName");
+
+    const setNameData = textEncoder.encode(newName);
+    this.sendMessage([{ type: "setTfliteName", data: setNameData.buffer }], sendImmediately);
+
+    await promise;
+  }
+
+  #task!: TfliteTask;
+  get task() {
+    return this.#task;
+  }
+  #parseTask(dataView: DataView) {
+    _console.log("parseTask", dataView);
+    const taskEnum = dataView.getUint8(0);
+    this.#assertValidTaskEnum(taskEnum);
+    const task = TfliteTasks[taskEnum];
+    this.#updateTask(task);
+  }
+  #updateTask(task: TfliteTask) {
+    _console.log({ task });
+    this.#task = task;
+    this.#dispatchEvent("getTfliteTask", { tfliteTask: task });
+  }
+  async setTask(newTask: TfliteTask, sendImmediately?: boolean) {
+    this.#assertValidTask(newTask);
+    if (this.task == newTask) {
+      _console.log(`redundant task assignment ${newTask}`);
+      return;
+    }
+
+    const promise = this.waitForEvent("getTfliteTask");
+
+    const taskEnum = TfliteTasks.indexOf(newTask);
+    this.sendMessage([{ type: "setTfliteTask", data: Uint8Array.from([taskEnum]).buffer }], sendImmediately);
+
+    await promise;
+  }
+
+  #sampleRate!: number;
+  get sampleRate() {
+    return this.#sampleRate;
+  }
+  #parseSampleRate(dataView: DataView) {
+    _console.log("parseSampleRate", dataView);
+    const sampleRate = dataView.getUint16(0, true);
+    this.#updateSampleRate(sampleRate);
+  }
+  #updateSampleRate(sampleRate: number) {
+    _console.log({ sampleRate });
+    this.#sampleRate = sampleRate;
+    this.#dispatchEvent("getTfliteSampleRate", { tfliteSampleRate: sampleRate });
+  }
+  async setSampleRate(newSampleRate: number, sendImmediately?: boolean) {
+    _console.assertTypeWithError(newSampleRate, "number");
+    newSampleRate -= newSampleRate % SensorRateStep;
+    _console.assertWithError(
+      newSampleRate >= SensorRateStep,
+      `sampleRate must be multiple of ${SensorRateStep} greater than 0 (got ${newSampleRate})`
+    );
+    if (this.#sampleRate == newSampleRate) {
+      _console.log(`redundant sampleRate assignment ${newSampleRate}`);
+      return;
+    }
+
+    const promise = this.waitForEvent("getTfliteSampleRate");
+
+    const dataView = new DataView(new ArrayBuffer(2));
+    dataView.setUint16(0, newSampleRate, true);
+    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}"`);
+  }
+
+  #sensorTypes: SensorType[] = [];
+  get sensorTypes() {
+    return this.#sensorTypes.slice();
+  }
+  #parseSensorTypes(dataView: DataView) {
+    _console.log("parseSensorTypes", dataView);
+    const sensorTypes: SensorType[] = [];
+    for (let index = 0; index < dataView.byteLength; index++) {
+      const sensorTypeEnum = dataView.getUint8(index);
+      const sensorType = SensorTypes[sensorTypeEnum];
+      if (sensorType) {
+        sensorTypes.push(sensorType);
+      } else {
+        _console.error(`invalid sensorTypeEnum ${sensorTypeEnum}`);
+      }
+    }
+    this.#updateSensorTypes(sensorTypes);
+  }
+  #updateSensorTypes(sensorTypes: SensorType[]) {
+    _console.log({ sensorTypes });
+    this.#sensorTypes = sensorTypes;
+    this.#dispatchEvent("getTfliteSensorTypes", { tfliteSensorTypes: sensorTypes });
+  }
+  async setSensorTypes(newSensorTypes: SensorType[], sendImmediately?: boolean) {
+    newSensorTypes.forEach((sensorType) => {
+      TfliteManager.AssertValidSensorType(sensorType);
+    });
+
+    const promise = this.waitForEvent("getTfliteSensorTypes");
+
+    newSensorTypes = arrayWithoutDuplicates(newSensorTypes);
+    const newSensorTypeEnums = newSensorTypes.map((sensorType) => SensorTypes.indexOf(sensorType)).sort();
+    _console.log(newSensorTypes, newSensorTypeEnums);
+    this.sendMessage(
+      [{ type: "setTfliteSensorTypes", data: Uint8Array.from(newSensorTypeEnums).buffer }],
+      sendImmediately
+    );
+
+    await promise;
+  }
+
+  #isReady!: boolean;
+  get isReady() {
+    return this.#isReady;
+  }
+  #parseIsReady(dataView: DataView) {
+    _console.log("parseIsReady", dataView);
+    const isReady = Boolean(dataView.getUint8(0));
+    this.#updateIsReady(isReady);
+  }
+  #updateIsReady(isReady: boolean) {
+    _console.log({ isReady });
+    this.#isReady = isReady;
+    this.#dispatchEvent("tfliteIsReady", { tfliteIsReady: isReady });
+  }
+  #assertIsReady() {
+    _console.assertWithError(this.isReady, `tflite is not ready`);
+  }
+
+  #captureDelay!: number;
+  get captureDelay() {
+    return this.#captureDelay;
+  }
+  #parseCaptureDelay(dataView: DataView) {
+    _console.log("parseCaptureDelay", dataView);
+    const captureDelay = dataView.getUint16(0, true);
+    this.#updateCaptueDelay(captureDelay);
+  }
+  #updateCaptueDelay(captureDelay: number) {
+    _console.log({ captureDelay });
+    this.#captureDelay = captureDelay;
+    this.#dispatchEvent("getTfliteCaptureDelay", { tfliteCaptureDelay: captureDelay });
+  }
+  async setCaptureDelay(newCaptureDelay: number, sendImmediately: boolean) {
+    _console.assertTypeWithError(newCaptureDelay, "number");
+    if (this.#captureDelay == newCaptureDelay) {
+      _console.log(`redundant captureDelay assignment ${newCaptureDelay}`);
+      return;
+    }
+
+    const promise = this.waitForEvent("getTfliteCaptureDelay");
+
+    const dataView = new DataView(new ArrayBuffer(2));
+    dataView.setUint16(0, newCaptureDelay, true);
+    this.sendMessage([{ type: "setTfliteCaptureDelay", data: dataView.buffer }], sendImmediately);
+
+    await promise;
+  }
+
+  #threshold!: number;
+  get threshold() {
+    return this.#threshold;
+  }
+  #parseThreshold(dataView: DataView) {
+    _console.log("parseThreshold", dataView);
+    const threshold = dataView.getFloat32(0, true);
+    this.#updateThreshold(threshold);
+  }
+  #updateThreshold(threshold: number) {
+    _console.log({ threshold });
+    this.#threshold = threshold;
+    this.#dispatchEvent("getTfliteThreshold", { tfliteThreshold: threshold });
+  }
+  async setThreshold(newThreshold: number, sendImmediately: boolean) {
+    _console.assertTypeWithError(newThreshold, "number");
+    _console.assertWithError(newThreshold >= 0, `threshold must be positive (got ${newThreshold})`);
+    if (this.#threshold == newThreshold) {
+      _console.log(`redundant threshold assignment ${newThreshold}`);
+      return;
+    }
+
+    const promise = this.waitForEvent("getTfliteThreshold");
+
+    const dataView = new DataView(new ArrayBuffer(4));
+    dataView.setFloat32(0, newThreshold, true);
+    this.sendMessage([{ type: "setTfliteThreshold", data: dataView.buffer }], sendImmediately);
+
+    await promise;
+  }
+
+  #inferencingEnabled!: boolean;
+  get inferencingEnabled() {
+    return this.#inferencingEnabled;
+  }
+  #parseInferencingEnabled(dataView: DataView) {
+    _console.log("parseInferencingEnabled", dataView);
+    const inferencingEnabled = Boolean(dataView.getUint8(0));
+    this.#updateInferencingEnabled(inferencingEnabled);
+  }
+  #updateInferencingEnabled(inferencingEnabled: boolean) {
+    _console.log({ inferencingEnabled });
+    this.#inferencingEnabled = inferencingEnabled;
+    this.#dispatchEvent("getTfliteInferencingEnabled", { tfliteInferencingEnabled: inferencingEnabled });
+  }
+  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}`);
+      return;
+    }
+
+    const promise = this.waitForEvent("getTfliteInferencingEnabled");
+
+    this.sendMessage(
+      [
+        {
+          type: "setTfliteInferencingEnabled",
+          data: Uint8Array.from([Number(newInferencingEnabled)]).buffer,
+        },
+      ],
+      sendImmediately
+    );
+
+    await promise;
+  }
+  async toggleInferencingEnabled() {
+    return this.setInferencingEnabled(!this.inferencingEnabled);
+  }
+
+  async enableInferencing() {
+    if (this.inferencingEnabled) {
+      return;
+    }
+    this.setInferencingEnabled(true);
+  }
+  async disableInferencing() {
+    if (!this.inferencingEnabled) {
+      return;
+    }
+    this.setInferencingEnabled(false);
+  }
+
+  #parseInference(dataView: DataView) {
+    _console.log("parseInference", dataView);
+
+    const timestamp = parseTimestamp(dataView, 0);
+    _console.log({ timestamp });
+
+    const values: number[] = [];
+    for (let index = 0, byteOffset = 2; byteOffset < dataView.byteLength; index++, byteOffset += 4) {
+      const value = dataView.getFloat32(byteOffset, true);
+      values.push(value);
+    }
+    _console.log("values", values);
+
+    const inference: TfliteInference = {
+      timestamp,
+      values,
+    };
+
+    if (this.task == "classification") {
+      let maxValue = 0;
+      let maxIndex = 0;
+      values.forEach((value, index) => {
+        if (value > maxValue) {
+          maxValue = value;
+          maxIndex = index;
+        }
+      });
+      _console.log({ maxIndex, maxValue });
+      inference.maxIndex = maxIndex;
+      inference.maxValue = maxValue;
+    }
+
+    this.#dispatchEvent("tfliteInference", { tfliteInference: inference });
+  }
+
+  parseMessage(messageType: TfliteMessageType, dataView: DataView) {
+    _console.log({ messageType });
+
+    switch (messageType) {
+      case "getTfliteName":
+      case "setTfliteName":
+        this.#parseName(dataView);
+        break;
+      case "getTfliteTask":
+      case "setTfliteTask":
+        this.#parseTask(dataView);
+        break;
+      case "getTfliteSampleRate":
+      case "setTfliteSampleRate":
+        this.#parseSampleRate(dataView);
+        break;
+      case "getTfliteSensorTypes":
+      case "setTfliteSensorTypes":
+        this.#parseSensorTypes(dataView);
+        break;
+      case "tfliteIsReady":
+        this.#parseIsReady(dataView);
+        break;
+      case "getTfliteCaptureDelay":
+      case "setTfliteCaptureDelay":
+        this.#parseCaptureDelay(dataView);
+        break;
+      case "getTfliteThreshold":
+      case "setTfliteThreshold":
+        this.#parseThreshold(dataView);
+        break;
+      case "getTfliteInferencingEnabled":
+      case "setTfliteInferencingEnabled":
+        this.#parseInferencingEnabled(dataView);
+        break;
+      case "tfliteInference":
+        this.#parseInference(dataView);
+        break;
+      default:
+        throw Error(`uncaught messageType ${messageType}`);
+    }
+  }
+}
+
+export default TfliteManager;

package/src/connection/BaseConnectionManager.ts

@@ -0,0 +1,255 @@
+import { createConsole } from "../utils/Console.ts";
+import Timer from "../utils/Timer.ts";
+
+import { FileTransferMessageTypes } from "../FileTransferManager.ts";
+import { TfliteMessageTypes } from "../TfliteManager.ts";
+import { concatenateArrayBuffers } from "../utils/ArrayBufferUtils.ts";
+import { parseMessage } from "../utils/ParseUtils.ts";
+import { DeviceInformationMessageTypes } from "../DeviceInformationManager.ts";
+import { InformationMessageTypes } from "../InformationManager.ts";
+import { VibrationMessageTypes } from "../vibration/VibrationManager.ts";
+import { SensorConfigurationMessageTypes } from "../sensor/SensorConfigurationManager.ts";
+import { SensorDataMessageTypes } from "../sensor/SensorDataManager.ts";
+
+const _console = createConsole("BaseConnectionManager", { log: true });
+
+export const ConnectionTypes = ["webBluetooth", "noble", "client"] as const;
+export type ConnectionType = (typeof ConnectionTypes)[number];
+
+export const ConnectionStatuses = ["notConnected", "connecting", "connected", "disconnecting"] as const;
+export type ConnectionStatus = (typeof ConnectionStatuses)[number];
+
+export const ConnectionEventTypes = [...ConnectionStatuses, "connectionStatus", "isConnected"] as const;
+export type ConnectionEventType = (typeof ConnectionEventTypes)[number];
+
+export interface ConnectionStatusEventMessages {
+  notConnected: any;
+  connecting: any;
+  connected: any;
+  disconnecting: any;
+  connectionStatus: { connectionStatus: ConnectionStatus };
+  isConnected: { isConnected: boolean };
+}
+
+export interface TxMessage {
+  type: TxRxMessageType;
+  data?: ArrayBuffer;
+}
+
+export const TxRxMessageTypes = [
+  ...InformationMessageTypes,
+  ...SensorConfigurationMessageTypes,
+  ...SensorDataMessageTypes,
+  ...VibrationMessageTypes,
+  ...TfliteMessageTypes,
+  ...FileTransferMessageTypes,
+] as const;
+export type TxRxMessageType = (typeof TxRxMessageTypes)[number];
+
+export const SMPMessageTypes = ["smp"] as const;
+export type SMPMessageType = (typeof SMPMessageTypes)[number];
+
+export const BatteryLevelMessageTypes = ["batteryLevel"] as const;
+export type BatteryLevelMessageType = (typeof BatteryLevelMessageTypes)[number];
+
+export const MetaConnectionMessageTypes = ["rx", "tx"] as const;
+export type MetaConnectionMessageType = (typeof MetaConnectionMessageTypes)[number];
+
+export const ConnectionMessageTypes = [
+  ...BatteryLevelMessageTypes,
+  ...DeviceInformationMessageTypes,
+  ...MetaConnectionMessageTypes,
+  ...TxRxMessageTypes,
+  ...SMPMessageTypes,
+] as const;
+export type ConnectionMessageType = (typeof ConnectionMessageTypes)[number];
+
+export type ConnectionStatusCallback = (status: ConnectionStatus) => void;
+export type MessageReceivedCallback = (messageType: ConnectionMessageType, dataView: DataView) => void;
+
+abstract class BaseConnectionManager {
+  static #AssertValidTxRxMessageType(messageType: TxRxMessageType) {
+    _console.assertEnumWithError(messageType, TxRxMessageTypes);
+  }
+
+  abstract get bluetoothId(): string;
+
+  // CALLBACKS
+  onStatusUpdated?: ConnectionStatusCallback;
+  onMessageReceived?: MessageReceivedCallback;
+
+  protected get baseConstructor() {
+    return this.constructor as typeof BaseConnectionManager;
+  }
+  static get isSupported() {
+    return false;
+  }
+  get isSupported() {
+    return this.baseConstructor.isSupported;
+  }
+
+  static type: ConnectionType;
+  get type(): ConnectionType {
+    return this.baseConstructor.type;
+  }
+
+  /** @throws {Error} if not supported */
+  #assertIsSupported() {
+    _console.assertWithError(this.isSupported, `${this.constructor.name} is not supported`);
+  }
+
+  constructor() {
+    this.#assertIsSupported();
+  }
+
+  #status: ConnectionStatus = "notConnected";
+  get status() {
+    return this.#status;
+  }
+  protected set status(newConnectionStatus) {
+    _console.assertEnumWithError(newConnectionStatus, ConnectionStatuses);
+    if (this.#status == newConnectionStatus) {
+      _console.log(`tried to assign same connection status "${newConnectionStatus}"`);
+      return;
+    }
+    _console.log(`new connection status "${newConnectionStatus}"`);
+    this.#status = newConnectionStatus;
+    this.onStatusUpdated!(this.status);
+
+    if (this.isConnected) {
+      this.#timer.start();
+    } else {
+      this.#timer.stop();
+    }
+
+    if (this.#status == "notConnected") {
+      this.mtu = undefined;
+    }
+  }
+
+  get isConnected() {
+    return this.status == "connected";
+  }
+
+  /** @throws {Error} if connected */
+  #assertIsNotConnected() {
+    _console.assertWithError(!this.isConnected, "device is already connected");
+  }
+  /** @throws {Error} if connecting */
+  #assertIsNotConnecting() {
+    _console.assertWithError(this.status != "connecting", "device is already connecting");
+  }
+  /** @throws {Error} if not connected */
+  #assertIsConnected() {
+    _console.assertWithError(this.isConnected, "device is not connected");
+  }
+  /** @throws {Error} if disconnecting */
+  #assertIsNotDisconnecting() {
+    _console.assertWithError(this.status != "disconnecting", "device is already disconnecting");
+  }
+  /** @throws {Error} if not connected or is disconnecting */
+  #assertIsConnectedAndNotDisconnecting() {
+    this.#assertIsConnected();
+    this.#assertIsNotDisconnecting();
+  }
+
+  async connect() {
+    this.#assertIsNotConnected();
+    this.#assertIsNotConnecting();
+    this.status = "connecting";
+  }
+  get canReconnect() {
+    return false;
+  }
+  async reconnect() {
+    this.#assertIsNotConnected();
+    this.#assertIsNotConnecting();
+    _console.assert(this.canReconnect, "unable to reconnect");
+  }
+  async disconnect() {
+    this.#assertIsConnected();
+    this.#assertIsNotDisconnecting();
+    this.status = "disconnecting";
+    _console.log("disconnecting from device...");
+  }
+
+  async sendSmpMessage(data: ArrayBuffer) {
+    this.#assertIsConnectedAndNotDisconnecting();
+    _console.log("sending smp message", data);
+  }
+
+  #pendingMessages: TxMessage[] = [];
+
+  async sendTxMessages(messages: TxMessage[] | undefined, sendImmediately: boolean = true) {
+    this.#assertIsConnectedAndNotDisconnecting();
+
+    if (messages) {
+      this.#pendingMessages.push(...messages);
+    }
+
+    if (!sendImmediately) {
+      return;
+    }
+
+    _console.log("sendTxMessages", this.#pendingMessages.slice());
+
+    const arrayBuffers = this.#pendingMessages.map((message) => {
+      BaseConnectionManager.#AssertValidTxRxMessageType(message.type);
+      const messageTypeEnum = TxRxMessageTypes.indexOf(message.type);
+      const dataLength = new DataView(new ArrayBuffer(2));
+      dataLength.setUint16(0, message.data?.byteLength || 0, true);
+      return concatenateArrayBuffers(messageTypeEnum, dataLength, message.data);
+    });
+
+    if (this.mtu) {
+      while (arrayBuffers.length > 0) {
+        let arrayBufferByteLength = 0;
+        let arrayBufferCount = 0;
+        arrayBuffers.some((arrayBuffer) => {
+          if (arrayBufferByteLength + arrayBuffer.byteLength > this.mtu! - 3) {
+            return true;
+          }
+          arrayBufferCount++;
+          arrayBufferByteLength += arrayBuffer.byteLength;
+        });
+        const arrayBuffersToSend = arrayBuffers.splice(0, arrayBufferCount);
+        _console.log({ arrayBufferCount, arrayBuffersToSend });
+
+        const arrayBuffer = concatenateArrayBuffers(...arrayBuffersToSend);
+        _console.log("sending arrayBuffer", arrayBuffer);
+        await this.sendTxData(arrayBuffer);
+      }
+    } else {
+      const arrayBuffer = concatenateArrayBuffers(...arrayBuffers);
+      _console.log("sending arrayBuffer", arrayBuffer);
+      await this.sendTxData(arrayBuffer);
+    }
+    this.#pendingMessages.length = 0;
+  }
+
+  mtu?: number;
+
+  async sendTxData(data: ArrayBuffer) {
+    _console.log("sendTxData", data);
+  }
+
+  parseRxMessage(dataView: DataView) {
+    parseMessage(dataView, TxRxMessageTypes, this.#onRxMessage.bind(this), null, true);
+  }
+
+  #onRxMessage(messageType: TxRxMessageType, dataView: DataView) {
+    _console.log({ messageType, dataView });
+    this.onMessageReceived!(messageType, dataView);
+  }
+
+  #timer = new Timer(this.#checkConnection.bind(this), 5000);
+  #checkConnection() {
+    //console.log("checking connection...");
+    if (!this.isConnected) {
+      _console.log("timer detected disconnection");
+      this.status = "notConnected";
+    }
+  }
+}
+
+export default BaseConnectionManager;