brilliantsole 0.0.26 → 0.0.28

package/src/devicePair/DevicePairPressureSensorDataManager.ts

@@ -1,16 +1,24 @@
 import { createConsole } from "../utils/Console.ts";
 import CenterOfPressureHelper from "../utils/CenterOfPressureHelper.ts";
-import { PressureData } from "../sensor/PressureSensorDataManager.ts";
+import {
+  PressureData,
+  PressureSensorPosition,
+  PressureSensorValue,
+} from "../sensor/PressureSensorDataManager.ts";
 import { CenterOfPressure } from "../utils/CenterOfPressureHelper.ts";
-import { InsoleSide, InsoleSides } from "../InformationManager.ts";
+import { Side, Sides } from "../InformationManager.ts";
 import { DeviceEventMap } from "../Device.ts";
+import { RangeHelper } from "../BS.ts";
 
-const _console = createConsole("DevicePairPressureSensorDataManager", { log: true });
+const _console = createConsole("DevicePairPressureSensorDataManager", {
+  log: false,
+});
 
-export type DevicePairRawPressureData = { [insoleSide in InsoleSide]: PressureData };
+export type DevicePairRawPressureData = { [side in Side]: PressureData };
 
 export interface DevicePairPressureData {
-  rawSum: number;
+  sensors: { [key in Side]: PressureSensorValue[] };
+  scaledSum: number;
   normalizedSum: number;
   center?: CenterOfPressure;
   normalizedCenter?: CenterOfPressure;
@@ -29,15 +37,22 @@ class DevicePairPressureSensorDataManager {
 
   #centerOfPressureHelper = new CenterOfPressureHelper();
 
+  #normalizedSumRangeHelper = new RangeHelper();
+
+  constructor() {
+    this.resetPressureRange();
+  }
+
   resetPressureRange() {
     this.#centerOfPressureHelper.reset();
+    this.#normalizedSumRangeHelper.reset();
   }
 
   onDevicePressureData(event: DeviceEventMap["pressure"]) {
     const { pressure } = event.message;
-    const insoleSide = event.target.insoleSide;
-    _console.log({ pressure, insoleSide });
-    this.#rawPressure[insoleSide] = pressure;
+    const { side } = event.target;
+    _console.log({ pressure, side });
+    this.#rawPressure[side] = pressure;
     if (this.#hasAllPressureData) {
       return this.#updatePressureData();
     } else {
@@ -46,33 +61,66 @@ class DevicePairPressureSensorDataManager {
   }
 
   get #hasAllPressureData() {
-    return InsoleSides.every((side) => side in this.#rawPressure);
+    return Sides.every((side) => side in this.#rawPressure);
   }
 
   #updatePressureData() {
-    const pressure: DevicePairPressureData = { rawSum: 0, normalizedSum: 0 };
-
-    InsoleSides.forEach((side) => {
-      pressure.rawSum += this.#rawPressure[side]!.scaledSum;
-      pressure.normalizedSum += this.#rawPressure[side]!.normalizedSum;
+    const pressure: DevicePairPressureData = {
+      scaledSum: 0,
+      normalizedSum: 0,
+      sensors: { left: [], right: [] },
+    };
+
+    Sides.forEach((side) => {
+      const sidePressure = this.#rawPressure[side]!;
+      pressure.scaledSum += sidePressure.scaledSum;
+      //pressure.normalizedSum += this.#rawPressure[side]!.normalizedSum;
     });
+    pressure.normalizedSum +=
+      this.#normalizedSumRangeHelper.updateAndGetNormalization(
+        pressure.scaledSum,
+        false
+      );
 
-    if (pressure.normalizedSum > 0.001) {
+    if (pressure.scaledSum > 0) {
       pressure.center = { x: 0, y: 0 };
-      InsoleSides.forEach((side) => {
+      Sides.forEach((side) => {
         const sidePressure = this.#rawPressure[side]!;
-        const normalizedPressureSumWeight = sidePressure.normalizedSum / pressure.normalizedSum;
-        if (normalizedPressureSumWeight > 0) {
-          if (sidePressure.normalizedCenter?.y != undefined) {
-            pressure.center!.y += sidePressure.normalizedCenter.y * normalizedPressureSumWeight;
-          }
-          if (side == "right") {
-            pressure.center!.x = normalizedPressureSumWeight;
+
+        if (false) {
+          const sidePressureWeight =
+            sidePressure.scaledSum / pressure.scaledSum;
+          if (sidePressureWeight > 0) {
+            if (sidePressure.normalizedCenter?.y != undefined) {
+              pressure.center!.y +=
+                sidePressure.normalizedCenter!.y * sidePressureWeight;
+            }
+            if (side == "right") {
+              pressure.center!.x = sidePressureWeight;
+            }
           }
+        } else {
+          sidePressure.sensors.forEach((sensor) => {
+            const _sensor: PressureSensorValue = { ...sensor };
+            _sensor.weightedValue = sensor.scaledValue / pressure.scaledSum;
+            let { x, y } = sensor.position;
+            x /= 2;
+            if (side == "right") {
+              x += 0.5;
+            }
+            _sensor.position = { x, y };
+            pressure.center!.x += _sensor.position.x * _sensor.weightedValue;
+            pressure.center!.y += _sensor.position.y * _sensor.weightedValue;
+            pressure.sensors[side].push(_sensor);
+          });
         }
       });
 
-      pressure.normalizedCenter = this.#centerOfPressureHelper.updateAndGetNormalization(pressure.center);
+      pressure.normalizedCenter =
+        this.#centerOfPressureHelper.updateAndGetNormalization(
+          pressure.center,
+          false
+        );
     }
 
     _console.log({ devicePairPressure: pressure });

package/src/devicePair/DevicePairSensorDataManager.ts

@@ -2,14 +2,14 @@ import DevicePairPressureSensorDataManager, {
   DevicePairPressureDataEventMessages,
 } from "./DevicePairPressureSensorDataManager.ts";
 import { createConsole } from "../utils/Console.ts";
-import { InsoleSide } from "../InformationManager.ts";
+import { Side } from "../InformationManager.ts";
 import { SensorType } from "../sensor/SensorDataManager.ts";
-import { DeviceEventMap, SpecificDeviceEvent } from "../Device.ts";
+import { DeviceEventMap } from "../Device.ts";
 import EventDispatcher from "../utils/EventDispatcher.ts";
 import DevicePair from "./DevicePair.ts";
 import { AddKeysAsPropertyToInterface, ExtendInterfaceValues, ValueOf } from "../utils/TypeScriptUtils.ts";
 
-const _console = createConsole("DevicePairSensorDataManager", { log: true });
+const _console = createConsole("DevicePairSensorDataManager", { log: false });
 
 export const DevicePairSensorTypes = ["pressure", "sensorData"] as const;
 export type DevicePairSensorType = (typeof DevicePairSensorTypes)[number];
@@ -17,7 +17,7 @@ export type DevicePairSensorType = (typeof DevicePairSensorTypes)[number];
 export const DevicePairSensorDataEventTypes = DevicePairSensorTypes;
 export type DevicePairSensorDataEventType = (typeof DevicePairSensorDataEventTypes)[number];
 
-export type DevicePairSensorDataTimestamps = { [insoleSide in InsoleSide]: number };
+export type DevicePairSensorDataTimestamps = { [side in Side]: number };
 
 interface BaseDevicePairSensorDataEventMessage {
   timestamps: DevicePairSensorDataTimestamps;
@@ -63,7 +63,7 @@ class DevicePairSensorDataManager {
     if (!this.#timestamps[sensorType]) {
       this.#timestamps[sensorType] = {};
     }
-    this.#timestamps[sensorType]![event.target.insoleSide] = timestamp;
+    this.#timestamps[sensorType]![event.target.side] = timestamp;
 
     let value;
     switch (sensorType) {

package/src/scanner/BaseScanner.ts

@@ -1,8 +1,13 @@
-import EventDispatcher, { BoundEventListeners, Event, EventMap } from "../utils/EventDispatcher.ts";
+import EventDispatcher, {
+  BoundEventListeners,
+  Event,
+  EventMap,
+} from "../utils/EventDispatcher.ts";
 import { addEventListeners } from "../utils/EventUtils.ts";
 import { createConsole } from "../utils/Console.ts";
 import Timer from "../utils/Timer.ts";
 import { DeviceType } from "../InformationManager.ts";
+import { ConnectionType } from "../connection/BaseConnectionManager.ts";
 
 const _console = createConsole("BaseScanner");
 
@@ -19,6 +24,8 @@ export interface DiscoveredDevice {
   name: string;
   deviceType: DeviceType;
   rssi: number;
+  ipAddress?: string;
+  isWifiSecure?: boolean;
 }
 
 interface ScannerDiscoveredDeviceEventMessage {
@@ -32,10 +39,26 @@ export interface ScannerEventMessages {
   isScanning: { isScanning: boolean };
 }
 
-export type ScannerEventDispatcher = EventDispatcher<BaseScanner, ScannerEventType, ScannerEventMessages>;
-export type ScannerEventMap = EventMap<BaseScanner, ScannerEventType, ScannerEventMessages>;
-export type ScannerEvent = Event<BaseScanner, ScannerEventType, ScannerEventMessages>;
-export type BoundScannerEventListeners = BoundEventListeners<BaseScanner, ScannerEventType, ScannerEventMessages>;
+export type ScannerEventDispatcher = EventDispatcher<
+  BaseScanner,
+  ScannerEventType,
+  ScannerEventMessages
+>;
+export type ScannerEventMap = EventMap<
+  BaseScanner,
+  ScannerEventType,
+  ScannerEventMessages
+>;
+export type ScannerEvent = Event<
+  BaseScanner,
+  ScannerEventType,
+  ScannerEventMessages
+>;
+export type BoundScannerEventListeners = BoundEventListeners<
+  BaseScanner,
+  ScannerEventType,
+  ScannerEventMessages
+>;
 
 export type DiscoveredDevicesMap = { [deviceId: string]: DiscoveredDevice };
 
@@ -52,12 +75,18 @@ abstract class BaseScanner {
   }
 
   #assertIsSupported() {
-    _console.assertWithError(this.isSupported, `${this.constructor.name} is not supported`);
+    _console.assertWithError(
+      this.isSupported,
+      `${this.constructor.name} is not supported`
+    );
   }
 
   // CONSTRUCTOR
   #assertIsSubclass() {
-    _console.assertWithError(this.constructor != BaseScanner, `${this.constructor.name} must be subclassed`);
+    _console.assertWithError(
+      this.constructor != BaseScanner,
+      `${this.constructor.name} must be subclassed`
+    );
   }
   constructor() {
     this.#assertIsSubclass();
@@ -71,7 +100,10 @@ abstract class BaseScanner {
   };
 
   // EVENT DISPATCHER
-  #eventDispatcher: ScannerEventDispatcher = new EventDispatcher(this as BaseScanner, ScannerEventTypes);
+  #eventDispatcher: ScannerEventDispatcher = new EventDispatcher(
+    this as BaseScanner,
+    ScannerEventTypes
+  );
   get addEventListener() {
     return this.#eventDispatcher.addEventListener;
   }
@@ -127,7 +159,10 @@ abstract class BaseScanner {
   }
   get discoveredDevicesArray() {
     return Object.values(this.#discoveredDevices).sort((a, b) => {
-      return this.#discoveredDeviceTimestamps[a.bluetoothId] - this.#discoveredDeviceTimestamps[b.bluetoothId];
+      return (
+        this.#discoveredDeviceTimestamps[a.bluetoothId] -
+        this.#discoveredDeviceTimestamps[b.bluetoothId]
+      );
     });
   }
   #assertValidDiscoveredDeviceId(discoveredDeviceId: string) {
@@ -153,7 +188,10 @@ abstract class BaseScanner {
   get #discoveredDeviceExpirationTimeout() {
     return BaseScanner.DiscoveredDeviceExpirationTimeout;
   }
-  #checkDiscoveredDevicesExpirationTimer = new Timer(this.#checkDiscoveredDevicesExpiration.bind(this), 1000);
+  #checkDiscoveredDevicesExpirationTimer = new Timer(
+    this.#checkDiscoveredDevicesExpiration.bind(this),
+    1000
+  );
   #checkDiscoveredDevicesExpiration() {
     const entries = Object.entries(this.#discoveredDevices);
     if (entries.length == 0) {
@@ -173,7 +211,7 @@ abstract class BaseScanner {
   }
 
   // DEVICE CONNECTION
-  async connectToDevice(deviceId: string) {
+  async connectToDevice(deviceId: string, connectionType?: ConnectionType) {
     this.#assertIsAvailable();
   }
 

package/src/scanner/NobleScanner.ts

@@ -1,11 +1,19 @@
-import BaseScanner, { DiscoveredDevice, ScannerEventMap } from "./BaseScanner.ts";
+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 {
+  serviceDataUUID,
+  serviceUUIDs,
+} from "../connection/bluetooth/bluetoothUUIDs.ts";
 import Device from "../Device.ts";
-import NobleConnectionManager, { NoblePeripheral } from "../connection/bluetooth/NobleConnectionManager.ts";
+import NobleConnectionManager, {
+  NoblePeripheral,
+} from "../connection/bluetooth/NobleConnectionManager.ts";
 
-const _console = createConsole("NobleScanner", { log: true });
+const _console = createConsole("NobleScanner", { log: false });
 
 let isSupported = false;
 
@@ -13,10 +21,21 @@ let isSupported = false;
 import noble from "@abandonware/noble";
 import { DeviceTypes } from "../InformationManager.ts";
 import DeviceManager from "../DeviceManager.ts";
+import {
+  ClientConnectionType,
+  ConnectionType,
+} from "../connection/BaseConnectionManager.ts";
 isSupported = true;
 /** NODE_END */
 
-export const NobleStates = ["unknown", "resetting", "unsupported", "unauthorized", "poweredOff", "poweredOn"] as const;
+export const NobleStates = [
+  "unknown",
+  "resetting",
+  "unsupported",
+  "unauthorized",
+  "poweredOff",
+  "poweredOn",
+] as const;
 export type NobleState = (typeof NobleStates)[number];
 
 class NobleScanner extends BaseScanner {
@@ -55,7 +74,9 @@ class NobleScanner extends BaseScanner {
     }
     this.#_nobleState = newNobleState;
     _console.log({ newNobleState });
-    this.dispatchEvent("isScanningAvailable", { isScanningAvailable: this.isScanningAvailable });
+    this.dispatchEvent("isScanningAvailable", {
+      isScanningAvailable: this.isScanningAvailable,
+    });
   }
 
   // NOBLE LISTENERS
@@ -84,12 +105,29 @@ class NobleScanner extends BaseScanner {
       this.#noblePeripherals[noblePeripheral.id] = noblePeripheral;
     }
 
+    _console.log("advertisement", noblePeripheral.advertisement);
+
     let deviceType;
+    let ipAddress;
+    let isWifiSecure;
     const { manufacturerData, serviceData } = noblePeripheral.advertisement;
     if (manufacturerData) {
       _console.log("manufacturerData", manufacturerData);
-      const deviceTypeEnum = manufacturerData.readUint8(manufacturerData.byteLength - 1);
-      deviceType = DeviceTypes[deviceTypeEnum];
+      if (manufacturerData.byteLength >= 3) {
+        const deviceTypeEnum = manufacturerData.readUint8(2);
+        deviceType = DeviceTypes[deviceTypeEnum];
+        _console;
+      }
+      if (manufacturerData.byteLength >= 3 + 4) {
+        ipAddress = new Uint8Array(
+          manufacturerData.buffer.slice(3, 3 + 4)
+        ).join(".");
+        //_console.log({ ipAddress });
+      }
+      if (manufacturerData.byteLength >= 3 + 4 + 1) {
+        isWifiSecure = manufacturerData.readUint8(3 + 4) != 0;
+        _console.log({ isWifiSecure });
+      }
     }
     if (serviceData) {
       _console.log("serviceData", serviceData);
@@ -103,6 +141,7 @@ class NobleScanner extends BaseScanner {
       }
     }
     if (deviceType == undefined) {
+      _console.log("skipping device - no deviceType");
       return;
     }
 
@@ -111,6 +150,8 @@ class NobleScanner extends BaseScanner {
       bluetoothId: noblePeripheral.id,
       deviceType,
       rssi: noblePeripheral.rssi,
+      ipAddress,
+      isWifiSecure,
     };
     this.dispatchEvent("discoveredDevice", { discoveredDevice });
   }
@@ -151,9 +192,12 @@ class NobleScanner extends BaseScanner {
     expiredDiscoveredDevice: this.#onExpiredDiscoveredDevice.bind(this),
   };
 
-  #onExpiredDiscoveredDevice(event: ScannerEventMap["expiredDiscoveredDevice"]) {
+  #onExpiredDiscoveredDevice(
+    event: ScannerEventMap["expiredDiscoveredDevice"]
+  ) {
     const { discoveredDevice } = event.message;
-    const noblePeripheral = this.#noblePeripherals[discoveredDevice.bluetoothId];
+    const noblePeripheral =
+      this.#noblePeripherals[discoveredDevice.bluetoothId];
     if (noblePeripheral) {
       // disconnect?
       delete this.#noblePeripherals[discoveredDevice.bluetoothId];
@@ -171,20 +215,40 @@ class NobleScanner extends BaseScanner {
   }
 
   // DEVICES
-  async connectToDevice(deviceId: string) {
-    super.connectToDevice(deviceId);
+  async connectToDevice(
+    deviceId: string,
+    connectionType?: ClientConnectionType
+  ) {
+    super.connectToDevice(deviceId, connectionType);
     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
-    );
+    let device = DeviceManager.AvailableDevices.filter(
+      (device) => device.connectionType == "noble"
+    ).find((device) => device.bluetoothId == deviceId);
     if (!device) {
       device = this.#createDevice(noblePeripheral);
-      await device.connect();
+      const { ipAddress, isWifiSecure } =
+        this.discoveredDevices[device.bluetoothId!];
+      if (connectionType && connectionType != "noble" && ipAddress) {
+        await device.connect({ type: connectionType, ipAddress, isWifiSecure });
+      } else {
+        await device.connect();
+      }
     } else {
-      await device.reconnect();
+      const { ipAddress, isWifiSecure } =
+        this.discoveredDevices[device.bluetoothId!];
+      if (
+        connectionType &&
+        connectionType != "noble" &&
+        connectionType != device.connectionType &&
+        ipAddress
+      ) {
+        await device.connect({ type: connectionType, ipAddress, isWifiSecure });
+      } else {
+        await device.reconnect();
+      }
     }
   }
 

package/src/sensor/BarometerSensorDataManager.ts

@@ -13,7 +13,7 @@ export interface BarometerSensorDataEventMessages {
   };
 }
 
-const _console = createConsole("BarometerSensorDataManager", { log: true });
+const _console = createConsole("BarometerSensorDataManager", { log: false });
 
 class BarometerSensorDataManager {
   #calculcateAltitude(pressure: number) {

package/src/sensor/MotionSensorDataManager.ts

@@ -1,6 +1,6 @@
 import { createConsole } from "../utils/Console.ts";
 
-const _console = createConsole("MotionSensorDataManager", { log: true });
+const _console = createConsole("MotionSensorDataManager", { log: false });
 
 export const MotionSensorTypes = [
   "acceleration",
@@ -15,6 +15,7 @@ export const MotionSensorTypes = [
   "stepCounter",
   "stepDetector",
   "deviceOrientation",
+  "tapDetector",
 ] as const;
 export type MotionSensorType = (typeof MotionSensorTypes)[number];
 
@@ -26,6 +27,7 @@ export const ContinuousMotionTypes = [
   "magnetometer",
   "gameRotation",
   "rotation",
+  "orientation",
 ] as const;
 export type ContinuousMotionType = (typeof ContinuousMotionTypes)[number];
 
@@ -36,7 +38,14 @@ 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 const ActivityTypes = [
+  "still",
+  "walking",
+  "running",
+  "bicycle",
+  "vehicle",
+  "tilting",
+] as const;
 export type ActivityType = (typeof ActivityTypes)[number];
 
 export interface Activity {
@@ -70,15 +79,19 @@ export interface MotionSensorDataEventMessages {
   stepCounter: { stepCounter: number };
   activity: { activity: Activity };
   deviceOrientation: { deviceOrientation: DeviceOrientation };
+  tapDetector: { tapDetector: Object };
 }
 
-export type MotionSensorDataEventMessage = ValueOf<MotionSensorDataEventMessages>;
+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
-    );
+    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 };
 
@@ -109,7 +122,9 @@ class MotionSensorDataManager {
 
     pitch *= -1;
     heading *= -1;
-    heading += 360;
+    if (heading < 0) {
+      heading += 360;
+    }
 
     const euler: Euler = { heading, pitch, roll };
 

package/src/sensor/PressureSensorDataManager.ts

@@ -3,15 +3,16 @@ import CenterOfPressureHelper from "../utils/CenterOfPressureHelper.ts";
 import RangeHelper from "../utils/RangeHelper.ts";
 import { createArray } from "../utils/ArrayUtils.ts";
 
-const _console = createConsole("PressureDataManager", { log: true });
+const _console = createConsole("PressureDataManager", { log: false });
 
 export const PressureSensorTypes = ["pressure"] as const;
 export type PressureSensorType = (typeof PressureSensorTypes)[number];
 
 export const ContinuousPressureSensorTypes = PressureSensorTypes;
-export type ContinuousPressureSensorType = (typeof ContinuousPressureSensorTypes)[number];
+export type ContinuousPressureSensorType =
+  (typeof ContinuousPressureSensorTypes)[number];
 
-import { Vector2 } from "../utils/MathUtils.ts";
+import { computeVoronoiWeights, Vector2 } from "../utils/MathUtils.ts";
 export type PressureSensorPosition = Vector2;
 
 import { CenterOfPressure } from "../utils/CenterOfPressureHelper.ts";
@@ -66,42 +67,75 @@ class PressureSensorDataManager {
 
     this.#positions = positions;
 
-    this.#sensorRangeHelpers = createArray(this.numberOfSensors, () => new RangeHelper());
+    this.#sensorRangeHelpers = createArray(
+      this.numberOfSensors,
+      () => new RangeHelper()
+    );
 
     this.resetRange();
   }
 
   #sensorRangeHelpers!: RangeHelper[];
+  #normalizedSumRangeHelper = new RangeHelper();
 
   #centerOfPressureHelper = new CenterOfPressureHelper();
 
   resetRange() {
-    this.#sensorRangeHelpers.forEach((rangeHelper) => rangeHelper.reset());
+    this.#sensorRangeHelpers?.forEach((rangeHelper) => rangeHelper.reset());
     this.#centerOfPressureHelper.reset();
+    this.#normalizedSumRangeHelper.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 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;
+      let scaledValue = (rawValue * scalar) / this.numberOfSensors;
       const rangeHelper = this.#sensorRangeHelpers[index];
-      const normalizedValue = rangeHelper.updateAndGetNormalization(scaledValue, true);
+      const normalizedValue = rangeHelper.updateAndGetNormalization(
+        scaledValue,
+        false
+      );
+      //scaledValue -= rangeHelper.min;
+
       const position = this.positions[index];
-      pressure.sensors[index] = { rawValue, scaledValue, normalizedValue, position, weightedValue: 0 };
+      pressure.sensors[index] = {
+        rawValue,
+        scaledValue,
+        normalizedValue,
+        position,
+        weightedValue: 0,
+      };
 
       pressure.scaledSum += scaledValue;
-      pressure.normalizedSum += normalizedValue / this.numberOfSensors;
+      //pressure.normalizedSum += normalizedValue;
     }
+    pressure.normalizedSum =
+      this.#normalizedSumRangeHelper.updateAndGetNormalization(
+        pressure.scaledSum,
+        false
+      );
 
-    if (pressure.scaledSum > 0 && pressure.normalizedSum > 0.001) {
+    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);
+      pressure.normalizedCenter =
+        this.#centerOfPressureHelper.updateAndGetNormalization(
+          pressure.center,
+          false
+        );
     }
 
     _console.log({ pressure });