brilliantsole 0.0.1

package/src/scanner/NobleScanner.ts

@@ -0,0 +1,195 @@
+import BaseScanner, { DiscoveredDevice, ScannerEventMap } from "./BaseScanner.ts";
+import { createConsole } from "../utils/Console.ts";
+import { addEventListeners } from "../utils/EventUtils.ts";
+import { serviceDataUUID, serviceUUIDs } from "../connection/bluetooth/bluetoothUUIDs.ts";
+import Device from "../Device.ts";
+import NobleConnectionManager, { NoblePeripheral } from "../connection/bluetooth/NobleConnectionManager.ts";
+
+const _console = createConsole("NobleScanner", { log: true });
+
+let isSupported = false;
+
+/** NODE_START */
+import noble from "@abandonware/noble";
+import { DeviceTypes } from "../InformationManager.ts";
+import DeviceManager from "../DeviceManager.ts";
+isSupported = true;
+/** NODE_END */
+
+export const NobleStates = ["unknown", "resetting", "unsupported", "unauthorized", "poweredOff", "poweredOn"] as const;
+export type NobleState = (typeof NobleStates)[number];
+
+class NobleScanner extends BaseScanner {
+  static get isSupported() {
+    return isSupported;
+  }
+
+  // SCANNING
+  #_isScanning = false;
+  get #isScanning() {
+    return this.#_isScanning;
+  }
+  set #isScanning(newIsScanning) {
+    _console.assertTypeWithError(newIsScanning, "boolean");
+    if (this.isScanning == newIsScanning) {
+      _console.log("duplicate isScanning assignment");
+      return;
+    }
+    this.#_isScanning = newIsScanning;
+    this.dispatchEvent("isScanning", { isScanning: this.isScanning });
+  }
+  get isScanning() {
+    return this.#isScanning;
+  }
+
+  // NOBLE STATE
+  #_nobleState: NobleState = "unknown";
+  get #nobleState() {
+    return this.#_nobleState;
+  }
+  set #nobleState(newNobleState) {
+    _console.assertTypeWithError(newNobleState, "string");
+    if (this.#nobleState == newNobleState) {
+      _console.log("duplicate nobleState assignment");
+      return;
+    }
+    this.#_nobleState = newNobleState;
+    _console.log({ newNobleState });
+    this.dispatchEvent("isScanningAvailable", { isScanningAvailable: this.isScanningAvailable });
+  }
+
+  // NOBLE LISTENERS
+  #boundNobleListeners = {
+    scanStart: this.#onNobleScanStart.bind(this),
+    scanStop: this.#onNobleScanStop.bind(this),
+    stateChange: this.#onNobleStateChange.bind(this),
+    discover: this.#onNobleDiscover.bind(this),
+  };
+  #onNobleScanStart() {
+    _console.log("OnNobleScanStart");
+    this.#isScanning = true;
+  }
+  #onNobleScanStop() {
+    _console.log("OnNobleScanStop");
+    this.#isScanning = false;
+  }
+  #onNobleStateChange(state: NobleState) {
+    _console.log("onNobleStateChange", state);
+    this.#nobleState = state;
+  }
+  #onNobleDiscover(noblePeripheral: NoblePeripheral) {
+    _console.log("onNobleDiscover", noblePeripheral.id);
+    if (!this.#noblePeripherals[noblePeripheral.id]) {
+      noblePeripheral.scanner = this;
+      this.#noblePeripherals[noblePeripheral.id] = noblePeripheral;
+    }
+
+    let deviceType;
+    const serviceData = noblePeripheral.advertisement.serviceData;
+    if (serviceData) {
+      //_console.log("serviceData", serviceData);
+      const deviceTypeServiceData = serviceData.find((serviceDatum) => {
+        return serviceDatum.uuid == serviceDataUUID;
+      });
+      //_console.log("deviceTypeServiceData", deviceTypeServiceData);
+      if (deviceTypeServiceData) {
+        const deviceTypeEnum = deviceTypeServiceData.data.readUint8(0);
+        deviceType = DeviceTypes[deviceTypeEnum];
+      }
+    }
+    if (deviceType == undefined) {
+      return;
+    }
+
+    const discoveredDevice: DiscoveredDevice = {
+      name: noblePeripheral.advertisement.localName,
+      bluetoothId: noblePeripheral.id,
+      deviceType,
+      rssi: noblePeripheral.rssi,
+    };
+    this.dispatchEvent("discoveredDevice", { discoveredDevice });
+  }
+
+  // CONSTRUCTOR
+  constructor() {
+    super();
+    addEventListeners(noble, this.#boundNobleListeners);
+    addEventListeners(this, this.#boundBaseScannerListeners);
+  }
+
+  // AVAILABILITY
+  get isScanningAvailable() {
+    return this.#nobleState == "poweredOn";
+  }
+
+  // SCANNING
+  startScan() {
+    super.startScan();
+    noble.startScanningAsync(serviceUUIDs as string[], true);
+  }
+  stopScan() {
+    super.stopScan();
+    noble.stopScanningAsync();
+  }
+
+  // RESET
+  get canReset() {
+    return true;
+  }
+  reset() {
+    super.reset();
+    noble.reset();
+  }
+
+  // BASESCANNER LISTENERS
+  #boundBaseScannerListeners = {
+    expiredDiscoveredDevice: this.#onExpiredDiscoveredDevice.bind(this),
+  };
+
+  #onExpiredDiscoveredDevice(event: ScannerEventMap["expiredDiscoveredDevice"]) {
+    const { discoveredDevice } = event.message;
+    const noblePeripheral = this.#noblePeripherals[discoveredDevice.bluetoothId];
+    if (noblePeripheral) {
+      // disconnect?
+      delete this.#noblePeripherals[discoveredDevice.bluetoothId];
+    }
+  }
+
+  // DISCOVERED DEVICES
+  #noblePeripherals: { [bluetoothId: string]: NoblePeripheral } = {};
+  #assertValidNoblePeripheralId(noblePeripheralId: string) {
+    _console.assertTypeWithError(noblePeripheralId, "string");
+    _console.assertWithError(
+      this.#noblePeripherals[noblePeripheralId],
+      `no noblePeripheral found with id "${noblePeripheralId}"`
+    );
+  }
+
+  // DEVICES
+  async connectToDevice(deviceId: string) {
+    super.connectToDevice(deviceId);
+    this.#assertValidNoblePeripheralId(deviceId);
+    const noblePeripheral = this.#noblePeripherals[deviceId];
+    _console.log("connecting to discoveredDevice...", deviceId);
+
+    let device = DeviceManager.AvailableDevices.filter((device) => device.connectionType == "noble").find(
+      (device) => device.bluetoothId == deviceId
+    );
+    if (!device) {
+      device = this.#createDevice(noblePeripheral);
+      await device.connect();
+    } else {
+      await device.reconnect();
+    }
+  }
+
+  #createDevice(noblePeripheral: NoblePeripheral) {
+    const device = new Device();
+    const nobleConnectionManager = new NobleConnectionManager();
+    nobleConnectionManager.noblePeripheral = noblePeripheral;
+    device.connectionManager = nobleConnectionManager;
+    return device;
+  }
+}
+
+export default NobleScanner;

package/src/scanner/Scanner.ts

@@ -0,0 +1,16 @@
+import { createConsole } from "../utils/Console.ts";
+import NobleScanner from "./NobleScanner.ts";
+import BaseScanner from "./BaseScanner.ts";
+
+const _console = createConsole("Scanner", { log: false });
+
+let scanner: BaseScanner | undefined;
+
+if (NobleScanner.isSupported) {
+  _console.log("using NobleScanner");
+  scanner = new NobleScanner() as BaseScanner;
+} else {
+  _console.log("Scanner not available");
+}
+
+export default scanner;

package/src/sensor/BarometerSensorDataManager.ts

@@ -0,0 +1,41 @@
+import { createConsole } from "../utils/Console.ts";
+
+export const BarometerSensorTypes = ["barometer"] as const;
+export type BarometerSensorType = (typeof BarometerSensorTypes)[number];
+
+export const ContinuousBarometerSensorTypes = BarometerSensorTypes;
+export type ContinuousBarometerSensorType = (typeof ContinuousBarometerSensorTypes)[number];
+
+export interface BarometerSensorDataEventMessages {
+  barometer: {
+    barometer: number;
+    //altitude: number;
+  };
+}
+
+const _console = createConsole("BarometerSensorDataManager", { log: true });
+
+class BarometerSensorDataManager {
+  #calculcateAltitude(pressure: number) {
+    const P0 = 101325; // Standard atmospheric pressure at sea level in Pascals
+    const T0 = 288.15; // Standard temperature at sea level in Kelvin
+    const L = 0.0065; // Temperature lapse rate in K/m
+    const R = 8.3144598; // Universal gas constant in J/(mol·K)
+    const g = 9.80665; // Acceleration due to gravity in m/s²
+    const M = 0.0289644; // Molar mass of Earth's air in kg/mol
+
+    const exponent = (R * L) / (g * M);
+    const h = (T0 / L) * (1 - Math.pow(pressure / P0, exponent));
+
+    return h;
+  }
+
+  parseData(dataView: DataView, scalar: number) {
+    const pressure = dataView.getUint32(0, true) * scalar;
+    const altitude = this.#calculcateAltitude(pressure);
+    _console.log({ pressure, altitude });
+    return { pressure };
+  }
+}
+
+export default BarometerSensorDataManager;

package/src/sensor/MotionSensorDataManager.ts

@@ -0,0 +1,151 @@
+import { createConsole } from "../utils/Console.ts";
+
+const _console = createConsole("MotionSensorDataManager", { log: true });
+
+export const MotionSensorTypes = [
+  "acceleration",
+  "gravity",
+  "linearAcceleration",
+  "gyroscope",
+  "magnetometer",
+  "gameRotation",
+  "rotation",
+  "orientation",
+  "activity",
+  "stepCounter",
+  "stepDetector",
+  "deviceOrientation",
+] as const;
+export type MotionSensorType = (typeof MotionSensorTypes)[number];
+
+export const ContinuousMotionTypes = [
+  "acceleration",
+  "gravity",
+  "linearAcceleration",
+  "gyroscope",
+  "magnetometer",
+  "gameRotation",
+  "rotation",
+] as const;
+export type ContinuousMotionType = (typeof ContinuousMotionTypes)[number];
+
+import { Vector3, Quaternion, Euler } from "../utils/MathUtils.ts";
+import { ValueOf } from "../utils/TypeScriptUtils.ts";
+
+export const Vector2Size = 2 * 2;
+export const Vector3Size = 3 * 2;
+export const QuaternionSize = 4 * 2;
+
+export const ActivityTypes = ["still", "walking", "running", "bicycle", "vehicle", "tilting"] as const;
+export type ActivityType = (typeof ActivityTypes)[number];
+
+export interface Activity {
+  still: boolean;
+  walking: boolean;
+  running: boolean;
+  bicycle: boolean;
+  vehicle: boolean;
+  tilting: boolean;
+}
+
+export const DeviceOrientations = [
+  "portraitUpright",
+  "landscapeLeft",
+  "portraitUpsideDown",
+  "landscapeRight",
+  "unknown",
+] as const;
+export type DeviceOrientation = (typeof DeviceOrientations)[number];
+
+export interface MotionSensorDataEventMessages {
+  acceleration: { acceleration: Vector3 };
+  gravity: { gravity: Vector3 };
+  linearAcceleration: { linearAcceleration: Vector3 };
+  gyroscope: { gyroscope: Vector3 };
+  magnetometer: { magnetometer: Vector3 };
+  gameRotation: { gameRotation: Quaternion };
+  rotation: { rotation: Quaternion };
+  orientation: { orientation: Euler };
+  stepDetector: { stepDetector: Object };
+  stepCounter: { stepCounter: number };
+  activity: { activity: Activity };
+  deviceOrientation: { deviceOrientation: DeviceOrientation };
+}
+
+export type MotionSensorDataEventMessage = ValueOf<MotionSensorDataEventMessages>;
+
+class MotionSensorDataManager {
+  parseVector3(dataView: DataView, scalar: number): Vector3 {
+    let [x, y, z] = [dataView.getInt16(0, true), dataView.getInt16(2, true), dataView.getInt16(4, true)].map(
+      (value) => value * scalar
+    );
+
+    const vector: Vector3 = { x, y, z };
+
+    _console.log({ vector });
+    return vector;
+  }
+
+  parseQuaternion(dataView: DataView, scalar: number): Quaternion {
+    let [x, y, z, w] = [
+      dataView.getInt16(0, true),
+      dataView.getInt16(2, true),
+      dataView.getInt16(4, true),
+      dataView.getInt16(6, true),
+    ].map((value) => value * scalar);
+
+    const quaternion: Quaternion = { x, y, z, w };
+
+    _console.log({ quaternion });
+    return quaternion;
+  }
+
+  parseEuler(dataView: DataView, scalar: number): Euler {
+    let [heading, pitch, roll] = [
+      dataView.getInt16(0, true),
+      dataView.getInt16(2, true),
+      dataView.getInt16(4, true),
+    ].map((value) => value * scalar);
+
+    pitch *= -1;
+    heading *= -1;
+
+    const euler: Euler = { heading, pitch, roll };
+
+    _console.log({ euler });
+    return euler;
+  }
+
+  parseStepCounter(dataView: DataView) {
+    _console.log("parseStepCounter", dataView);
+    const stepCount = dataView.getUint32(0, true);
+    _console.log({ stepCount });
+    return stepCount;
+  }
+
+  parseActivity(dataView: DataView) {
+    _console.log("parseActivity", dataView);
+    const activity: Partial<Activity> = {};
+
+    const activityBitfield = dataView.getUint8(0);
+    _console.log("activityBitfield", activityBitfield.toString(2));
+    ActivityTypes.forEach((activityType, index) => {
+      activity[activityType] = Boolean(activityBitfield & (1 << index));
+    });
+
+    _console.log("activity", activity);
+
+    return activity as Activity;
+  }
+
+  parseDeviceOrientation(dataView: DataView) {
+    _console.log("parseDeviceOrientation", dataView);
+    const index = dataView.getUint8(0);
+    const deviceOrientation = DeviceOrientations[index];
+    _console.assertWithError(deviceOrientation, "undefined deviceOrientation");
+    _console.log({ deviceOrientation });
+    return deviceOrientation;
+  }
+}
+
+export default MotionSensorDataManager;

package/src/sensor/PressureSensorDataManager.ts

@@ -0,0 +1,112 @@
+import { createConsole } from "../utils/Console.ts";
+import CenterOfPressureHelper from "../utils/CenterOfPressureHelper.ts";
+import RangeHelper from "../utils/RangeHelper.ts";
+import { createArray } from "../utils/ArrayUtils.ts";
+
+const _console = createConsole("PressureDataManager", { log: true });
+
+export const PressureSensorTypes = ["pressure"] as const;
+export type PressureSensorType = (typeof PressureSensorTypes)[number];
+
+export const ContinuousPressureSensorTypes = PressureSensorTypes;
+export type ContinuousPressureSensorType = (typeof ContinuousPressureSensorTypes)[number];
+
+import { Vector2 } from "../utils/MathUtils.ts";
+export type PressureSensorPosition = Vector2;
+
+import { CenterOfPressure } from "../utils/CenterOfPressureHelper.ts";
+
+export interface PressureSensorValue {
+  position: PressureSensorPosition;
+  rawValue: number;
+  scaledValue: number;
+  normalizedValue: number;
+  weightedValue: number;
+}
+
+export interface PressureData {
+  sensors: PressureSensorValue[];
+  scaledSum: number;
+  normalizedSum: number;
+  center?: CenterOfPressure;
+  normalizedCenter?: CenterOfPressure;
+}
+
+export interface PressureDataEventMessages {
+  pressure: { pressure: PressureData };
+}
+
+export const DefaultNumberOfPressureSensors = 8;
+
+class PressureSensorDataManager {
+  #positions: PressureSensorPosition[] = [];
+  get positions() {
+    return this.#positions;
+  }
+
+  get numberOfSensors() {
+    return this.positions.length;
+  }
+
+  parsePositions(dataView: DataView) {
+    const positions: PressureSensorPosition[] = [];
+
+    for (
+      let pressureSensorIndex = 0, byteOffset = 0;
+      byteOffset < dataView.byteLength;
+      pressureSensorIndex++, byteOffset += 2
+    ) {
+      positions.push({
+        x: dataView.getUint8(byteOffset) / 2 ** 8,
+        y: dataView.getUint8(byteOffset + 1) / 2 ** 8,
+      });
+    }
+
+    _console.log({ positions });
+
+    this.#positions = positions;
+
+    this.#sensorRangeHelpers = createArray(this.numberOfSensors, () => new RangeHelper());
+
+    this.resetRange();
+  }
+
+  #sensorRangeHelpers!: RangeHelper[];
+
+  #centerOfPressureHelper = new CenterOfPressureHelper();
+
+  resetRange() {
+    this.#sensorRangeHelpers.forEach((rangeHelper) => rangeHelper.reset());
+    this.#centerOfPressureHelper.reset();
+  }
+
+  parseData(dataView: DataView, scalar: number) {
+    const pressure: PressureData = { sensors: [], scaledSum: 0, normalizedSum: 0 };
+    for (let index = 0, byteOffset = 0; byteOffset < dataView.byteLength; index++, byteOffset += 2) {
+      const rawValue = dataView.getUint16(byteOffset, true);
+      const scaledValue = rawValue * scalar;
+      const rangeHelper = this.#sensorRangeHelpers[index];
+      const normalizedValue = rangeHelper.updateAndGetNormalization(scaledValue, true);
+      const position = this.positions[index];
+      pressure.sensors[index] = { rawValue, scaledValue, normalizedValue, position, weightedValue: 0 };
+
+      pressure.scaledSum += scaledValue;
+      pressure.normalizedSum += normalizedValue / this.numberOfSensors;
+    }
+
+    if (pressure.scaledSum > 0) {
+      pressure.center = { x: 0, y: 0 };
+      pressure.sensors.forEach((sensor) => {
+        sensor.weightedValue = sensor.scaledValue / pressure.scaledSum;
+        pressure.center!.x += sensor.position.x * sensor.weightedValue;
+        pressure.center!.y += sensor.position.y * sensor.weightedValue;
+      });
+      pressure.normalizedCenter = this.#centerOfPressureHelper.updateAndGetNormalization(pressure.center);
+    }
+
+    _console.log({ pressure });
+    return pressure;
+  }
+}
+
+export default PressureSensorDataManager;

package/src/sensor/SensorConfigurationManager.ts

@@ -0,0 +1,177 @@
+import { createConsole } from "../utils/Console.ts";
+import SensorDataManager, { SensorTypes, SensorType } from "./SensorDataManager.ts";
+import EventDispatcher from "../utils/EventDispatcher.ts";
+import Device, { SendMessageCallback } from "../Device.ts";
+import autoBind from "../../node_modules/auto-bind/index.js";
+
+const _console = createConsole("SensorConfigurationManager", { log: true });
+
+export type SensorConfiguration = { [sensorType in SensorType]?: number };
+
+export const MaxSensorRate = 2 ** 16 - 1;
+export const SensorRateStep = 5;
+
+export const SensorConfigurationMessageTypes = ["getSensorConfiguration", "setSensorConfiguration"] as const;
+export type SensorConfigurationMessageType = (typeof SensorConfigurationMessageTypes)[number];
+
+export const SensorConfigurationEventTypes = SensorConfigurationMessageTypes;
+export type SensorConfigurationEventType = (typeof SensorConfigurationEventTypes)[number];
+
+export interface SensorConfigurationEventMessages {
+  getSensorConfiguration: { sensorConfiguration: SensorConfiguration };
+}
+
+export type SensorConfigurationEventDispatcher = EventDispatcher<
+  Device,
+  SensorConfigurationEventType,
+  SensorConfigurationEventMessages
+>;
+
+export type SendSensorConfigurationMessageCallback = SendMessageCallback<SensorConfigurationMessageType>;
+
+class SensorConfigurationManager {
+  constructor() {
+    autoBind(this);
+  }
+
+  sendMessage!: SendSensorConfigurationMessageCallback;
+
+  eventDispatcher!: SensorConfigurationEventDispatcher;
+  get addEventListener() {
+    return this.eventDispatcher.addEventListener;
+  }
+  get #dispatchEvent() {
+    return this.eventDispatcher.dispatchEvent;
+  }
+  get waitForEvent() {
+    return this.eventDispatcher.waitForEvent;
+  }
+
+  #availableSensorTypes!: SensorType[];
+  #assertAvailableSensorType(sensorType: SensorType) {
+    _console.assertWithError(this.#availableSensorTypes, "must get initial sensorConfiguration");
+    const isSensorTypeAvailable = this.#availableSensorTypes?.includes(sensorType);
+    _console.assert(isSensorTypeAvailable, `unavailable sensor type "${sensorType}"`);
+    return isSensorTypeAvailable;
+  }
+
+  #configuration!: SensorConfiguration;
+  get configuration() {
+    return this.#configuration;
+  }
+
+  #updateConfiguration(updatedConfiguration: SensorConfiguration) {
+    this.#configuration = updatedConfiguration;
+    _console.log({ updatedConfiguration: this.#configuration });
+    this.#dispatchEvent("getSensorConfiguration", { sensorConfiguration: this.configuration });
+  }
+
+  #isRedundant(sensorConfiguration: SensorConfiguration) {
+    let sensorTypes = Object.keys(sensorConfiguration) as SensorType[];
+    return sensorTypes.every((sensorType) => {
+      return this.configuration[sensorType] == sensorConfiguration[sensorType];
+    });
+  }
+
+  async setConfiguration(newSensorConfiguration: SensorConfiguration, clearRest?: boolean) {
+    if (clearRest) {
+      newSensorConfiguration = Object.assign({ ...this.zeroSensorConfiguration }, newSensorConfiguration);
+    }
+    _console.log({ newSensorConfiguration });
+    if (this.#isRedundant(newSensorConfiguration)) {
+      _console.log("redundant sensor configuration");
+      return;
+    }
+    const setSensorConfigurationData = this.#createData(newSensorConfiguration);
+    _console.log({ setSensorConfigurationData });
+
+    const promise = this.waitForEvent("getSensorConfiguration");
+    this.sendMessage([{ type: "setSensorConfiguration", data: setSensorConfigurationData.buffer }]);
+    await promise;
+  }
+
+  #parse(dataView: DataView) {
+    const parsedSensorConfiguration: SensorConfiguration = {};
+    for (let byteOffset = 0; byteOffset < dataView.byteLength; byteOffset += 3) {
+      const sensorTypeIndex = dataView.getUint8(byteOffset);
+      const sensorType = SensorTypes[sensorTypeIndex];
+      if (!sensorType) {
+        _console.warn(`unknown sensorType index ${sensorTypeIndex}`);
+        continue;
+      }
+      const sensorRate = dataView.getUint16(byteOffset + 1, true);
+      _console.log({ sensorType, sensorRate });
+      parsedSensorConfiguration[sensorType] = sensorRate;
+    }
+    _console.log({ parsedSensorConfiguration });
+    this.#availableSensorTypes = Object.keys(parsedSensorConfiguration) as SensorType[];
+    return parsedSensorConfiguration;
+  }
+
+  static #AssertValidSensorRate(sensorRate: number) {
+    _console.assertTypeWithError(sensorRate, "number");
+    _console.assertWithError(sensorRate >= 0, `sensorRate must be 0 or greater (got ${sensorRate})`);
+    _console.assertWithError(sensorRate < MaxSensorRate, `sensorRate must be 0 or greater (got ${sensorRate})`);
+    _console.assertWithError(sensorRate % SensorRateStep == 0, `sensorRate must be multiple of ${SensorRateStep}`);
+  }
+
+  #assertValidSensorRate(sensorRate: number) {
+    SensorConfigurationManager.#AssertValidSensorRate(sensorRate);
+  }
+
+  #createData(sensorConfiguration: SensorConfiguration) {
+    let sensorTypes = Object.keys(sensorConfiguration) as SensorType[];
+    sensorTypes = sensorTypes.filter((sensorType) => this.#assertAvailableSensorType(sensorType));
+
+    const dataView = new DataView(new ArrayBuffer(sensorTypes.length * 3));
+    sensorTypes.forEach((sensorType, index) => {
+      SensorDataManager.AssertValidSensorType(sensorType);
+      const sensorTypeEnum = SensorTypes.indexOf(sensorType);
+      dataView.setUint8(index * 3, sensorTypeEnum);
+
+      const sensorRate = sensorConfiguration[sensorType]!;
+      this.#assertValidSensorRate(sensorRate);
+      dataView.setUint16(index * 3 + 1, sensorRate, true);
+    });
+    _console.log({ sensorConfigurationData: dataView });
+    return dataView;
+  }
+
+  // ZERO
+  static #ZeroSensorConfiguration: SensorConfiguration = {};
+  static get ZeroSensorConfiguration() {
+    return this.#ZeroSensorConfiguration;
+  }
+  static {
+    SensorTypes.forEach((sensorType) => {
+      this.#ZeroSensorConfiguration[sensorType] = 0;
+    });
+  }
+  get zeroSensorConfiguration() {
+    const zeroSensorConfiguration: SensorConfiguration = {};
+    SensorTypes.forEach((sensorType) => {
+      zeroSensorConfiguration[sensorType] = 0;
+    });
+    return zeroSensorConfiguration;
+  }
+  async clearSensorConfiguration() {
+    return this.setConfiguration(this.zeroSensorConfiguration);
+  }
+
+  // MESSAGE
+  parseMessage(messageType: SensorConfigurationMessageType, dataView: DataView) {
+    _console.log({ messageType });
+
+    switch (messageType) {
+      case "getSensorConfiguration":
+      case "setSensorConfiguration":
+        const newSensorConfiguration = this.#parse(dataView);
+        this.#updateConfiguration(newSensorConfiguration);
+        break;
+      default:
+        throw Error(`uncaught messageType ${messageType}`);
+    }
+  }
+}
+
+export default SensorConfigurationManager;