tirecheck-device-sdk 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -1,80 +1,160 @@
 'use strict';
 
 const _ = require('lodash');
+const CryptoJs = require('crypto-js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const ___default = /*#__PURE__*/_interopDefaultCompat(_);
+const CryptoJs__default = /*#__PURE__*/_interopDefaultCompat(CryptoJs);
 
 let ble;
 function setBleImplementation(bleImplementation) {
   ble = bleImplementation;
 }
 
+const store = {
+  platform: "web",
+  devices: {},
+  /** unknown - no information but since we get advertisings it is most likely disconnected, connecting - trying to connect via bluetooth, connected - connected via bluetooth (can send write and read), paired - all additional connection steps completed (setMtu, sendPin, etc) */
+  deviceState: {},
+  // unknown => connecting => connected => paired => disconnecting => disconnected
+  bridgesReboot: {}
+};
+
+function delay(delayMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function setIntervalImmediate(fn, intervalMs) {
+  fn();
+  return setInterval(fn, intervalMs);
+}
+function withTimeout(promise, timeoutMs, error) {
+  return Promise.race([
+    promise,
+    new Promise((resolve, reject) => setTimeout(() => reject(normalizeError(error)), timeoutMs))
+  ]);
+}
+function waitUntil(callback, timeout = 5e3) {
+  return new Promise((resolve, reject) => {
+    const interval = setInterval(() => {
+      if (callback()) {
+        clearInterval(interval);
+        resolve();
+      }
+    }, 500);
+    setTimeout(() => {
+      clearInterval(interval);
+      resolve();
+    }, timeout);
+  });
+}
+function canCommunicateWith(deviceId) {
+  const state = store.deviceState[deviceId];
+  return ["connected", "paired"].includes(state);
+}
+function getDeviceData(deviceId) {
+  const deviceData = store.devices[deviceId];
+  if (!deviceData) throw new Error("Device data missing");
+  return deviceData;
+}
+function isVersionGreaterThan(deviceId, version) {
+  if (version?.length !== 5) {
+    throw new Error("Invalid version format");
+  }
+  if (store.devices[deviceId]?.advertisingData?.fwVersion) {
+    return store.devices[deviceId]?.advertisingData?.fwVersion > version;
+  }
+  return false;
+}
+function getPositionId(axlePosition, tyrePosition, axleTyresCount, isSpare) {
+  let i2sTyrePosition = tyrePosition;
+  if (tyrePosition === 4 && axleTyresCount === 2) i2sTyrePosition = 2;
+  if (tyrePosition != null) return axlePosition * 100 + i2sTyrePosition * 10 + (isSpare ? 0 : axleTyresCount);
+  if (axlePosition != null) return axlePosition;
+  return 0;
+}
+function stringToArrayBuffer(string) {
+  const array = new Uint8Array(string.length);
+  for (let i = 0, l = string.length; i < l; i++) {
+    array[i] = string.charCodeAt(i);
+  }
+  return array.buffer;
+}
+const toolsSvc = {
+  delay,
+  setIntervalImmediate,
+  waitUntil,
+  withTimeout,
+  canCommunicateWith,
+  getDeviceData
+};
+function normalizeError(error) {
+  if (!error) return new Error("Operation timed out");
+  if (typeof error === "string") return new Error(error);
+  return error;
+}
+
+const tyreLabels = getDefaultTyreLabels();
 const bridgeTools = {
-  //   convertBytesToStructure(objStructure: BridgeCommandStructureProperties, payload: number[]) {
-  //     const numArray = _.clone(payload)
-  //     const keys = Object.keys(objStructure)
-  //     const sumWithInitial = keys.reduce((accumulator, currentValue) => accumulator + objStructure[currentValue].size, 0)
-  //     if (numArray.length !== sumWithInitial) {
-  //       throw new Error('Cannot convert bytes to object')
-  //     }
-  //     const result: any = {}
-  //     for (const key of keys) {
-  //       const encodedData: number[] = numArray.splice(0, objStructure[key].size)
-  //       result[key] = this.decodeData(encodedData, objStructure[key].display)
-  //     }
-  //     return result
-  //   },
-  //   convertStructureToBytes(objStructure: any, structurizedObj: any) {
-  //     const keys = Object.keys(objStructure)
-  //     const result: number[] = []
-  //     for (const key of keys) {
-  //       const encoded = this.encodeData(structurizedObj[key], objStructure[key].display)
-  //       if (encoded.length < objStructure[key].size) {
-  //         const _padArray = Array.from({ length: objStructure[key].size - encoded.length }, () => 0)
-  //         encoded.push(..._padArray)
-  //       }
-  //       result.push(...encoded)
-  //     }
-  //     return result
-  //   },
-  //   convertAutoLearnObjectToBinary(data: Record<string, string>): Record<string, string> {
-  //     const result: Record<string, string> = {}
-  //     for (const key in data) {
-  //       if (!key.includes('axle')) continue
-  //       // Parse the value as hexadecimal (base 16)
-  //       const value = parseInt(data[key], 16)
-  //       // Convert to binary and pad with leading zeros to ensure 8 characters
-  //       const binaryString = value.toString(2).padStart(8, '0')
-  //       result[key] = binaryString
-  //     }
-  //     return result
-  //   },
-  //   decodeData(data: number[], displayUnits: undefined | 'ascii' | 'decimal') {
-  //     const _data = _.clone(data)
-  //     if (displayUnits === 'ascii') {
-  //       return _data
-  //         .filter(d => d)
-  //         .map(x => String.fromCharCode(x))
-  //         .join('')
-  //     }
-  //     const _reversedData = _data.reverse()
-  //     if (displayUnits === 'decimal') {
-  //       return Number(`0x${_reversedData.map(dec => this.decimalToHex(dec)).join('')}`.replace(/\r\n/g, ''))
-  //     }
-  //     return _reversedData.map(dec => this.decimalToHex(dec)).join('')
-  //   },
-  //   encodeData(data: number | string, displayUnits: undefined | 'ascii' | 'decimal'): number[] {
-  //     const _data = _.clone(data)
-  //     if (displayUnits === 'ascii') {
-  //       return (_data as string).split('').map((v, i) => (_data as string).charCodeAt(i))
-  //     }
-  //     if (displayUnits === 'decimal') {
-  //       return this.hexToDecimalArray(this.decimalToHex(_data as number)).reverse()
-  //     }
-  //     return this.hexToDecimalArray(_data as string).reverse()
-  //   },
+  convertBytesToStructure(objStructure, payload) {
+    const numArray = ___default.clone(payload);
+    const keys = Object.keys(objStructure);
+    const sumWithInitial = keys.reduce((accumulator, currentValue) => accumulator + objStructure[currentValue].size, 0);
+    if (numArray.length !== sumWithInitial) {
+      throw new Error("Cannot convert bytes to object");
+    }
+    const result = {};
+    for (const key of keys) {
+      const encodedData = numArray.splice(0, objStructure[key].size);
+      result[key] = this.decodeData(encodedData, objStructure[key].display);
+    }
+    return result;
+  },
+  convertStructureToBytes(objStructure, structurizedObj) {
+    const keys = Object.keys(objStructure);
+    const result = [];
+    for (const key of keys) {
+      const encoded = this.encodeData(structurizedObj[key], objStructure[key].display);
+      if (encoded.length < objStructure[key].size) {
+        const _padArray = Array.from({ length: objStructure[key].size - encoded.length }, () => 0);
+        encoded.push(..._padArray);
+      }
+      result.push(...encoded);
+    }
+    return result;
+  },
+  convertAutoLearnObjectToBinary(data) {
+    const result = {};
+    for (const key in data) {
+      if (!key.includes("axle")) continue;
+      const value = Number.parseInt(data[key], 16);
+      const binaryString = value.toString(2).padStart(8, "0");
+      result[key] = binaryString;
+    }
+    return result;
+  },
+  decodeData(data, displayUnits) {
+    const _data = ___default.clone(data);
+    if (displayUnits === "ascii") {
+      return _data.filter((d) => d).map((x) => String.fromCharCode(x)).join("");
+    }
+    const _reversedData = _data.reverse();
+    if (displayUnits === "decimal") {
+      return Number(`0x${_reversedData.map((dec) => this.decimalToHex(dec)).join("")}`.replace(/\r\n/g, ""));
+    }
+    return _reversedData.map((dec) => this.decimalToHex(dec)).join("");
+  },
+  encodeData(data, displayUnits) {
+    const _data = ___default.clone(data);
+    if (displayUnits === "ascii") {
+      return _data.split("").map((v, i) => _data.charCodeAt(i));
+    }
+    if (displayUnits === "decimal") {
+      return this.hexToDecimalArray(this.decimalToHex(_data)).reverse();
+    }
+    return this.hexToDecimalArray(_data).reverse();
+  },
   //   getBridgeId(device: BluetoothDeviceBridge) {
   //     // [244,177, 0, 34,123, 155] => F4B100227B9B
   //     return (
@@ -85,20 +165,20 @@ const bridgeTools = {
   //         .toUpperCase() || ''
   //     )
   //   },
-  //   pkcs(array: any[], length: number) {
-  //     const pkcsValue = length - array.length
-  //     if (pkcsValue > 0) {
-  //       return [...array, ...new Array(pkcsValue).fill(pkcsValue)]
-  //     }
-  //     return array
-  //   },
+  pkcs(array, length) {
+    const pkcsValue = length - array.length;
+    if (pkcsValue > 0) {
+      return [...array, ...new Array(pkcsValue).fill(pkcsValue)];
+    }
+    return array;
+  },
   decimalToHex(decimal) {
     const hex = decimal.toString(16);
     return hex.padStart(2, "0");
   },
-  //   hexToDecimalArray(hex: string): number[] {
-  //     return hex.match(/.{1,2}/g)?.map(byte => parseInt(byte, 16)) || []
-  //   },
+  hexToDecimalArray(hex) {
+    return hex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || [];
+  },
   getFwVersion(payload) {
     if (payload?.length !== 3) {
       console.warn("Could not process FwVersion ", payload);
@@ -109,46 +189,125 @@ const bridgeTools = {
       acc.push(value[0] === "0" ? value[1] : value);
       return acc;
     }, []).join(".");
+  },
+  barToKpaByte(value) {
+    if (!value) return 0;
+    return ___default.round((value + 1) * 100 / 5.0625);
+  },
+  convertSensorIdForBridge(sensorId) {
+    if (sensorId.startsWith("2") && sensorId.length === 10) {
+      return Number.parseInt(sensorId).toString(16);
+    }
+    return sensorId;
+  },
+  kpaByteToBar(value, decrementValue = 1) {
+    if (!___default.isNumber(value)) {
+      throw new TypeError("Value has to be a number");
+    }
+    const rawBar = value * 5.0625 / 100;
+    return Math.max(rawBar - decrementValue, 0);
+  },
+  isVersionGreaterThan(device, version) {
+    if (version?.length !== 5) {
+      throw new Error("Invalid version format");
+    }
+    if (device.advertisingData.fwVersion) {
+      return device.advertisingData?.fwVersion > version;
+    }
+    return false;
+  },
+  convertSensorIdFromBridge(sensorId) {
+    const sensorIdDecimal = Number.parseInt(sensorId, 16).toString();
+    if (sensorId.startsWith("B") && sensorIdDecimal.startsWith("2") && sensorIdDecimal.length === 10) {
+      return sensorIdDecimal;
+    }
+    return sensorId;
+  },
+  getPositionInfo(positionId) {
+    if (positionId === 0)
+      return {
+        axlePosition: null,
+        tyrePosition: null,
+        name: "Vehicle"
+      };
+    if (positionId < 100)
+      return {
+        axlePosition: positionId,
+        tyrePosition: null,
+        name: `Axle ${positionId.toString()}`
+      };
+    const axleTyresCount = positionId % 10;
+    const axlePosition = Math.floor(positionId / 100);
+    const tyrePosition = Math.floor(positionId / 10) % 10;
+    const isSpare = String(positionId).endsWith("0");
+    return {
+      positionId,
+      axlePosition,
+      tyrePosition: isSpare ? 1 : tyrePosition,
+      axleTyresCount,
+      name: this.getPositionNameInner(axlePosition, tyrePosition, axleTyresCount),
+      description: this.getPositionDescriptionInner(axlePosition, tyrePosition, axleTyresCount),
+      isSpareTyre: axleTyresCount === 0 || isSpare,
+      isLeftTyre: axleTyresCount === 2 && tyrePosition === 1 || axleTyresCount === 4 && tyrePosition <= 2,
+      isRightTyre: axleTyresCount === 2 && tyrePosition === 2 || axleTyresCount === 4 && tyrePosition > 2,
+      isCenterTyre: axleTyresCount === 1,
+      isTwinTyre: axleTyresCount === 4,
+      isOuterTwinTyre: axleTyresCount === 4 && [1, 4].includes(tyrePosition),
+      isInnerTwinTyre: axleTyresCount === 4 && [2, 3].includes(tyrePosition)
+    };
+  },
+  getPositionNameInner(axlePosition, tyrePosition, axleTyresCount) {
+    const l = tyreLabels[tyrePosition * 10 + axleTyresCount];
+    const tyreLabel = l?.replace("_", axlePosition.toString());
+    if (tyreLabel) return tyreLabel;
+    if (axleTyresCount < 2) return axlePosition.toString();
+    return tyrePosition.toString();
+  },
+  getPositionDescriptionInner(axlePosition, tyrePosition, axleTyresCount) {
+    const axle = `Axle ${axlePosition.toString()}`;
+    if (axleTyresCount === 4) {
+      const side = tyrePosition === 1 || tyrePosition === 2 ? "Left" : "Right";
+      const pos = tyrePosition === 1 || tyrePosition === axleTyresCount ? "Outer" : "Inner";
+      return `${axle}, ${side} ${pos}`;
+    }
+    if (axleTyresCount === 2) {
+      const side = tyrePosition === 1 ? "Left" : "Right";
+      return `${axle}, ${side}`;
+    }
+    if (axleTyresCount === 1) {
+      return `${axle}, ${"Center"}`;
+    }
+    return `${axle}, ${"Spare"}`;
+  },
+  getSpareTyres(tcVehicle) {
+    const spareTyres = tcVehicle.tcTyres?.filter((tyre) => String(tyre.mountedOn?.positionId).endsWith("0"));
+    return spareTyres;
   }
-  //   barToKpaByte(value?: number) {
-  //     if (!value) return 0
-  //     return _.round(((value + 1) * 100) / 5.0625)
-  //   },
-  //   kpaByteToBar(value?: number, decrementValue = 1) {
-  //     if (!_.isNumber(value)) {
-  //       throw new TypeError('Value has to be a number')
-  //     }
-  //     const rawBar = (value * 5.0625) / 100
-  //     return Math.max(rawBar - decrementValue, 0)
-  //   },
-  //   getMacAddressIfOtaAndIos(device: BluetoothDeviceBridge) {
-  //     const uint8 = new Uint8Array(device.advertising.kCBAdvDataLeBluetoothDeviceAddress)
-  //     const macAddressArray = Array.from(uint8)
-  //       .reverse()
-  //       .slice(0, 6)
-  //       .map(x => this.decimalToHex(x).toUpperCase())
-  //     return macAddressArray.join('')
-  //   },
-  //   isVersionGreaterThan(version: string) {
-  //     if (version?.length !== 5) {
-  //       throw new Error('Invalid version format'.t())
-  //     }
-  //     if (bluetoothStore?.connectedBridge?.advertisingData?.fwVersion) {
-  //       return bluetoothStore?.connectedBridge?.advertisingData?.fwVersion > version
-  //     }
-  //     return false
-  //   },
 };
+function getDefaultTyreLabels() {
+  const tyreLabelsStr = "_L;_R;_LO;_LI;_RI;_RO;_";
+  const tyreLabelsStrLoc = tyreLabelsStr;
+  const tls = tyreLabelsStrLoc.split(";");
+  return {
+    12: tls[0],
+    22: tls[1],
+    14: tls[2],
+    24: tls[3],
+    34: tls[4],
+    44: tls[5],
+    10: ___default.last(tls) || "",
+    20: ___default.last(tls) || ""
+  };
+}
 
 const bridgeAdvertisingParser = {
   getDeviceInfoFromAdvertising(device) {
     const adversitingType = getAdvertisingType(device);
-    if (adversitingType !== "connectable")
-      return void 0;
+    if (adversitingType !== "connectable") return void 0;
     const advertisingData = getAdvertisingData({ advertising: device.advertising, deviceName: device.name });
     const bridgeId = advertisingData?.macAddress?.map((n) => bridgeTools.decimalToHex(n)).reverse().join("").toUpperCase() || "";
     const vin = String.fromCharCode(...advertisingData?.vinNum || []).split("\0").join("");
-    return { id: device.id, name: device.name, bridgeId, vin, advertisingData, device };
+    return { id: device.id, name: device.name, bridgeId, vin, advertisingData, type: "bridge", rssi: device.rssi };
   }
 };
 function getAdvertisingType(device) {
@@ -173,7 +332,7 @@ function getAdvertisingData({ advertising, deviceName }) {
     advertising.kCBAdvDataIsConnectable ? advertising.kCBAdvDataManufacturerData : advertising
   );
   const adv = Array.from(uint8);
-  const advertisingData = advertising.kCBAdvDataIsConnectable ? processIosAdvertising(adv) : processAndroidAdvertising(adv, isKrone);
+  const advertisingData = advertising.kCBAdvDataIsConnectable ? processIosAdvertising(adv, isKrone) : processAndroidAdvertising(adv, isKrone);
   if (!advertisingData || !advertisingData.macAddress.length || !advertisingData.randomAdvNumber.length || !advertisingData.vinNum.length) {
     throw new Error("Device not recognized");
   }
@@ -213,145 +372,206 @@ function processAndroidAdvertising(adv, isKrone) {
   return advertisingData;
 }
 function processIosAdvertising(adv, isKrone) {
-  if (adv.length < 34)
-    return void 0;
+  const advertisingData = {
+    configVersion: isKrone ? 17 : 1,
+    macAddress: [],
+    randomAdvNumber: [],
+    vinNum: [],
+    fwVersion: void 0,
+    timeFromStart: void 0
+  };
+  console.log("adv.lenght", adv.length);
+  if (adv.length < 34) return void 0;
   if (adv.length === 35) {
-    adv.slice(3, 11);
-    adv.slice(12, 18);
-    adv.slice(18, 35);
+    advertisingData.randomAdvNumber = adv.slice(3, 11);
+    advertisingData.macAddress = adv.slice(12, 18);
+    advertisingData.vinNum = adv.slice(18, 35);
   }
   if (adv.length === 40) {
-    adv.slice(3, 11);
-    bridgeTools.getFwVersion(adv.slice(11, 14));
-    adv[14];
-    adv[15];
-    adv.slice(17, 23);
-    adv.slice(23, 40);
+    advertisingData.randomAdvNumber = adv.slice(3, 11);
+    advertisingData.fwVersion = bridgeTools.getFwVersion(adv.slice(11, 14));
+    advertisingData.configVersion = adv[14];
+    advertisingData.timeFromStart = adv[15];
+    advertisingData.macAddress = adv.slice(17, 23);
+    advertisingData.vinNum = adv.slice(23, 40);
   }
+  return advertisingData;
 }
 
 const deviceMeta = {
   bridge: {
     nameRegex: /(030303|030321)/,
-    characteristic: {
+    communication: {
       serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
       // message from device
       characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d7"
     },
-    capabilities: [],
-    manufacturerId: 2978,
     mtu: 256,
     getDeviceInfoFromAdvertising: bridgeAdvertisingParser.getDeviceInfoFromAdvertising
   },
   bridgeOta: {
-    nameRegex: /CAN BLE BRDG OTA.*/,
+    nameRegex: /(CAN BLE BRDG OTA.*|0303.{2}_B)/,
     characteristic: {
       serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
       characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d7"
     },
-    capabilities: [],
-    getDeviceInfoFromAdvertising: () => {
+    getDeviceInfoFromAdvertising: (device) => {
+      const bleDevice = {
+        ...device,
+        type: "bridgeOta"
+      };
+      return bleDevice;
     }
   },
   flexiGaugeTpms: {
     nameRegex: /Flexi.*/,
-    characteristic: {
+    communication: {
       serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
-      // message from device
       characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
     },
-    getDeviceInfoFromAdvertising: () => {
+    battery: {
+      serviceId: "180f",
+      characteristicId: "2a19"
+    },
+    getDeviceInfoFromAdvertising: (device) => {
+      const bleDevice = {
+        ...device,
+        type: "flexiGaugeTpms"
+      };
+      return bleDevice;
     },
-    // Do we need it here?
-    capabilities: [
-      {
-        id: "td",
-        // processFn: processTreadDepth,
-        regex: /^\*TD.*/
-      },
-      {
-        id: "button",
-        // processFn: processButtonPress,
-        regex: /^\*[UDLRC] $/
-      },
-      {
-        id: "tpms",
-        // processFn: processTpms,
-        regex: /^\*TPMS.*/
-      }
-    ],
     reconnect: true
     // Do we need it here?
-  },
-  pressureStick: {
-    nameRegex: /Pressure Stick.*/,
-    characteristic: {
-      serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
-      characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
-    },
-    getDeviceInfoFromAdvertising: () => {
-    },
-    capabilities: [
-      {
-        id: "pressure",
-        // processFn: processPressure,
-        regex: /P([0-9.]+)mBar/
-      }
-      // only pressure is needed for initial implementation, uncomment tpms functionality when needed
-      // {
-      //   id: 'tpms',
-      //   processFn: processTpms,
-      //   regex: /^\*TPMS/,
-      // },
-    ]
   }
+  // pressureStick: {
+  //   nameRegex: /Pressure Stick.*/,
+  //   characteristic: {
+  //     serviceId: '4880c12c-fdcb-4077-8920-a450d7f9b907',
+  //     characteristicId: 'fec26ec4-6d71-4442-9f81-55bc21d658d6',
+  //   },
+  //   getDeviceInfoFromAdvertising: () => {},
+  //   capabilities: [
+  //     {
+  //       id: 'pressure',
+  //       // processFn: processPressure,
+  //       regex: /P([0-9.]+)mBar/,
+  //     },
+  //     // only pressure is needed for initial implementation, uncomment tpms functionality when needed
+  //     // {
+  //     //   id: 'tpms',
+  //     //   processFn: processTpms,
+  //     //   regex: /^\*TPMS/,
+  //     // },
+  //   ],
+  // },
 };
 
 const checkUnreachableDevicesTimeouts = {};
 const checkConnectedStateIntervals = {};
 let deviceAdvertisingCallback;
-let deviceUpdateCallback;
 let deviceUnreachableCallback;
+let deviceLostConnectionCallback;
 const bluetooth = {
   /** Triggered when "scanDevices" detects device supported by SDK */
   onDeviceAdvertising(callback) {
     deviceAdvertisingCallback = callback;
   },
-  onDeviceUpdate(callback) {
-    deviceUpdateCallback = callback;
-  },
   onDeviceUnreachable(callback) {
     deviceUnreachableCallback = callback;
   },
-  async scanDevices(services = []) {
-    await ble.stopScan();
-    ble.startScanWithOptions(
-      services,
-      {
-        reportDuplicates: true,
-        matchMode: "aggressive",
-        scanMode: "lowLatency",
-        numOfMatches: "max",
-        callbackType: "all",
-        reportDelay: 0
-      },
-      (device) => {
-        const processedDevice = processDevice(device);
-        if (!processedDevice)
-          return;
-        deviceAdvertisingCallback?.(processedDevice);
-      },
-      (e) => console.error("ble.startScanWithOptions error:", e)
-    );
-  }
+  onDeviceLostConnection(callback) {
+    deviceLostConnectionCallback = callback;
+  },
+  scanDevices,
+  stopScan() {
+    ble.stopScan();
+  },
+  connect,
+  disconnect,
+  write,
+  read
 };
-function processDevice(device) {
-  const uint8 = new Uint8Array(device.advertising);
-  const adv = Array.from(uint8);
-  let name = device.advertising.kCBAdvDataLocalName || device.name;
-  if (!name || name === "OTA") {
-    name = getDeviceNameFromAdvertising(adv);
+async function scanDevices(services = [], duration) {
+  await ble.stopScan();
+  ble.startScanWithOptions(
+    services,
+    {
+      reportDuplicates: true,
+      matchMode: "aggressive",
+      scanMode: "lowLatency",
+      numOfMatches: "max",
+      callbackType: "all",
+      reportDelay: 0,
+      duration
+    },
+    (device) => {
+      const processedDevice = processDevice(device);
+      if (!processedDevice) return;
+      store.devices[processedDevice.id] = processedDevice;
+      deviceAdvertisingCallback?.(processedDevice);
+    },
+    (e) => console.error("ble.startScanWithOptions error:", e)
+  );
+}
+async function connect(deviceId, disconnectCallback) {
+  store.deviceState[deviceId] = "connecting";
+  let connectedDevice;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      connectedDevice = await connectInner(deviceId, disconnectCallback);
+      if (connectedDevice) break;
+    } catch (e) {
+      console.warn(`${attempt} connect fail`, e);
+      if (attempt === 3) throw new Error("Connection unsuccessful");
+    }
+  }
+  const isConnected = await ble.isConnected(deviceId);
+  if (!isConnected) {
+    store.deviceState[deviceId] = void 0;
+    throw new Error("Connect Error");
+  }
+  store.deviceState[deviceId] = "connected";
+  return connectedDevice;
+}
+function connectInner(deviceId, disconnectCallback) {
+  return new Promise(
+    (resolve, reject) => ble.connect(deviceId, resolve, (err) => {
+      if (toolsSvc.canCommunicateWith(deviceId)) {
+        deviceLostConnectionCallback?.(deviceId);
+        disconnectCallback(deviceId);
+      }
+      reject(err);
+    })
+  );
+}
+async function disconnect(deviceId) {
+  for (let attempts = 0; attempts < 3; attempts++) {
+    await withTimeout(ble.disconnect(deviceId), 1e3, "Disconnect timed out");
+    const isConnected = await ble.isConnected(deviceId);
+    if (!isConnected) return;
+  }
+  store.deviceState[deviceId] = void 0;
+  throw new Error("Disconnect unsuccessful");
+}
+async function write(deviceId, serviceUuid, characteristicUuid, value) {
+  if (!toolsSvc.canCommunicateWith(deviceId)) throw new Error("Write Error: Not connected to device");
+  try {
+    await ble.writeWithoutResponse(deviceId, serviceUuid, characteristicUuid, value);
+  } catch (e) {
+    throw new Error(`Write Error: ${e}`);
+  }
+}
+async function read(deviceId, serviceUuid, characteristicUuid) {
+  if (!toolsSvc.canCommunicateWith(deviceId)) throw new Error("Read Error: Not connected to device");
+  try {
+    const value = await ble.read(deviceId, serviceUuid, characteristicUuid);
+    return Array.from(new Uint8Array(value));
+  } catch (e) {
+    throw new Error(`Read Error: ${e}`);
   }
+}
+function processDevice(device) {
+  const name = getDeviceName(device);
   const deviceType = getDeviceTypeFromName(name);
   if (!deviceType) {
     return;
@@ -359,14 +579,12 @@ function processDevice(device) {
   let processedDevice;
   try {
     processedDevice = deviceMeta[deviceType].getDeviceInfoFromAdvertising({ ...device, name });
-    if (!processedDevice)
-      return;
+    if (!processedDevice) return;
   } catch (e) {
     console.warn("Error processing advertising", e);
     return;
   }
   refreshUnreachableTimeouts(processedDevice.id);
-  monitorConnectedState(processedDevice.id);
   return processedDevice;
 }
 function getDeviceTypeFromName(name) {
@@ -379,20 +597,6 @@ function getDeviceTypeFromName(name) {
   }
   return deviceType;
 }
-function monitorConnectedState(deviceId) {
-  if (checkConnectedStateIntervals[deviceId])
-    return;
-  checkConnectedStateIntervals[deviceId] = setInterval(async () => {
-    let isConnected = false;
-    try {
-      await ble.isConnected(deviceId);
-      isConnected = true;
-    } catch {
-      isConnected = false;
-    }
-    deviceUpdateCallback?.({ deviceId, isConnected });
-  }, 1e3);
-}
 function refreshUnreachableTimeouts(deviceId) {
   if (checkUnreachableDevicesTimeouts[deviceId]) {
     clearTimeout(checkUnreachableDevicesTimeouts[deviceId]);
@@ -405,21 +609,2354 @@ function refreshUnreachableTimeouts(deviceId) {
     }
   }, 6e4);
 }
-function getDeviceNameFromAdvertising(adv) {
-  const advertising = ___default.clone(adv);
-  const messageType = advertising[4];
-  const packet = advertising.slice(5, 11);
-  if (messageType === 9) {
-    return packet.map((x) => String.fromCharCode(x)).join("");
+function getDeviceName(device) {
+  const isBridge = deviceMeta.bridge.nameRegex.test(device.name) || deviceMeta.bridgeOta.nameRegex.test(device.name);
+  if (isBridge && !device.advertising.kCBAdvDataLocalName) {
+    return getDeviceNameFromAdvertising(device.advertising);
   }
-  return "";
+  return device.advertising.kCBAdvDataLocalName ?? device.name;
+}
+function getDeviceNameFromAdvertising(advertising) {
+  const adv = new Uint8Array(advertising);
+  const length = adv[3];
+  const type = adv[4];
+  if (type !== 9) {
+    console.warn("Bridge name not found in advertising");
+    return "";
+  }
+  const decoder = new TextDecoder("utf-8");
+  const deviceName = decoder.decode(adv.slice(5, 4 + length));
+  return deviceName;
+}
+
+const bridgeCommandStructures = {
+  bridgeConfiguration: {
+    id: [98, 1],
+    name: "bridgeConfiguration",
+    structure: {
+      configVersion: {
+        size: 4,
+        description: "Application configuration version details"
+      },
+      bleTxPower: {
+        size: 2,
+        description: "Used BLE Tx power (16 bit signed value; LSB = 0.1 LSB)",
+        display: "decimal"
+      },
+      bleTxChannels: {
+        size: 1,
+        description: "BLE channel configuration (0x07 = all channels)"
+      },
+      bleConnectableAdvPeriod: {
+        size: 2,
+        description: "Ble Connectable Advertisement Period [LSB = 0.625 ms]",
+        display: "decimal"
+      },
+      configurationFlags: {
+        size: 1,
+        description: "Configuration flags (1 = Enable inactivity timeout; 4 = Disable time lockout on false PINs)"
+      },
+      wrongPinUntilLockout: {
+        size: 1,
+        display: "decimal",
+        description: "Minimimal number of wrong pins allowed before the Lockout will be activated for a period"
+      },
+      maxLockoutPeriodIncreases: {
+        display: "decimal",
+        size: 1,
+        description: "How many times it is allowed to double the lockout period"
+      },
+      wrongPinInitialLockoutTime: {
+        size: 1,
+        display: "decimal",
+        description: "What is the initial lockout time duration after too many wrong PINs"
+      },
+      securityConfiguration: {
+        size: 1,
+        description: "Bluetooth security configuration (0x03 - legacy pairing enabled; 0x07 - legacy pairing disabled)"
+      },
+      canEnabled: {
+        size: 1,
+        display: "decimal",
+        description: "CAN enabled state"
+      },
+      bleEnabled: {
+        size: 1,
+        display: "decimal",
+        description: "BLE Advertisement enabled state"
+      },
+      canBitrate: {
+        size: 2,
+        display: "decimal",
+        description: "CAN Bitrate [kbps]"
+      },
+      movementDetectionLimit: {
+        size: 2,
+        display: "decimal",
+        description: "Movement detection limit [1/256 kmph per bit]"
+      },
+      sensorInactivityTimeout: {
+        size: 2,
+        display: "decimal",
+        description: "Timeout [s] counter after which inactive sensor is marked as erroneous (incremented when vehicle is moving; max. 512 seconds)"
+      },
+      manufacturerCode: {
+        size: 4,
+        display: "decimal",
+        description: "Manufacturer Code as per SAE J1939"
+      },
+      identityNumber: {
+        size: 4,
+        display: "decimal",
+        description: "Identity number for ECU (Max. 22 bits value = 0x1FFFFF)"
+      },
+      manufacturerName: {
+        size: 20,
+        description: "Manufacturer Name (Max. 20 bytes length)",
+        display: "ascii"
+      },
+      ecuPartNumber: {
+        size: 20,
+        description: "ECU Part Number (Max. 20 bytes length)",
+        display: "ascii"
+      },
+      softwareVersion: {
+        size: 20,
+        description: "Software Version (Max. 20 bytes length)",
+        display: "ascii"
+      },
+      reservedConfiguration: {
+        size: 4,
+        display: "decimal",
+        description: "Reserved configuration"
+      }
+    }
+  },
+  workshopCanSettings: {
+    id: [98, 96],
+    name: "workshopCanSettings",
+    structure: {
+      canTermination: {
+        size: 1,
+        description: "CAN Termination disabled / enabled"
+      }
+    }
+  },
+  customerCanSettings: {
+    id: [98, 80],
+    name: "customerCanSettings",
+    structure: {
+      canProtocol: {
+        size: 1,
+        description: "J1939 / ECE-R141 CAN Protocol Status"
+      },
+      transparentFilteredMode: {
+        size: 1,
+        description: "0th bit = CAN Transparent/Filtered Mode; 1st bit = BLE Transparent/Filtered Mode"
+      },
+      spnsPgnsBitmap: {
+        size: 4,
+        description: "SPNs/PGNs Bitmap Toggled State"
+      }
+    }
+  },
+  axleImbalanceThresholds: {
+    id: [98, 66],
+    name: "axleImbalanceThresholds",
+    structure: {
+      axle01: {
+        size: 1,
+        description: "Axle 01 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle02: {
+        size: 1,
+        description: "Axle 02 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle03: {
+        size: 1,
+        description: "Axle 03 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle04: {
+        size: 1,
+        description: "Axle 04 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle05: {
+        size: 1,
+        description: "Axle 05 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle06: {
+        size: 1,
+        description: "Axle 06 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle07: {
+        size: 1,
+        description: "Axle 07 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle08: {
+        size: 1,
+        description: "Axle 08 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle09: {
+        size: 1,
+        description: "Axle 09 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle10: {
+        size: 1,
+        description: "Axle 10 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle11: {
+        size: 1,
+        description: "Axle 11 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle12: {
+        size: 1,
+        description: "Axle 12 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle13: {
+        size: 1,
+        description: "Axle 13 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle14: {
+        size: 1,
+        description: "Axle 14 imbalance limits (encoded pressure and temperature imbalance limits)"
+      },
+      axle15: {
+        size: 1,
+        description: "Axle 15 imbalance limits (encoded pressure and temperature imbalance limits)"
+      }
+    }
+  },
+  axleTemperatureThresholds: {
+    id: [98, 65],
+    name: "axleTemperatureThresholds",
+    structure: {
+      axle01: {
+        size: 1,
+        description: "Axle 01 over-temperature limit"
+      },
+      axle02: {
+        size: 1,
+        description: "Axle 02 over-temperature limit"
+      },
+      axle03: {
+        size: 1,
+        description: "Axle 03 over-temperature limit"
+      },
+      axle04: {
+        size: 1,
+        description: "Axle 04 over-temperature limit"
+      },
+      axle05: {
+        size: 1,
+        description: "Axle 05 over-temperature limit"
+      },
+      axle06: {
+        size: 1,
+        description: "Axle 06 over-temperature limit"
+      },
+      axle07: {
+        size: 1,
+        description: "Axle 07 over-temperature limit"
+      },
+      axle08: {
+        size: 1,
+        description: "Axle 08 over-temperature limit"
+      },
+      axle09: {
+        size: 1,
+        description: "Axle 09 over-temperature limit"
+      },
+      axle10: {
+        size: 1,
+        description: "Axle 10 over-temperature limit"
+      },
+      axle11: {
+        size: 1,
+        description: "Axle 11 over-temperature limit"
+      },
+      axle12: {
+        size: 1,
+        description: "Axle 12 over-temperature limit"
+      },
+      axle13: {
+        size: 1,
+        description: "Axle 13 over-temperature limit"
+      },
+      axle14: {
+        size: 1,
+        description: "Axle 14 over-temperature limit"
+      },
+      axle15: {
+        size: 1,
+        description: "Axle 15 over-temperature limit"
+      }
+    }
+  },
+  axlePressureThresholds: {
+    id: [98, 64],
+    name: "axlePressureThresholds",
+    structure: {
+      axle01: {
+        size: 4,
+        description: "Axle 01 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle02: {
+        size: 4,
+        description: "Axle 02 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle03: {
+        size: 4,
+        description: "Axle 03 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle04: {
+        size: 4,
+        description: "Axle 04 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle05: {
+        size: 4,
+        description: "Axle 05 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle06: {
+        size: 4,
+        description: "Axle 06 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle07: {
+        size: 4,
+        description: "Axle 07 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle08: {
+        size: 4,
+        description: "Axle 08 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle09: {
+        size: 4,
+        description: "Axle 09 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle10: {
+        size: 4,
+        description: "Axle 10 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle11: {
+        size: 4,
+        description: "Axle 11 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle12: {
+        size: 4,
+        description: "Axle 12 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle13: {
+        size: 4,
+        description: "Axle 13 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle14: {
+        size: 4,
+        description: "Axle 14 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      },
+      axle15: {
+        size: 4,
+        description: "Axle 15 pressure delta limits (encoded extreme over-; over-; under-; extreme under-pressure limit)"
+      }
+    }
+  },
+  pressuresPerAxle: {
+    id: [98, 48],
+    lsb: true,
+    name: "pressuresPerAxle",
+    structure: {
+      axle01: {
+        size: 3,
+        description: "Axle 01 set pressure; min pressure; max pressure"
+      },
+      axle02: {
+        size: 3,
+        description: "Axle 02 set pressure; min pressure; max pressure"
+      },
+      axle03: {
+        size: 3,
+        description: "Axle 03 set pressure; min pressure; max pressure"
+      },
+      axle04: {
+        size: 3,
+        description: "Axle 04 set pressure; min pressure; max pressure"
+      },
+      axle05: {
+        size: 3,
+        description: "Axle 05 set pressure; min pressure; max pressure"
+      },
+      axle06: {
+        size: 3,
+        description: "Axle 06 set pressure; min pressure; max pressure"
+      },
+      axle07: {
+        size: 3,
+        description: "Axle 07 set pressure; min pressure; max pressure"
+      },
+      axle08: {
+        size: 3,
+        description: "Axle 08 set pressure; min pressure; max pressure"
+      },
+      axle09: {
+        size: 3,
+        description: "Axle 09 set pressure; min pressure; max pressure"
+      },
+      axle10: {
+        size: 3,
+        description: "Axle 10 set pressure; min pressure; max pressure"
+      },
+      axle11: {
+        size: 3,
+        description: "Axle 11 set pressure; min pressure; max pressure"
+      },
+      axle12: {
+        size: 3,
+        description: "Axle 12 set pressure; min pressure; max pressure"
+      },
+      axle13: {
+        size: 3,
+        description: "Axle 13 set pressure; min pressure; max pressure"
+      },
+      axle14: {
+        size: 3,
+        description: "Axle 14 set pressure; min pressure; max pressure"
+      },
+      axle15: {
+        size: 3,
+        description: "Axle 15 set pressure; min pressure; max pressure"
+      }
+    }
+  },
+  autolearnSettings: {
+    id: [98, 160],
+    name: "autolearnSettings",
+    structure: {
+      axle01: {
+        size: 1,
+        description: "Axle 01 type, steer, liftable..."
+      },
+      axle02: {
+        size: 1,
+        description: "Axle 02 type, steer, liftable..."
+      },
+      axle03: {
+        size: 1,
+        description: "Axle 03 type, steer, liftable..."
+      },
+      axle04: {
+        size: 1,
+        description: "Axle 04 type, steer, liftable..."
+      },
+      axle05: {
+        size: 1,
+        description: "Axle 05 type, steer, liftable..."
+      },
+      axle06: {
+        size: 1,
+        description: "Axle 06 type, steer, liftable..."
+      },
+      axle07: {
+        size: 1,
+        description: "Axle 07 type, steer, liftable..."
+      },
+      axle08: {
+        size: 1,
+        description: "Axle 08 type, steer, liftable..."
+      },
+      axle09: {
+        size: 1,
+        description: "Axle 09 type, steer, liftable..."
+      },
+      axle10: {
+        size: 1,
+        description: "Axle 10 type, steer, liftable..."
+      },
+      axle11: {
+        size: 1,
+        description: "Axle 11 type, steer, liftable..."
+      },
+      axle12: {
+        size: 1,
+        description: "Axle 12 type, steer, liftable..."
+      },
+      axle13: {
+        size: 1,
+        description: "Axle 13 type, steer, liftable..."
+      },
+      axle14: {
+        size: 1,
+        description: "Axle 14 type, steer, liftable..."
+      },
+      axle15: {
+        size: 1,
+        description: "Axle 15 type, steer, liftable..."
+      },
+      isAutolearnEnabled: {
+        size: 1,
+        description: "Is autolearn enabled: 0 - disabled, 1 - enabled"
+      },
+      checkingPeriod: {
+        size: 1,
+        description: "Autolearn is evaluated within this period (when enabled)"
+      },
+      multiIdTimeout: {
+        size: 1,
+        description: "This timer (2 sec per bit) detects if multiple tyres / sensor IDs were changed and therefore autolearn cannot identify the tyre position of the new sensors"
+      },
+      temperatureLimit: {
+        size: 1,
+        description: "Autolearn temperature difference acceptation limit"
+      }
+    }
+  },
+  autolearnIdStatus: {
+    id: [98, 176],
+    name: "autolearnIdStatus",
+    structure: {
+      axle01: {
+        size: 8,
+        description: "Axle 01 autolearn statuses, each nibble signifies a single wheel."
+      },
+      axle02: {
+        size: 8,
+        description: "Axle 02 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle03: {
+        size: 8,
+        description: "Axle 03 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle04: {
+        size: 8,
+        description: "Axle 04 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle05: {
+        size: 8,
+        description: "Axle 05 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle06: {
+        size: 8,
+        description: "Axle 06 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle07: {
+        size: 8,
+        description: "Axle 07 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle08: {
+        size: 8,
+        description: "Axle 08 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle09: {
+        size: 8,
+        description: "Axle 09 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle10: {
+        size: 8,
+        description: "Axle 10 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle11: {
+        size: 8,
+        description: "Axle 11 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle12: {
+        size: 8,
+        description: "Axle 12 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle13: {
+        size: 8,
+        description: "Axle 13 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle14: {
+        size: 8,
+        description: "Axle 14 autolearn statuses, each nibble signifies a single wheel"
+      },
+      axle15: {
+        size: 8,
+        description: "Axle 15 autolearn statuses, each nibble signifies a single wheel"
+      }
+    }
+  },
+  autolearnUnknownSensors: {
+    id: [98, 192],
+    name: "autolearnUnknownSensors",
+    structure: {
+      sensor01: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor02: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor03: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor04: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor05: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor06: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor07: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor08: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor09: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor10: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor11: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor12: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor13: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor14: {
+        size: 8,
+        description: "Unknown sensor data"
+      },
+      sensor15: {
+        size: 8,
+        description: "Unknown sensor data"
+      }
+    }
+  }
+};
+
+const signature_keys = {
+  0: [
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 31],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 47],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 63],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 79],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 95],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 111],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 127],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 143],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 159],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 175],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 191],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 207],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 223],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 239],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 255]
+  ],
+  1: [
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 31],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 47],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 63],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 79],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 95],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 111],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 127],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 143],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 159],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 175],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 191],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 207],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 223],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 239],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 255]
+  ],
+  2: [
+    [121, 114, 34, 71, 3, 133, 92, 108, 162, 173, 161, 168, 164, 148, 34, 139],
+    [136, 120, 146, 44, 228, 28, 205, 63, 205, 120, 170, 120, 251, 245, 227, 154],
+    [37, 22, 60, 132, 154, 66, 59, 185, 36, 142, 163, 103, 39, 121, 227, 209],
+    [15, 30, 54, 173, 21, 127, 65, 158, 168, 84, 192, 17, 51, 3, 90, 173],
+    [136, 165, 72, 127, 72, 38, 200, 5, 4, 187, 203, 29, 6, 82, 130, 39],
+    [106, 95, 111, 82, 191, 213, 104, 194, 106, 30, 199, 250, 69, 223, 79, 250],
+    [150, 63, 177, 61, 50, 182, 227, 53, 157, 168, 245, 96, 90, 212, 17, 132],
+    [233, 159, 182, 205, 3, 216, 203, 73, 193, 142, 183, 16, 22, 208, 38, 143],
+    [7, 45, 239, 102, 47, 8, 237, 115, 77, 232, 2, 167, 47, 65, 164, 251],
+    [7, 159, 18, 71, 3, 132, 84, 47, 60, 167, 134, 251, 114, 207, 254, 190],
+    [203, 129, 34, 153, 32, 169, 153, 45, 215, 172, 76, 214, 5, 21, 210, 65],
+    [29, 194, 255, 4, 195, 144, 178, 174, 255, 66, 15, 19, 26, 212, 61, 251],
+    [42, 13, 136, 252, 143, 234, 120, 242, 164, 36, 21, 135, 252, 145, 101, 124],
+    [24, 24, 207, 236, 159, 24, 180, 141, 80, 119, 86, 239, 192, 32, 51, 34],
+    [187, 89, 217, 2, 16, 125, 121, 46, 159, 66, 85, 169, 9, 155, 2, 178],
+    [212, 230, 71, 216, 35, 20, 241, 0, 204, 163, 80, 198, 132, 210, 166, 173]
+  ],
+  16: [
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 31],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 47],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 63],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 79],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 95],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 111],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 127],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 143],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 159],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 175],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 191],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 207],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 223],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 239],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 255]
+  ],
+  17: [
+    [75, 40, 61, 20, 254, 102, 105, 160, 44, 236, 79, 39, 84, 27, 235, 100],
+    [185, 139, 202, 38, 158, 109, 211, 6, 38, 73, 28, 120, 208, 168, 159, 108],
+    [252, 100, 192, 127, 135, 127, 228, 125, 190, 210, 248, 146, 45, 229, 218, 159],
+    [217, 39, 58, 200, 22, 212, 105, 55, 15, 45, 82, 96, 216, 134, 69, 123],
+    [192, 34, 199, 199, 200, 112, 61, 98, 174, 62, 7, 200, 149, 168, 175, 110],
+    [60, 41, 125, 116, 134, 191, 241, 188, 171, 127, 209, 10, 114, 52, 120, 164],
+    [255, 19, 220, 184, 141, 224, 242, 117, 230, 143, 20, 75, 44, 50, 70, 113],
+    [55, 112, 171, 176, 239, 50, 111, 3, 175, 145, 123, 38, 12, 44, 18, 79],
+    [211, 119, 219, 6, 27, 41, 170, 199, 206, 66, 89, 89, 154, 128, 110, 70],
+    [187, 184, 42, 154, 108, 182, 238, 223, 192, 10, 144, 139, 130, 22, 220, 66],
+    [91, 248, 195, 246, 212, 104, 246, 252, 231, 120, 153, 211, 39, 250, 221, 133],
+    [184, 148, 72, 207, 106, 143, 21, 239, 133, 206, 1, 234, 1, 75, 92, 43],
+    [46, 35, 117, 127, 103, 37, 155, 16, 177, 106, 195, 129, 168, 235, 159, 162],
+    [0, 7, 114, 77, 77, 66, 224, 223, 92, 193, 241, 44, 242, 104, 67, 163],
+    [116, 194, 13, 179, 75, 181, 245, 211, 19, 38, 45, 21, 36, 163, 252, 235],
+    [6, 211, 31, 66, 81, 221, 137, 33, 23, 18, 160, 147, 159, 34, 121, 125]
+  ]
+};
+const pinKeys = {
+  0: "00000000000000010000000000000002",
+  1: "00000000000000010000000000000002",
+  2: "B2D24304FC345F1418EB96835B3B7AE8",
+  16: "00000000000000010000000000000002",
+  17: "CB5A6AA23FD565A141C5CE5ABF209000"
+};
+const bridgeSecurity = {
+  getSignedCommand(device, command) {
+    const { randomAdvNumber, configVersion } = device?.advertisingData || {};
+    if (!randomAdvNumber || !___default.isNumber(configVersion)) return console.error("random not present", randomAdvNumber);
+    const rand = ___default.clone(randomAdvNumber);
+    const security_level = bridgeTools.decimalToHex(command[0]);
+    const keyIndex = Number(security_level[0]);
+    const keyShift = Number(security_level[1]);
+    let paddedCommand = [];
+    if (command.length <= 16) {
+      paddedCommand = bridgeTools.pkcs(command, 16);
+    } else {
+      let t = Math.floor(command.length / 16);
+      const r = command.length % 16;
+      paddedCommand = bridgeTools.pkcs(command, r ? ++t * 16 : t * 16);
+    }
+    const key = signature_keys[configVersion][keyIndex];
+    const startArray = key.slice(keyShift);
+    const endArray = key.slice(0, keyShift);
+    const shiftedKey = startArray.concat(endArray).map((n) => bridgeTools.decimalToHex(n)).join("");
+    const dataIn = [...rand.reverse(), ...Array.from({ length: 8 }).fill(8)].map((x) => bridgeTools.decimalToHex(x)).join("");
+    const keyWA = CryptoJs__default.enc.Hex.parse(shiftedKey);
+    const dataInWA = CryptoJs__default.enc.Hex.parse(dataIn);
+    const encrypted = CryptoJs__default.AES.encrypt(dataInWA, keyWA, {
+      mode: CryptoJs__default.mode.ECB,
+      // ECB mode is used here for simplicity. Consider more secure modes.
+      padding: CryptoJs__default.pad.Pkcs7
+      // We handle padding manually
+    });
+    const iv = CryptoJs__default.enc.Hex.stringify(encrypted.ciphertext).slice(0, 32);
+    const nBlocks = paddedCommand.length / 16 + 1;
+    let blockVector = this.encryptedStringToNum(iv);
+    for (let index = 1; index < nBlocks; index++) {
+      const block = paddedCommand.slice((index - 1) * 16, index * 16);
+      const xorBlock = [];
+      for (let index2 = 0; index2 < block.length; index2++) {
+        xorBlock.push(block[index2] ^ blockVector[index2]);
+      }
+      const vector = blockVector.map((x) => bridgeTools.decimalToHex(x)).join("");
+      const dataWa = CryptoJs__default.enc.Hex.parse(xorBlock.map((x) => bridgeTools.decimalToHex(x)).join(""));
+      const testo = CryptoJs__default.AES.encrypt(dataWa, keyWA, {
+        iv: CryptoJs__default.enc.Hex.parse(vector),
+        mode: CryptoJs__default.mode.ECB,
+        padding: CryptoJs__default.pad.Pkcs7
+      });
+      const result = CryptoJs__default.enc.Hex.stringify(testo.ciphertext);
+      blockVector = this.encryptedStringToNum(result.slice(0, 32));
+    }
+    const signature = blockVector.slice(0, 4).reverse();
+    return [...command, ...signature];
+  },
+  async getPin(deviceId) {
+    const deviceData = store.devices[deviceId];
+    if (!deviceData) throw new Error("Device data missing");
+    const { randomAdvNumber, macAddress, configVersion } = deviceData.advertisingData || {};
+    if (!randomAdvNumber || !macAddress || !___default.isNumber(configVersion)) throw new Error("Cannot compute pin");
+    const mac = macAddress.map((n) => bridgeTools.decimalToHex(n)).join("");
+    const rand = randomAdvNumber.map((n) => bridgeTools.decimalToHex(n)).join("");
+    const message = `${mac}0000${rand}`;
+    const key = pinKeys[configVersion];
+    const res = await this.aesToCrc32(message, key);
+    return res;
+  },
+  aesToCrc32(message, key) {
+    const messageHex = CryptoJs__default.enc.Hex.parse(message);
+    const keyHex = CryptoJs__default.enc.Hex.parse(key);
+    const encrypted = CryptoJs__default.AES.encrypt(messageHex, keyHex, {
+      mode: CryptoJs__default.mode.ECB,
+      // You can use other modes like CBC or CTR for additional security
+      padding: CryptoJs__default.pad.ZeroPadding
+      // You can use other padding modes as well
+    });
+    const encryptedByteString = CryptoJs__default.enc.Hex.stringify(encrypted.ciphertext).slice(0, 32);
+    const hexArray = this.encryptedStringToNum(encryptedByteString);
+    return hexArray;
+  },
+  encryptedStringToNum(encString) {
+    const hexArray = [];
+    for (let i = 0; i < encString.length; i += 2) {
+      const slicedString = encString.slice(i, i + 2);
+      hexArray.push(Number(`0x${slicedString}`));
+    }
+    return hexArray;
+  },
+  crc32mpeg2(msg) {
+    let crc = 4294967295;
+    for (let i = 0; i < msg.length; i++) {
+      const b = msg[i];
+      crc ^= b << 24;
+      for (let j = 0; j < 8; j++) {
+        crc = crc << 1 ^ (crc & 2147483648 ? 79764919 : 0);
+      }
+    }
+    return crc >>> 0;
+  },
+  getCrcArray(msg) {
+    const crc = this.crc32mpeg2(msg);
+    const crcHex = bridgeTools.decimalToHex(crc).padStart(8, "0");
+    return bridgeTools.hexToDecimalArray(crcHex).reverse();
+  },
+  uint32ToLittleEndian(value) {
+    const byteArray = new Uint8Array(4);
+    byteArray[0] = value & 255;
+    byteArray[1] = value >> 8 & 255;
+    byteArray[2] = value >> 16 & 255;
+    byteArray[3] = value >> 24 & 255;
+    return byteArray;
+  }
+};
+
+const bridgeMeta = deviceMeta.bridge;
+let promiseQueue = Promise.resolve();
+let currentResolve = (_v) => {
+};
+let currentReject = (_v) => {
+};
+let responseIdentifier;
+const promiseQueue$1 = {
+  clearQueue(message) {
+    currentReject(new Error(message ?? "Stopped sending commands"));
+    promiseQueue = Promise.resolve();
+    responseIdentifier = [];
+  },
+  async enqueue(device, payload) {
+    promiseQueue = promiseQueue.then(() => {
+      const promise = new Promise((resolve, reject) => {
+        currentResolve = resolve;
+        currentReject = reject;
+        const isKeepAlive = payload[3] === commandIds.keepAlive;
+        responseIdentifier = [isKeepAlive ? 126 : 0, payload[4]];
+        const signedData = bridgeSecurity.getSignedCommand(device, payload);
+        if (!toolsSvc.canCommunicateWith(device.id)) return reject(new Error("Bridge not connected"));
+        if (signedData.length > 110) {
+          const chunks = [];
+          chunks.push(signedData.slice(0, 110));
+          chunks.push(signedData.slice(110));
+          for (const chunk of chunks) {
+            const convertedChunk = new Uint8Array(chunk).buffer;
+            bluetooth.write(
+              device.id,
+              bridgeMeta.communication.serviceId,
+              bridgeMeta.communication.characteristicId,
+              convertedChunk
+            );
+          }
+        } else {
+          const convertedData = new Uint8Array(signedData).buffer;
+          bluetooth.write(
+            device.id,
+            bridgeMeta.communication.serviceId,
+            bridgeMeta.communication.characteristicId,
+            convertedData
+          );
+        }
+      });
+      return withTimeout(promise, 5e3, "Command timed out");
+    });
+    return promiseQueue;
+  },
+  async processMessage(deviceId, payload) {
+    const numberArray = Array.from(new Uint8Array(payload));
+    if (numberArray[3] === 127) {
+      return currentReject(new Error(`Command not succesful: ${numberArray[4]}`));
+    }
+    if ([226, 81].includes(numberArray[3]) && numberArray[4] && toolsSvc.canCommunicateWith(deviceId)) {
+      store.bridgesReboot[deviceId] = true;
+    }
+    if ((!responseIdentifier[0] || numberArray[3] === responseIdentifier[0]) && (!responseIdentifier[1] || numberArray[4] === responseIdentifier[1])) {
+      return currentResolve(payload);
+    }
+    console.warn("message from the device not belonging to the pending promise: ", payload);
+  }
+};
+
+const securityLevelIds = {
+  tirecheck: 1,
+  vehicleManufacturer: 16,
+  vehicleDealership: 32,
+  workshop: 48,
+  driver: 64
+};
+const messageTypeIds = {
+  command: 0,
+  response: 1
+};
+const commandIds = {
+  readData: 34,
+  writeData: 46,
+  keepAlive: 62,
+  keepAliveResponse: 126,
+  sensorMeasurement: 189,
+  sensorMeasurementResponse: 253,
+  ecuReset: 17,
+  reboot: 162,
+  pin: 18,
+  pinResponse: 90,
+  otaRequest: 167
+};
+const subCommandIds = {
+  ecuResetSubCommand: 0,
+  rebootSubCommand: 4,
+  bridgeConfiguration: 1,
+  vehicleLayout: 16,
+  /** 0x20 - 0x2F */
+  idsPerWheel: (axleIndex) => 32 + axleIndex,
+  /** only for commandIds.sensorMeasurement */
+  sensorMeasurementPerWheel: (axlePosition, tyrePosition, isTwinTyre, isSpareAxle) => {
+    let bridgeTyrePosition = 0;
+    if (isTwinTyre && !isSpareAxle) {
+      if (tyrePosition === 1) bridgeTyrePosition = 6;
+      else if (tyrePosition === 2) bridgeTyrePosition = 7;
+      else if (tyrePosition === 3) bridgeTyrePosition = 9;
+      else if (tyrePosition === 4) bridgeTyrePosition = 10;
+    } else if (!isTwinTyre && !isSpareAxle) {
+      if (tyrePosition === 1) bridgeTyrePosition = 7;
+      else if (tyrePosition === 2) bridgeTyrePosition = 9;
+    } else if (isSpareAxle) {
+      if (tyrePosition === 1) bridgeTyrePosition = 8;
+    }
+    return axlePosition * 16 + bridgeTyrePosition;
+  },
+  pressurePerAxle: 48,
+  customerPressureThresholds: 64,
+  customerTemperatureThresholds: 65,
+  customerImbalanceThresholds: 66,
+  customerCanSettings: 80,
+  workshopCanSettings: 96,
+  errorHistoryCounter: 112,
+  eolStatus: 128,
+  firmwareVersion: 144,
+  autolearnSettings: 160,
+  autolearnIdStatus: 176,
+  autolearnUnknownSensors: 192
+};
+___default.invert(commandIds);
+___default.invert(subCommandIds);
+let keepAliveTimer;
+const bridgeCommands = {
+  getCommandHeader(device) {
+    return [securityLevelIds.tirecheck, messageTypeIds.command];
+  },
+  async setAxlesPressure(deviceId, data) {
+    const deviceData = getDeviceData(deviceId);
+    await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.pressurePerAxle, data);
+  },
+  async setVehicleLayout(deviceId, data) {
+    const deviceData = getDeviceData(deviceId);
+    await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.vehicleLayout, data);
+  },
+  async getCustomerCANSettings(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.customerCanSettings);
+    return bridgeTools.convertBytesToStructure(bridgeCommandStructures.customerCanSettings.structure, result);
+  },
+  async getWorkshopCANSettings(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.workshopCanSettings);
+    return bridgeTools.convertBytesToStructure(bridgeCommandStructures.workshopCanSettings.structure, result);
+  },
+  async getBridgeConfiguration(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.bridgeConfiguration);
+    return bridgeTools.convertBytesToStructure(bridgeCommandStructures.bridgeConfiguration.structure, result);
+  },
+  async getCustomerPressureThresholds(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.customerPressureThresholds);
+    return bridgeTools.convertBytesToStructure(bridgeCommandStructures.axlePressureThresholds.structure, result);
+  },
+  async getCustomerTemperatureThresholds(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.customerTemperatureThresholds);
+    return bridgeTools.convertBytesToStructure(bridgeCommandStructures.axleTemperatureThresholds.structure, result);
+  },
+  async getCustomerImbalanceThresholds(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.customerImbalanceThresholds);
+    return bridgeTools.convertBytesToStructure(bridgeCommandStructures.axleImbalanceThresholds.structure, result);
+  },
+  async sendKeepAliveCommand(device) {
+    return this.promisify(device, [...this.getCommandHeader(device), 2, commandIds.keepAlive, 0]);
+  },
+  async sendOtaRequest(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const command = [commandIds.otaRequest, 0];
+    const result = await this.promisify(deviceData, [...this.getCommandHeader(deviceData), command.length, ...command]);
+    return result;
+  },
+  async sendPinCommand(deviceId) {
+    const deviceData = await getDeviceData(deviceId);
+    const pin = await bridgeSecurity.getPin(deviceId);
+    return this.promisify(deviceData, [...this.getCommandHeader(deviceData), 18, commandIds.pin, 0, ...pin]);
+  },
+  async setBridgeToRestart(deviceId) {
+    const deviceData = await getDeviceData(deviceId);
+    const useNewCommand = (deviceData.advertisingData.fwVersion || "") > "0.9.7";
+    await this.promisify(deviceData, [
+      ...this.getCommandHeader(deviceData),
+      2,
+      useNewCommand ? commandIds.ecuReset : commandIds.reboot,
+      useNewCommand ? subCommandIds.ecuResetSubCommand : subCommandIds.rebootSubCommand
+    ]);
+  },
+  async setCustomerCANSettings(deviceId, structurizedPayload) {
+    const deviceData = getDeviceData(deviceId);
+    const payload = bridgeTools.convertStructureToBytes(
+      bridgeCommandStructures.customerCanSettings.structure,
+      structurizedPayload
+    );
+    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.customerCanSettings, payload);
+  },
+  async getCustomerCrcSettings(deviceId) {
+    const result = await this.readCrcCommand(deviceId, subCommandIds.customerCanSettings);
+    let factorySettings = false;
+    if (!result?.length || result.every((n) => n === 0)) factorySettings = true;
+    return factorySettings;
+  },
+  async readCrcCommand(deviceId, subCommandId) {
+    const deviceData = getDeviceData(deviceId);
+    const commandLength = 2;
+    const result = await this.promisify(deviceData, [
+      ...this.getCommandHeader(deviceData),
+      commandLength,
+      commandIds.readData,
+      subCommandId
+    ]);
+    const crc = result.slice(result.length - 8, result.length - 4);
+    return crc;
+  },
+  async setWorkshopCANSettings(deviceId, structurizedPayload) {
+    const deviceData = getDeviceData(deviceId);
+    const payload = bridgeTools.convertStructureToBytes(
+      bridgeCommandStructures.workshopCanSettings.structure,
+      structurizedPayload
+    );
+    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.workshopCanSettings, payload);
+  },
+  async setBridgeConfiguration(deviceId, structurizedPayload) {
+    const deviceData = getDeviceData(deviceId);
+    const payload = bridgeTools.convertStructureToBytes(
+      bridgeCommandStructures.bridgeConfiguration.structure,
+      structurizedPayload
+    );
+    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.bridgeConfiguration, payload);
+  },
+  async setCustomerPressureThresholds(deviceId, structurizedPayload) {
+    const deviceData = getDeviceData(deviceId);
+    const payload = bridgeTools.convertStructureToBytes(
+      bridgeCommandStructures.axlePressureThresholds.structure,
+      structurizedPayload
+    );
+    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.customerPressureThresholds, payload);
+  },
+  async setCustomerTemperatureThresholds(deviceId, structurizedPayload) {
+    const deviceData = getDeviceData(deviceId);
+    const payload = bridgeTools.convertStructureToBytes(
+      bridgeCommandStructures.axleTemperatureThresholds.structure,
+      structurizedPayload
+    );
+    return await this.writeCommand(
+      deviceData,
+      commandIds.writeData,
+      subCommandIds.customerTemperatureThresholds,
+      payload
+    );
+  },
+  async setCustomerImbalanceThresholds(deviceId, structurizedPayload) {
+    const deviceData = getDeviceData(deviceId);
+    const payload = bridgeTools.convertStructureToBytes(
+      bridgeCommandStructures.axleImbalanceThresholds.structure,
+      structurizedPayload
+    );
+    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.customerImbalanceThresholds, payload);
+  },
+  async getAutolearnSettings(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.autolearnSettings);
+    return bridgeTools.convertBytesToStructure(bridgeCommandStructures.autolearnSettings.structure, result);
+  },
+  async getAutolearnIdStatus(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.autolearnIdStatus);
+    return bridgeTools.convertBytesToStructure(bridgeCommandStructures.autolearnIdStatus.structure, result);
+  },
+  async setAutoLearnSettings(deviceId, structurizedPayload) {
+    const deviceData = getDeviceData(deviceId);
+    const payload = bridgeTools.convertStructureToBytes(
+      bridgeCommandStructures.autolearnSettings.structure,
+      structurizedPayload
+    );
+    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.autolearnSettings, payload);
+  },
+  async setAutolearnIdStatus(deviceId, structurizedPayload) {
+    const deviceData = getDeviceData(deviceId);
+    const payload = bridgeTools.convertStructureToBytes(
+      bridgeCommandStructures.autolearnIdStatus.structure,
+      structurizedPayload
+    );
+    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.autolearnIdStatus, payload);
+  },
+  async getAutolearnUnknownSensors(device) {
+    const result = await this.readCommand(device, subCommandIds.autolearnUnknownSensors);
+    return bridgeTools.convertBytesToStructure(bridgeCommandStructures.autolearnUnknownSensors.structure, result);
+  },
+  async getAxleInfo(deviceId, axleIndex) {
+    const deviceData = getDeviceData(deviceId);
+    if (!___default.inRange(axleIndex, 0, 16)) throw new Error("Error getting an axle");
+    const result = await this.readCommand(deviceData, subCommandIds.idsPerWheel(axleIndex));
+    return result;
+  },
+  // move logic to bridge svc
+  async setAxleInfo(deviceId, axleIndex, data) {
+    const deviceData = getDeviceData(deviceId);
+    await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.idsPerWheel(axleIndex), data);
+  },
+  async getAxlesPressure(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.pressurePerAxle);
+    return result;
+  },
+  async getPressuresPerAxle(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.pressurePerAxle);
+    const structurizedData = bridgeTools.convertBytesToStructure(
+      bridgeCommandStructures.pressuresPerAxle.structure,
+      result
+    );
+    return structurizedData;
+  },
+  async setPressuresPerAxle(deviceId, structurizedPayload) {
+    const deviceData = getDeviceData(deviceId);
+    const payload = bridgeTools.convertStructureToBytes(
+      bridgeCommandStructures.pressuresPerAxle.structure,
+      structurizedPayload
+    );
+    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.pressurePerAxle, payload);
+  },
+  // // async setPressureThresholds(device: BleBridge, rules: any) {
+  // //   // https://tirecheck.atlassian.net/wiki/spaces/HWPRG/pages/6547767302/Technical+Design+Document+BLE+CAN+Bridge+Krone#Example.1
+  // //   let numberArray = [
+  // //     rules?.underinflation?.valueCritical || null,
+  // //     rules?.underinflation?.valueWarning || null,
+  // //     rules?.overinflation?.valueWarning || null,
+  // //     rules?.overinflation?.valueCritical || null,
+  // //   ]
+  // //   if (numberArray.includes(null)) {
+  // //     const defaultRules = userStore.maybeTcAccount?.ruleset || { underinflation: {}, overinflation: {} }
+  // //     const defaultArray = [
+  // //       defaultRules?.underinflation?.valueCritical || 100,
+  // //       defaultRules?.underinflation?.valueWarning || 90,
+  // //       defaultRules?.overinflation?.valueWarning || 90,
+  // //       defaultRules?.overinflation?.valueCritical || 100, // default values when threshold is not set should be discussed with managenemt
+  // //     ]
+  // //     numberArray = numberArray.map((x, index) => (x === null ? defaultArray[index] : x))
+  // //   }
+  // //   const allAxles = Array(15).fill(numberArray).flat()
+  // //   await this.writeCommand(device, commandIds.writeData, subCommandIds.customerPressureThresholds, allAxles)
+  // // },
+  async getVehicleLayout(deviceId) {
+    const deviceData = getDeviceData(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.vehicleLayout);
+    return result;
+  },
+  async getSensorMeasurement(deviceId, positionId) {
+    const deviceData = getDeviceData(deviceId);
+    const isSpare = String(positionId).endsWith("0");
+    const positionInfo = bridgeTools.getPositionInfo(positionId);
+    const { axlePosition, tyrePosition, isTwinTyre } = positionInfo;
+    if (axlePosition == null || isTwinTyre == null || tyrePosition == null) {
+      throw new Error(`Invalid positionId ${positionId}`);
+    }
+    const result = await this.writeCommand(
+      deviceData,
+      commandIds.sensorMeasurement,
+      subCommandIds.sensorMeasurementPerWheel(axlePosition, tyrePosition, isTwinTyre, isSpare),
+      []
+    );
+    return result;
+  },
+  async readCommand(device, subCommandId) {
+    const commandLength = 2;
+    const result = await this.promisify(device, [
+      ...this.getCommandHeader(device),
+      commandLength,
+      commandIds.readData,
+      subCommandId
+    ]);
+    const data = result.slice(19, result.length - 8);
+    return data;
+  },
+  async writeCommand(device, commandId, subCommandId, payload) {
+    const commandHead = this.getCommandHeader(device);
+    const macAddress = [0, 0, 0, 0, 0, 0];
+    const timestamp = bridgeTools.decimalToHex(Math.floor(Date.now() / 1e3));
+    const parsedTimestamp = timestamp.match(/.{2}/g)?.map((x) => Number.parseInt(x, 16));
+    if (parsedTimestamp?.length !== 4) throw new Error("Wrong timestamp format");
+    const paddedTimestamp = [...parsedTimestamp, 0, 0, 0, 0];
+    const crc = bridgeSecurity.getCrcArray([...macAddress, ...paddedTimestamp, ...payload]);
+    if (crc.length !== 4) throw new Error("Wrong crc length");
+    const commandLength = macAddress.length + paddedTimestamp.length + crc.length + payload.length + 2;
+    const writeCommand = [
+      ...commandHead,
+      commandLength,
+      commandId,
+      subCommandId,
+      ...macAddress,
+      ...paddedTimestamp,
+      ...payload,
+      ...crc
+    ];
+    if ([subCommandIds.vehicleLayout, subCommandIds.customerCanSettings, subCommandIds.workshopCanSettings].includes(
+      subCommandId
+    )) {
+      await this.setBridgeToRestart(device.id);
+    }
+    return await this.promisify(device, writeCommand);
+  },
+  async promisify(device, writeCommand) {
+    if (!writeCommand.every((n) => ___default.isNumber(n))) {
+      console.error("invallid command", writeCommand);
+      throw new Error("Invalid command");
+    }
+    if (!canCommunicateWith(device.id)) throw new Error("Bridge not connected");
+    clearTimeout(keepAliveTimer);
+    keepAliveTimer = setTimeout(() => {
+      if (!canCommunicateWith(device.id)) {
+        return;
+      }
+      this.sendKeepAliveCommand(device);
+    }, 1e4);
+    return promiseQueue$1.enqueue(device, writeCommand);
+  }
+};
+
+const otaServiceUuid = "1d14d6ee-fd63-4fa1-bfa4-8f47b42119f0";
+const otaControlCharacteristicUuid = "f7bf3564-fb6d-4e53-88a4-5e37e0326063";
+const otaDataCharacteristicUuid = "984227f3-34fc-4045-a5d0-2c581f81a153";
+const bridgeOtaCommands = {
+  async beginOta(deviceId) {
+    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([0]).buffer);
+  },
+  async uploadOtaChunk(deviceId, data) {
+    await bluetooth.write(deviceId, otaServiceUuid, otaDataCharacteristicUuid, data);
+  },
+  async endOta(deviceId) {
+    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([3]).buffer);
+  }
+};
+
+const mtu = 180;
+const bridgeOtaService = {
+  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
+    await delay(2e3);
+    progressCallback("Connecting to the bridge...", 0.1);
+    await bridgeOta.connect(deviceId);
+    progressCallback("Uploading bootloader...", 0.12);
+    await bridgeOtaCommands.beginOta(deviceId);
+    await uploadOta(deviceId, bootloader, (str, percents) => progressCallback(str, 0.12 + percents * 0.2));
+    await bridgeOtaCommands.endOta(deviceId);
+    progressCallback("Uploading application...", 0.32);
+    await bridgeOtaCommands.beginOta(deviceId);
+    await uploadOta(deviceId, firmware, (str, percents) => progressCallback(str, 0.32 + percents * 0.5));
+    await bridgeOtaCommands.endOta(deviceId);
+    progressCallback("Upload completed, disconnecting...", 0.81);
+    await bridgeOta.disconnect(deviceId);
+    progressCallback("Disconnected...", 0.82);
+  }
+};
+async function uploadOta(deviceId, firmwareBinary, reportStatus) {
+  let uploadedBytes = 0;
+  let chunkIndex = 0;
+  while (uploadedBytes < firmwareBinary.byteLength) {
+    if (chunkIndex % 100 === 0)
+      reportStatus(
+        `Uploading new firmware... (${___default.round(uploadedBytes / 1e3)} / ${___default.round(
+          firmwareBinary.byteLength / 1e3
+        )} KB)`,
+        uploadedBytes / firmwareBinary.byteLength
+      );
+    const chunkSize = Math.min(mtu - 3, firmwareBinary.byteLength - uploadedBytes);
+    const chunk = firmwareBinary.slice(uploadedBytes, uploadedBytes + chunkSize);
+    await bridgeOtaCommands.uploadOtaChunk(deviceId, chunk);
+    uploadedBytes += chunkSize;
+    chunkIndex++;
+  }
+}
+
+const bridgeOta = {
+  async connect(deviceId) {
+    await bluetooth.connect(deviceId, this.disconnect);
+    store.deviceState[deviceId] = "paired";
+  },
+  async disconnect(deviceId) {
+    store.deviceState[deviceId] = "disconnecting";
+    await bluetooth.disconnect(deviceId);
+    store.deviceState[deviceId] = "disconnected";
+  },
+  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
+    return bridgeOtaService.updateFirmware(deviceId, bootloader, firmware, progressCallback);
+  }
+};
+
+const vehicleLayoutAxleTypes = {
+  noAxle: [0, 0],
+  twoTyresAxle: [128, 2],
+  twoTyresAxleSpare: [128, 3],
+  fourTyresAxle: [192, 6],
+  fourTyresAxleSpare: [192, 7],
+  spareTyreAxle: [1, 0]
+};
+const bridgeService = {
+  updateFirmware,
+  getVehicle,
+  setVehicle,
+  getConfiguration,
+  setConfiguration,
+  getSensorReading,
+  getVehicleReadings,
+  resetAutolearnStatuses,
+  getAutolearnStatuses
+};
+async function updateFirmware(deviceId, bootloader, firmware, reportStatus) {
+  reportStatus("Sending OTA Request...", 0.02);
+  await bridgeCommands.sendOtaRequest(deviceId);
+  await toolsSvc.delay(2e3);
+  await bluetooth.scanDevices();
+  reportStatus("Discovering OTA Device...", 0.02);
+  await discoverOtaBridge(deviceId, (str, percents) => reportStatus(str, 0.02 + percents * 0.1));
+  await bridgeOta.updateFirmware(deviceId, bootloader, firmware, reportStatus);
+  reportStatus("Update completed", 1);
+  await waitForBridgeToReconnect(deviceId, (str, percents) => reportStatus(str, 0.85 + percents * 0.15));
+  reportStatus("Update finished!", 1);
+}
+async function setVehicleLayout(deviceId, tcVehicle) {
+  const spareTyres = tcVehicle.tcTyres?.filter((tyre) => String(tyre.mountedOn?.positionId).endsWith("0"));
+  let spareTyresCount = Math.min(spareTyres.length || 0, 2);
+  let layout = [];
+  for (let index = 0; index < 15; index++) {
+    const tyresCount = tcVehicle.axles && tcVehicle.axles[index]?.tyresCount;
+    if (tyresCount === 2) {
+      let value = vehicleLayoutAxleTypes.twoTyresAxle;
+      if (spareTyresCount) {
+        value = vehicleLayoutAxleTypes.twoTyresAxleSpare;
+        spareTyresCount -= 1;
+      }
+      layout = [...layout, ...value];
+      continue;
+    }
+    if (tyresCount === 4) {
+      let value = vehicleLayoutAxleTypes.fourTyresAxle;
+      if (spareTyresCount) {
+        value = vehicleLayoutAxleTypes.fourTyresAxleSpare;
+        spareTyresCount -= 1;
+      }
+      layout = [...layout, ...value];
+      continue;
+    }
+    layout = [...layout, ...vehicleLayoutAxleTypes.noAxle];
+  }
+  let vin = tcVehicle.vin ? tcVehicle.vin.split("").map((x) => x.charCodeAt(0)) : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+  if (vin.length !== 17) {
+    throw new Error(`Incorrect VIN length: ${vin}`);
+  }
+  if (isVersionGreaterThan(deviceId, "1.0.2")) {
+    vin = [...vin, 0];
+  }
+  await bridgeCommands.setVehicleLayout(deviceId, [...layout, ...vin]);
+}
+async function getConfiguration(deviceId) {
+  const customerCANSettings = await bridgeCommands.getCustomerCANSettings(deviceId);
+  const workshopCANSettings = await bridgeCommands.getWorkshopCANSettings(deviceId);
+  const bridgeConfiguration = await bridgeCommands.getBridgeConfiguration(deviceId);
+  const customerPressureThresholds = await bridgeCommands.getCustomerPressureThresholds(deviceId);
+  const customerTemperatureThresholds = await bridgeCommands.getCustomerTemperatureThresholds(deviceId);
+  const customerImbalanceThresholds = await bridgeCommands.getCustomerImbalanceThresholds(deviceId);
+  const pressuresPerAxle = await bridgeCommands.getPressuresPerAxle(deviceId);
+  let autolearnSettings;
+  if (isVersionGreaterThan(deviceId, "0.9.7")) {
+    autolearnSettings = await bridgeCommands.getAutolearnSettings(deviceId);
+  }
+  return {
+    customerCANSettings,
+    workshopCANSettings,
+    bridgeConfiguration,
+    customerPressureThresholds,
+    customerTemperatureThresholds,
+    customerImbalanceThresholds,
+    pressuresPerAxle,
+    autolearnSettings
+  };
+}
+function bridgeVehiclesDifference(original, change) {
+  const differences = [];
+  if (original.tcBridge?.id !== change.tcBridge?.id) differences.push("bridgeId");
+  if (original.vin !== change.vin) differences.push("vin");
+  const originalTyres = original.tcTyres.map((t) => {
+    return { positionId: t.mountedOn?.positionId, sensorId: t.tcTpmsSensor?.id || null };
+  });
+  const changeTyres = change.tcTyres?.map((t) => {
+    return { positionId: t.mountedOn?.positionId, sensorId: t.tcTpmsSensor?.id || null };
+  });
+  if (!___default.isEqual(___default.sortBy(changeTyres, "positionId"), ___default.sortBy(originalTyres, "positionId")))
+    differences.push("sensorPosition");
+  const originalAxlesPressure = original.axles.map((a) => {
+    return {
+      targetPressure: a.targetPressure,
+      maxTargetPressure: a.maxTargetPressure,
+      minTargetPressure: a.minTargetPressure
+    };
+  });
+  const changeAxlesPressure = change.axles.map((a) => {
+    return {
+      targetPressure: a.targetPressure,
+      maxTargetPressure: a.maxTargetPressure,
+      minTargetPressure: a.minTargetPressure
+    };
+  });
+  if (!___default.isEqual(changeAxlesPressure, originalAxlesPressure)) differences.push("axlePressure");
+  const originalAxleType = original.axles.map((a) => {
+    return {
+      isSteer: a.isSteer,
+      isSpare: a.isSpare,
+      isLift: a.isLift
+    };
+  });
+  const changeAxleType = change.axles.map((a) => {
+    return {
+      isSteer: a.isSteer,
+      isSpare: a.isSpare,
+      isLift: a.isLift
+    };
+  });
+  if (!___default.isEqual(changeAxleType, originalAxleType)) differences.push("axleType");
+  const originalTyresCount = original.axles.map((a) => a.tyresCount);
+  const changeTyresCount = change.axles.map((a) => a.tyresCount);
+  if (!___default.isEqual(originalTyresCount, changeTyresCount)) differences.push("vehicleLayout");
+  return { isDifferent: !!differences.length, differences };
+}
+async function bridgeConfigurationDifference(original, change) {
+  const propertiesToCheck = [
+    "customerCANSettings",
+    "workshopCANSettings",
+    "customerPressureThresholds",
+    "customerTemperatureThresholds",
+    "customerImbalanceThresholds",
+    "pressuresPerAxle"
+  ];
+  const differentProps = [];
+  for (const prop of propertiesToCheck) {
+    for (const key in change[prop]) {
+      if (original[prop][key] !== change[prop][key]) {
+        differentProps.push(prop);
+        break;
+      }
+    }
+  }
+  return { isDifferent: !!differentProps.length, differences: differentProps };
+}
+function getVehicleAxlesTypes(tcVehicle) {
+  const filteredAxles = tcVehicle?.axles?.filter((axle) => !axle.isSpare);
+  const axleTypesBinary = (filteredAxles || []).map((axle) => {
+    let binaryRepresentation = 1;
+    if (axle?.isLift) {
+      binaryRepresentation |= 2;
+    }
+    if (axle?.isSteer) {
+      binaryRepresentation |= 8;
+    }
+    if (axle?.isDrive) {
+      binaryRepresentation |= 16;
+    }
+    return bridgeTools.decimalToHex(binaryRepresentation);
+  });
+  return axleTypesBinary;
+}
+function getEmptyAxles() {
+  const defaultAxles = {};
+  ___default.range(1, 16).forEach((n) => {
+    const key = `axle${___default.padStart(n.toString(), 2, "0")}`;
+    defaultAxles[key] = "00";
+  });
+  return defaultAxles;
+}
+function assignAxleTypes(defaultAxles, axleTypes) {
+  for (let i = 0; i < Object.keys(defaultAxles).length && i < axleTypes?.length; i++) {
+    const key = Object.keys(defaultAxles)[i];
+    defaultAxles[key] = axleTypes[i];
+  }
+  return defaultAxles;
+}
+async function getAxlesWithAutolearnSettings(deviceId) {
+  const defaultAxles = getEmptyAxles();
+  const autolearnSettings = await bridgeCommands.getAutolearnSettings(deviceId);
+  const pickedProperties = ___default.pick(autolearnSettings, [
+    "checkingPeriod",
+    "isAutolearnEnabled",
+    "multiIdTimeout",
+    "temperatureLimit"
+  ]);
+  Object.assign(defaultAxles, pickedProperties);
+  return defaultAxles;
+}
+async function setAxleInfo(deviceId, tcVehicle) {
+  if (!tcVehicle.axles?.length) throw new Error("Vehicle has no axles");
+  const spareTyres = tcVehicle.tcTyres?.filter((t) => String(t.mountedOn?.positionId).endsWith("0")) || [];
+  for (let axleIndex = 0; axleIndex < tcVehicle.axles.length; axleIndex++) {
+    const tyres = [
+      "00000000",
+      "00000000",
+      "00000000",
+      "00000000",
+      "00000000",
+      "00000000",
+      // LO
+      "00000000",
+      // LI
+      "00000000",
+      // null position
+      "00000000",
+      // RI
+      "00000000",
+      // RO
+      "00000000",
+      "00000000",
+      "00000000",
+      "00000000",
+      "00000000"
+    ];
+    const axle = tcVehicle.axles[axleIndex];
+    const spareTyre = spareTyres[axleIndex];
+    if (spareTyre && spareTyre.tcTpmsSensor?.id) {
+      tyres[7] = bridgeTools.convertSensorIdForBridge(spareTyre.tcTpmsSensor?.id);
+    }
+    const axleTyres = tcVehicle.tcTyres?.filter(
+      (t) => t.mountedOn?.positionId ? bridgeTools.getPositionInfo(t.mountedOn?.positionId).axlePosition === axleIndex + 1 && spareTyre?.mountedOn?.positionId !== t.mountedOn?.positionId : false
+    ) || [];
+    for (let tyreIndex = 0; tyreIndex < axleTyres.length; tyreIndex++) {
+      const sensorId = axleTyres[tyreIndex].tcTpmsSensor?.id;
+      if (!sensorId) continue;
+      if (axle.isSpare) continue;
+      const isTwinTyre = axle.tyresCount === 4;
+      let bridgeTyreIndex = 0;
+      if (isTwinTyre && tyreIndex === 0) bridgeTyreIndex = 5;
+      if (isTwinTyre && tyreIndex === 1 || !isTwinTyre && tyreIndex === 0) bridgeTyreIndex = 6;
+      if (isTwinTyre && tyreIndex === 3) bridgeTyreIndex = 9;
+      if (isTwinTyre && tyreIndex === 2 || !isTwinTyre && tyreIndex === 1) bridgeTyreIndex = 8;
+      tyres[bridgeTyreIndex] = bridgeTools.convertSensorIdForBridge(sensorId);
+    }
+    if (!___default.inRange(axleIndex, 0, 16)) return;
+    const numberArray = tyres.map((x) => x.match(/.{2}/g)?.reverse()).flat().map((n) => n ? Number.parseInt(n, 16) : 0);
+    await bridgeCommands.setAxleInfo(deviceId, axleIndex, numberArray);
+  }
+}
+async function setAxlesPressure(deviceId, axles) {
+  let data = [];
+  let bridgeAxlesPressureData;
+  for (let index = 0; index < 15; index++) {
+    let { targetPressure, maxTargetPressure, minTargetPressure, isSpare } = axles[index] || {};
+    maxTargetPressure = bridgeTools.barToKpaByte(maxTargetPressure);
+    minTargetPressure = bridgeTools.barToKpaByte(minTargetPressure);
+    if (isSpare && axles[0]) {
+      targetPressure = bridgeTools.barToKpaByte(axles[0].targetPressure);
+    } else {
+      targetPressure = bridgeTools.barToKpaByte(targetPressure);
+    }
+    if (!maxTargetPressure) {
+      if (!bridgeAxlesPressureData) {
+        bridgeAxlesPressureData = await bridgeCommands.getAxlesPressure(deviceId);
+      }
+      maxTargetPressure = bridgeAxlesPressureData[index * 3] || 255;
+    }
+    if (targetPressure > maxTargetPressure) {
+      targetPressure = maxTargetPressure;
+    } else if (targetPressure < minTargetPressure) {
+      targetPressure = minTargetPressure;
+    }
+    data = data.concat([maxTargetPressure, minTargetPressure, targetPressure]);
+  }
+  await bridgeCommands.setAxlesPressure(deviceId, data);
+}
+async function setConfiguration(deviceId, bridgeConfiguration) {
+  const currentBridgeConfiguration = await getConfiguration(deviceId);
+  const configurationValidation = await bridgeConfigurationDifference(currentBridgeConfiguration, bridgeConfiguration);
+  if (configurationValidation.differences.includes("workshopCANSettings")) {
+    await bridgeCommands.setWorkshopCANSettings(deviceId, bridgeConfiguration.workshopCANSettings);
+  }
+  if (bridgeConfiguration.customerCANSettings) {
+    const isFactory = await bridgeCommands.getCustomerCrcSettings(deviceId);
+    if (configurationValidation.differences.includes("customerCANSettings") || isFactory) {
+      await bridgeCommands.setCustomerCANSettings(deviceId, bridgeConfiguration.customerCANSettings);
+    }
+  }
+  if (configurationValidation.differences.includes("customerPressureThresholds")) {
+    await bridgeCommands.setCustomerPressureThresholds(deviceId, bridgeConfiguration.customerPressureThresholds);
+  }
+  if (configurationValidation.differences.includes("customerTemperatureThresholds")) {
+    await bridgeCommands.setCustomerTemperatureThresholds(deviceId, bridgeConfiguration.customerTemperatureThresholds);
+  }
+  if (configurationValidation.differences.includes("customerImbalanceThresholds")) {
+    await bridgeCommands.setCustomerImbalanceThresholds(deviceId, bridgeConfiguration.customerImbalanceThresholds);
+  }
+  if (configurationValidation.differences.includes("pressuresPerAxle")) {
+    await bridgeCommands.setPressuresPerAxle(deviceId, bridgeConfiguration.pressuresPerAxle);
+  }
+}
+async function setVehicle(deviceId, tcVehicle) {
+  const currentTcVehicle = await getVehicle(deviceId);
+  const vehicleValidation = bridgeVehiclesDifference(currentTcVehicle, tcVehicle);
+  if (["bridgeId", "vehicleLayout", "vin"].some((n) => vehicleValidation.differences.includes(n))) {
+    await setVehicleLayout(deviceId, tcVehicle);
+  }
+  if (["bridgeId", "sensorPosition"].some((n) => vehicleValidation.differences.includes(n))) {
+    await setAxleInfo(deviceId, tcVehicle);
+  }
+  if (["bridgeId", "axlePressure"].some((n) => vehicleValidation.differences.includes(n))) {
+    await setAxlesPressure(deviceId, tcVehicle.axles);
+  }
+  if (isVersionGreaterThan(deviceId, "0.9.7")) {
+    if (["bridgeId", "axleType"].some((n) => vehicleValidation.differences.includes(n))) {
+      const defaultAxles = await getAxlesWithAutolearnSettings(deviceId);
+      const axleTypes = getVehicleAxlesTypes(tcVehicle);
+      const updatedAxles = assignAxleTypes(defaultAxles, axleTypes);
+      await bridgeCommands.setAutoLearnSettings(deviceId, updatedAxles);
+    }
+  }
+}
+async function getSensorReading(deviceId, positionId) {
+  const value = await bridgeCommands.getSensorMeasurement(deviceId, positionId);
+  const sensorId = value.slice(5, 9).reverse().map((s) => bridgeTools.decimalToHex(s).toUpperCase()).join("");
+  const correctedSensorId = bridgeTools.convertSensorIdFromBridge(sensorId);
+  return {
+    date: Date.now() - value[14] * 2e3,
+    sensorId: correctedSensorId,
+    sensorStatus: value[12],
+    eceStatus: value[13],
+    pressureIssue: getPressureIssue(deviceId, value[13]),
+    ...getPressureAndTemperatureReadingObjects(value[9], value[10])
+  };
+}
+async function getVehicleReadings(deviceId, tcVehicle) {
+  const readings = [];
+  try {
+    for (const vehicleTyre of tcVehicle.tcTyres) {
+      if (vehicleTyre.tcTpmsSensor && vehicleTyre.mountedOn?.positionId) {
+        if (!canCommunicateWith(deviceId)) return;
+        const reading = await getSensorReading(deviceId, vehicleTyre.mountedOn.positionId);
+        readings.push(reading);
+      }
+    }
+  } catch (error) {
+    console.error("getSensorReading failed: ", error);
+  }
+  return readings;
+}
+async function getAutolearnStatuses(deviceId, tcVehicle) {
+  if (!isVersionGreaterThan(deviceId, "0.9.7"))
+    throw new Error("getAutolearnStatuses is not supported by this firmware version");
+  const statuses = await bridgeCommands.getAutolearnIdStatus(deviceId);
+  const autolearnedStatuses = [];
+  const statusEntries = Object.values(statuses);
+  for (const tcTyre of tcVehicle.tcTyres) {
+    if (!tcTyre.mountedOn?.positionId || tcTyre.mountedOn?.positionId % 10 === 0) continue;
+    const axleIndex = Math.floor(tcTyre.mountedOn?.positionId / 100) - 1;
+    const axleStatuses = statusEntries[axleIndex];
+    const tyreIndex = getBridgeIndexFromPositionId(tcTyre.mountedOn.positionId, 7);
+    const tyreStatus = axleStatuses.split("").reverse().join("")[tyreIndex];
+    let autolearnedSensorId;
+    if (["1", "4", "9"].includes(tyreStatus)) {
+      const axleInfo = await bridgeCommands.getAxleInfo(deviceId, axleIndex);
+      const axleData = axleInfo.map((i) => bridgeTools.decimalToHex(i).toUpperCase());
+      const joinedAxleData = Array.from(
+        { length: axleData.length / 4 },
+        (_2, index) => axleData[4 * index + 3] + axleData[4 * index + 2] + axleData[4 * index + 1] + axleData[4 * index]
+      );
+      autolearnedSensorId = bridgeTools.convertSensorIdFromBridge(joinedAxleData[tyreIndex]);
+    }
+    autolearnedStatuses.push({
+      positionId: tcTyre.mountedOn.positionId,
+      autolearnedSensorId,
+      autolearnedStatus: getAutolearnStatusName(tyreStatus)
+    });
+  }
+  return autolearnedStatuses;
+}
+function getAutolearnStatusName(statusId) {
+  if (["2", "A"].includes(statusId)) {
+    return "error";
+  }
+  if (statusId === "4") {
+    return "known";
+  }
+  if (["1", "9"].includes(statusId)) {
+    return "unknown";
+  }
+  if (statusId === "0") {
+    return "default";
+  }
+  throw new Error("Unknown autolearn status");
+}
+async function resetAutolearnStatuses(deviceId, positionIds) {
+  if (!isVersionGreaterThan(deviceId, "0.9.7"))
+    throw new Error("resetAutolearnStatuses is not supported by this firmware version");
+  const statuses = await bridgeCommands.getAutolearnIdStatus(deviceId);
+  const statusesKeys = Object.keys(statuses);
+  const sortedByAxle = ___default.groupBy(positionIds, (p) => Math.floor(p / 100));
+  for (const [axleIndex, axlePositionIds] of Object.entries(sortedByAxle)) {
+    const statusesAxleIndex = Number(axleIndex) - 1;
+    for (const positionId of axlePositionIds) {
+      const bitIndex = getBridgeIndexFromPositionId(positionId, 7);
+      let status = statuses[statusesKeys[statusesAxleIndex]].split("").reverse().join("");
+      status = `${status.substring(0, bitIndex)}0${status.substring(bitIndex + 1)}`;
+      statuses[statusesKeys[statusesAxleIndex]] = status.split("").reverse().join("");
+    }
+  }
+  await bridgeCommands.setAutolearnIdStatus(deviceId, statuses);
+}
+function getBridgeIndexFromPositionId(positionId, centerIndex = 8) {
+  const halfPoint = positionId % 10 * 6;
+  const tyrePosition = positionId % 100;
+  const result = (tyrePosition - halfPoint) / 10 - (tyrePosition <= halfPoint ? 1 : 0);
+  const bitIndex = centerIndex + result;
+  return bitIndex;
+}
+function getPressureAndTemperatureReadingObjects(rawPressure, rawTemperature) {
+  if (rawTemperature === 255 || rawPressure === 0) {
+    return {
+      pressure: void 0,
+      temperature: void 0
+    };
+  }
+  const ambientTemperature = 20;
+  const measuredTemperature = rawTemperature - 40;
+  const measuredPressureAbsolute = rawPressure / 19.753086;
+  const compensatedPressureAbsolute = measuredPressureAbsolute * (273 + ambientTemperature) / (273 + measuredTemperature);
+  return {
+    pressure: {
+      raw: rawPressure,
+      meas: Math.max(0, measuredPressureAbsolute - 1),
+      bar: Math.max(0, compensatedPressureAbsolute - 1)
+    },
+    temperature: { raw: rawTemperature, amb: ambientTemperature, celsius: measuredTemperature }
+  };
+}
+function getPressureIssue(deviceId, eceStatus) {
+  if (eceStatus === 254) {
+    return {
+      date: Date.now(),
+      tcIssue: {
+        id: "outdatedCritical"
+      },
+      type: "outdated",
+      severity: "critical"
+    };
+  }
+  const usesNewValues = isVersionGreaterThan(deviceId, "0.8.F");
+  if (eceStatus === (usesNewValues ? 3 : 4)) {
+    return {
+      date: Date.now(),
+      tcIssue: {
+        id: "overinflationCritical"
+      },
+      type: "over_inflated",
+      severity: "critical"
+    };
+  }
+  if (eceStatus === (usesNewValues ? 1 : 3)) {
+    return {
+      date: Date.now(),
+      tcIssue: {
+        id: "overinflationWarning"
+      },
+      severity: "warning",
+      type: "over_inflated"
+    };
+  }
+  if (eceStatus === (usesNewValues ? 4 : 2)) {
+    return {
+      date: Date.now(),
+      tcIssue: {
+        id: "underinflationCritical"
+      },
+      severity: "critical",
+      type: "under_inflated"
+    };
+  }
+  if (eceStatus === (usesNewValues ? 2 : 1)) {
+    return {
+      date: Date.now(),
+      tcIssue: {
+        id: "underinflationWarning"
+      },
+      severity: "warning",
+      type: "under_inflated"
+    };
+  }
+}
+async function discoverOtaBridge(deviceId, reportStatus) {
+  for (let i = 0; i < 200; i++) {
+    const msg = "Discovering OTA bridge...";
+    reportStatus(msg, i / 200);
+    const d = store.devices[deviceId];
+    if (d) {
+      if (d.type === "bridgeOta") return d;
+      if (d.type === "bridge" && i > 100) throw new Error("Bridge has not switched to OTA mode. Please, try again.".t());
+    }
+    await toolsSvc.delay(200);
+  }
+  throw new Error("Cannot detect the bridge");
+}
+async function waitForBridgeToReconnect(deviceId, reportStatus) {
+  let receivedOta = false;
+  for (let i = 0; i < 200; i++) {
+    reportStatus("Waiting for bridge to reconnect...", i / 200);
+    const d = store.devices[deviceId];
+    if (d) {
+      if (d.type === "bridge") return d;
+      if (d.type === "bridgeOta" && i > 50) receivedOta = true;
+    }
+    await toolsSvc.delay(200);
+  }
+  if (receivedOta) {
+    throw new Error("Bridge has not switched from OTA mode. Please, try again.");
+  }
+  throw new Error("Cannot reconnect to the bridge after firmware update");
+}
+async function getVehicle(deviceId) {
+  if (!canCommunicateWith(deviceId)) throw new Error("Not connected to any device");
+  const deviceData = getDeviceData(deviceId);
+  const tcVehicle = {
+    registrationNumber: "",
+    vin: deviceData.vin,
+    axles: [],
+    tcTyres: [],
+    tcBridge: { id: deviceData.bridgeId }
+  };
+  await assignAxles(deviceId, tcVehicle);
+  await assignTyres(deviceId, tcVehicle);
+  return tcVehicle;
+}
+async function assignAxles(deviceId, tcVehicle) {
+  const result = await bridgeCommands.getVehicleLayout(deviceId);
+  const data = result.map((x) => bridgeTools.decimalToHex(x));
+  const joinedData = Array.from({ length: data.length / 2 }, (_2, index) => data[2 * index + 1] + data[2 * index]);
+  const activeAxles = joinedData.slice(0, 15).filter((x) => Number(`0x${x}`));
+  const axlesPressureData = await bridgeCommands.getAxlesPressure(deviceId);
+  let axleTypesBytes;
+  if (isVersionGreaterThan(deviceId, "0.9.7")) {
+    const axleTypes = await bridgeCommands.getAutolearnSettings(deviceId);
+    axleTypesBytes = bridgeTools.convertAutoLearnObjectToBinary(axleTypes);
+  }
+  for (let index = 0; index < activeAxles.length; index++) {
+    let isSteer = false;
+    let isDrive = false;
+    let isLift = false;
+    if (axleTypesBytes) {
+      const axleKey = `axle${String(index + 1).padStart(2, "0")}`;
+      const tempAxle = axleTypesBytes[axleKey];
+      isLift = tempAxle ? tempAxle.charAt(6) === "1" : false;
+      isSteer = tempAxle ? tempAxle.charAt(4) === "1" : false;
+      isDrive = tempAxle ? tempAxle.charAt(3) === "1" : false;
+    }
+    const tyreCount = Number.parseInt(activeAxles[index], 16).toString(2).split("").filter((x) => x === "1").length;
+    if (!tyreCount) continue;
+    const hasSpareTyre = tyreCount % 2 === 1;
+    const axle = { tyresCount: hasSpareTyre ? tyreCount - 1 : tyreCount, isSteer, isDrive, isLift };
+    const axleWithLimits = await assignAxlePressureLimits(deviceId, tcVehicle, axle, index, axlesPressureData);
+    tcVehicle.axles.push(axleWithLimits);
+    if (hasSpareTyre) {
+      const spareAxle = { tyresCount: 0, isSpare: true };
+      const spareAxleWithLimits = await assignAxlePressureLimits(deviceId, tcVehicle, spareAxle, 0, axlesPressureData);
+      tcVehicle.axles.push(spareAxleWithLimits);
+    }
+  }
+  tcVehicle.axles = ___default.sortBy(tcVehicle.axles, (a) => a.isSpare ? 1 : 0);
+}
+async function assignTyres(deviceId, tcVehicle) {
+  const mountedTyres = tcVehicle.axles.filter((a) => !a.isSpare);
+  for (let index = 0; index < tcVehicle.axles.length; index++) {
+    const axle = tcVehicle.axles[index];
+    const axleInfo = await bridgeCommands.getAxleInfo(deviceId, axle.isSpare ? index - mountedTyres.length : index) || [];
+    const axleData = axleInfo.map((i) => bridgeTools.decimalToHex(i).toUpperCase());
+    const joinedAxleData = Array.from(
+      { length: axleData.length / 4 },
+      (_2, index2) => axleData[4 * index2 + 3] + axleData[4 * index2 + 2] + axleData[4 * index2 + 1] + axleData[4 * index2]
+    );
+    if (axle.isSpare) {
+      const spareTyrePositionId = getPositionId(index + 1, 1, 0, true);
+      const spareTyre = createNewTyre(spareTyrePositionId);
+      if (Number.parseInt(joinedAxleData[7], 16)) {
+        spareTyre.tcTpmsSensor = {
+          id: bridgeTools.convertSensorIdFromBridge(joinedAxleData[7])
+          // 7th place is reserved for spare tyres
+        };
+      }
+      tcVehicle.tcTyres.push(spareTyre);
+      continue;
+    }
+    const hasTwoTyres = ___default.inRange(axle.tyresCount, 2, 4);
+    const hasFourTyres = ___default.inRange(axle.tyresCount, 4, 6);
+    let sensorIndexes = [];
+    if (hasTwoTyres) sensorIndexes = [6, 8];
+    if (hasFourTyres) sensorIndexes = [5, 6, 8, 9];
+    for (let tyreIndex = 0; tyreIndex < sensorIndexes.length; tyreIndex++) {
+      const tyrePositionId = getPositionId(index + 1, tyreIndex + 1, axle.tyresCount);
+      const tyre = createNewTyre(tyrePositionId);
+      if (Number.parseInt(joinedAxleData[sensorIndexes[tyreIndex]], 16)) {
+        tyre.tcTpmsSensor = {
+          id: bridgeTools.convertSensorIdFromBridge(joinedAxleData[sensorIndexes[tyreIndex]])
+        };
+      }
+      tcVehicle.tcTyres.push(tyre);
+    }
+  }
+}
+async function assignAxlePressureLimits(deviceId, tcVehicle, tcVehicleAxle, axleIndex, bridgeAxlesPressureData) {
+  const axlesPressureData = bridgeAxlesPressureData ?? await bridgeCommands.getAxlesPressure(deviceId);
+  if (axlesPressureData[axleIndex * 3]) {
+    tcVehicleAxle.maxTargetPressure = bridgeTools.kpaByteToBar(axlesPressureData[axleIndex * 3]);
+  }
+  if (axlesPressureData[axleIndex * 3 + 1]) {
+    tcVehicleAxle.minTargetPressure = bridgeTools.kpaByteToBar(axlesPressureData[axleIndex * 3 + 1]);
+  }
+  if (axlesPressureData[axleIndex * 3 + 2]) {
+    tcVehicleAxle.targetPressure = bridgeTools.kpaByteToBar(
+      axlesPressureData[axleIndex * 3 + 2],
+      void 0
+    );
+  }
+  return tcVehicleAxle;
+}
+function createNewTyre(positionId) {
+  return {
+    mountedOn: { positionId },
+    serialNumber: `TYRE-${positionId}`
+  };
+}
+
+const bridge = {
+  async connect(deviceId) {
+    await promiseQueue$1.clearQueue("Previous pending commands aborted");
+    const bridgeMeta = deviceMeta.bridge;
+    await bluetooth.connect(deviceId, this.disconnect);
+    await ble.requestMtu(deviceId, deviceMeta.bridge.mtu);
+    await ble.startNotification(
+      deviceId,
+      bridgeMeta.communication.serviceId,
+      bridgeMeta.communication.characteristicId,
+      (notification) => promiseQueue$1.processMessage(deviceId, notification),
+      (error) => console.log("Nofit Error", error)
+    );
+    await bridgeCommands.sendPinCommand(deviceId);
+    store.deviceState[deviceId] = "paired";
+  },
+  async disconnect(deviceId) {
+    store.deviceState[deviceId] = "disconnecting";
+    await promiseQueue$1.clearQueue("Previous pending commands aborted");
+    await bluetooth.disconnect(deviceId);
+    store.deviceState[deviceId] = "disconnected";
+  },
+  getVehicle: bridgeService.getVehicle,
+  setVehicle: bridgeService.setVehicle,
+  getConfiguration: bridgeService.getConfiguration,
+  setConfiguration: bridgeService.setConfiguration,
+  getSensorReading: bridgeService.getSensorReading,
+  getVehicleReadings: bridgeService.getVehicleReadings,
+  getAutolearnStatuses: bridgeService.getAutolearnStatuses,
+  resetAutolearnStatuses: bridgeService.resetAutolearnStatuses,
+  updateFirmware: bridgeService.updateFirmware
+};
+
+const flexiGaugeTpmsMeta = deviceMeta.flexiGaugeTpms;
+const flexiGaugeTpmsCommands = {
+  startTpmsScan,
+  getBattery
+};
+async function startTpmsScan(deviceId) {
+  if (!canCommunicateWith(deviceId)) throw new Error("Flexi Gauge not connected");
+  const scanMsg = stringToArrayBuffer("*TPMS ON TIME=10\r\n");
+  return bluetooth.write(
+    deviceId,
+    flexiGaugeTpmsMeta.communication.serviceId,
+    flexiGaugeTpmsMeta.communication.characteristicId,
+    scanMsg
+  );
+}
+async function getBattery(deviceId) {
+  const batteryValue = await bluetooth.read(
+    deviceId,
+    flexiGaugeTpmsMeta.battery.serviceId,
+    flexiGaugeTpmsMeta.battery.characteristicId
+  );
+  const battery = Array.from(new Uint8Array(batteryValue))[0];
+  return battery;
+}
+
+let sensorReadings = [];
+let treadDepthCallback;
+let buttonCallback;
+let tpmsCallback;
+const capabilities = [
+  {
+    id: "td",
+    processFn: processTreadDepth,
+    regex: /^\*TD.*/
+  },
+  {
+    id: "button",
+    processFn: processButtonPress,
+    regex: /^\*[UDLRC] $/
+  },
+  {
+    id: "tpms",
+    processFn: processTpms,
+    regex: /^\*TPMS.*/
+  }
+];
+const flexiGaugeTpmsService = {
+  startTpmsScan(deviceId) {
+    flexiGaugeTpmsCommands.startTpmsScan(deviceId);
+  },
+  getBattery(deviceId) {
+    return flexiGaugeTpmsCommands.getBattery(deviceId);
+  },
+  onTreadDepth(callback) {
+    treadDepthCallback = callback;
+  },
+  onButton(callback) {
+    buttonCallback = callback;
+  },
+  onTpms(callback) {
+    tpmsCallback = callback;
+  },
+  icon: "icon-flexigauge",
+  processMessage(deviceId, message) {
+    const numberArray = Array.from(new Uint8Array(message));
+    const stringFromBytes = String.fromCharCode.apply(null, numberArray).replace("\r\n", "");
+    for (const capability of capabilities) {
+      if (capability.regex.test(stringFromBytes)) {
+        return capability.processFn(stringFromBytes);
+      }
+    }
+  }
+};
+function processTreadDepth(value) {
+  const treadDepth = value.match(/\d+/)[0];
+  const convertedValue = treadDepth / 1e3;
+  treadDepthCallback(convertedValue);
+}
+function processButtonPress(value) {
+  const buttonName = value.match(/\*(.)/);
+  if (!buttonName || !buttonName[1]) throw new Error("Unrecognized button");
+  buttonCallback(buttonName[1]);
+}
+function processTpms(value) {
+  const groupedValue = value.split(" ");
+  const type = groupedValue[1];
+  if (type === "ISON") {
+    sensorReadings = [];
+  }
+  if (type === "DATA") {
+    const reading = {};
+    for (const group of groupedValue) {
+      if (!group.includes("=")) continue;
+      const groupString = group.replace(",", "");
+      const groupSeparated = groupString.split("=");
+      reading[groupSeparated[0]] = groupSeparated[1];
+    }
+    sensorReadings.push(reading);
+  }
+  if (type === "ENDSCANNING") {
+    if (!sensorReadings.length) {
+      return notify.create({
+        type: "info",
+        message: "No sensors found"
+      });
+    }
+    const strongestReading = sensorReadings.reduce((accumulator, currentReading) => {
+      return Number(currentReading.Rssi) > Number(accumulator.Rssi) ? currentReading : accumulator;
+    }, sensorReadings[0]);
+    tpmsCallback(strongestReading);
+  }
+}
+
+const flexiGaugeTpms = {
+  async connect(deviceId) {
+    const bridgeMeta = deviceMeta.flexiGaugeTpms;
+    await bluetooth.connect(deviceId, this.disconnect);
+    await ble.startNotification(
+      deviceId,
+      bridgeMeta.communication.serviceId,
+      bridgeMeta.communication.characteristicId,
+      (notification) => flexiGaugeTpmsService.processMessage(deviceId, notification),
+      (error) => console.log("Nofit Error", error)
+    );
+    store.deviceState[deviceId] = "paired";
+  },
+  async disconnect(deviceId) {
+    store.deviceState[deviceId] = "disconnecting";
+    await bluetooth.disconnect(deviceId);
+    store.deviceState[deviceId] = "disconnected";
+  },
+  onTreadDepth(callback) {
+    flexiGaugeTpmsService.onTreadDepth(callback);
+  },
+  onButtonPress(callback) {
+    flexiGaugeTpmsService.onButton(callback);
+  },
+  onTpms(callback) {
+    flexiGaugeTpmsService.onTpms(callback);
+  },
+  getBattery: flexiGaugeTpmsService.getBattery,
+  startTpmsScan: flexiGaugeTpmsService.startTpmsScan
+};
+
+const bridgeSimulator = {
+  async connect(bridge) {
+    bridge.status = "connecting";
+    await toolsSvc.delay(100);
+    bridge.status = "connected";
+  },
+  async disconnect(bridge) {
+    bridge.status = "disconnecting";
+    await toolsSvc.delay(100);
+    bridge.status = void 0;
+  },
+  createSimulatedBridge(initialData) {
+    return {
+      type: "bridge",
+      id: "bridge1",
+      rssi: -50,
+      bridgeId: "FFFFAABB",
+      vin: "VIN1",
+      name: "Bridge1",
+      simulatorData: {},
+      advertisingData: {
+        configVersion: 1,
+        macAddress: [1, 2, 3, 4, 5, 6],
+        randomAdvNumber: [0, 0, 0, 0, 0, 0, 0, 0],
+        vinNum: [86, 87, 88, 89, 90, 91, 92, 93],
+        fwVersion: "0.7.C",
+        timeFromStart: 255
+      },
+      ...initialData
+    };
+  }
+  //   simulateWriteToDevice(
+  //     device: SimulatedBluetoothDeviceBridge,
+  //     serviceId: string,
+  //     characteristicId: string,
+  //     value: ArrayBuffer,
+  //   ) {
+  //     const command = new Uint8Array(value)
+  //     if (!command.length) {
+  //       console.warn('[BT Simulator] Empty write command received')
+  //       return
+  //     }
+  //     const [_sl, _msgType, size, commandId, subCommandId, ...payloadBytes] = command
+  //     const payload = payloadBytes.slice(0, size - 2)
+  //     const _macAddress = payload.slice(0, 6)
+  //     const _paddedTimestamp = payload.slice(6, 14)
+  //     const _crc = payload.slice(-4)
+  //     const payloadData = payload.slice(14, -4)
+  //     const responseHeader = [
+  //       securityLevelIds.tirecheck,
+  //       messageTypeIds.response,
+  //       0,
+  //       commandId,
+  //       subCommandId,
+  //       ..._.range(14).map((x) => 0), // mac address and timestamp
+  //     ]
+  //     if (!devtoolsStore.simulatedBluetoothDeviceHandlers[device.id])
+  //       console.warn(`[Bluetooth] Device ${device.id} is disconnected`)
+  //     const simulateReadFromDevice = (data: ArrayBuffer) => {
+  //       const dataToSend = new Uint8Array(data)
+  //       devtoolsStore.simulatedBluetoothDeviceHandlers[device.id]?.(
+  //         new Uint8Array([...dataToSend, 0, 0, 0, 0, 0, 0, 0, 0]).buffer,
+  //       ) // Append CRC to the data
+  //     }
+  //     const context: BridgeSimulatorContext = { device, responseHeader, payloadData, simulateReadFromDevice }
+  //     if (commandId === commandIds.keepAlive) {
+  //       context.responseHeader = [
+  //         securityLevelIds.tirecheck,
+  //         messageTypeIds.response,
+  //         2,
+  //         commandIds.keepAliveResponse,
+  //         subCommandId,
+  //         ...Array.from({ length: 4 }).fill(0),
+  //       ]
+  //       return simulateKeepalive(context)
+  //     }
+  //     if (commandId === commandIds.pin) {
+  //       return simulatePinResponse(context)
+  //     }
+  //     if (commandId === commandIds.sensorMeasurement) {
+  //       return simulateReadSensorMeasurement(context, subCommandId)
+  //     }
+  //     if (subCommandId === subCommandIds.vehicleLayout) {
+  //       if (commandId === commandIds.readData) {
+  //         return simulateReadVehicleLayout(context)
+  //       }
+  //       if (commandId === commandIds.writeData) {
+  //         return simulateWriteVehicleLayout(context)
+  //       }
+  //     }
+  //     if (subCommandId === subCommandIds.pressurePerAxle) {
+  //       if (commandId === commandIds.readData) {
+  //         return simulateReadPressurePerAxle(context)
+  //       }
+  //       if (commandId === commandIds.writeData) {
+  //         return simulateWritePressurePerAxle(context)
+  //       }
+  //     }
+  //     if (subCommandId === subCommandIds.customerPressureThresholds) {
+  //       if (commandId === commandIds.readData) {
+  //         return simulateReadPressureThresholds(context)
+  //       }
+  //       if (commandId === commandIds.writeData) {
+  //         return simulateWritePressureThresholds(context)
+  //       }
+  //     }
+  //     if (_.inRange(subCommandId, subCommandIds.idsPerWheel(0), subCommandIds.idsPerWheel(16))) {
+  //       const axleIndex = subCommandId - subCommandIds.idsPerWheel(0)
+  //       if (commandId === commandIds.readData) {
+  //         return simulateReadSensorIdsPerWheel(axleIndex, context)
+  //       }
+  //       if (commandId === commandIds.writeData) {
+  //         return simulateWriteSensorIdsPerWheel(axleIndex, context)
+  //       }
+  //     }
+  //     if (
+  //       [
+  //         subCommandIds.rebootSubCommand,
+  //         subCommandIds.customerCanSettings,
+  //         subCommandIds.workshopCanSettings,
+  //         subCommandIds.bridgeConfiguration,
+  //         subCommandIds.customerTemperatureThresholds,
+  //         subCommandIds.customerImbalanceThresholds,
+  //       ].includes(subCommandId)
+  //     ) {
+  //       const { responseHeader, simulateReadFromDevice } = context
+  //       return simulateReadFromDevice?.(new Uint8Array([...responseHeader]).buffer)
+  //     }
+  //     console.error(`[Bluetooth simulator] Unknown command: 0x${commandId.toString(16)} 0x${subCommandId.toString(16)}`)
+  //   },
+};
+
+let simulatedDevices = {};
+let areSimulatorMethodsInjected = false;
+let advertisingInterval;
+const simulator = {
+  setSimulatedDevices(devices) {
+    ensureSimulatorMethodsAreInjected();
+    simulatedDevices = { ...devices };
+  },
+  addSimulatedDevice(device) {
+    ensureSimulatorMethodsAreInjected();
+    simulatedDevices[device.id] = device;
+  },
+  getSimulatedDevices() {
+    return simulatedDevices;
+  }
+};
+function ensureSimulatorMethodsAreInjected() {
+  if (areSimulatorMethodsInjected) return;
+  areSimulatorMethodsInjected = true;
+  const scanDevices = bluetooth.scanDevices;
+  bluetooth.scanDevices = async (...args) => {
+    scanDevices(...args);
+    if (advertisingInterval) {
+      clearInterval(advertisingInterval);
+      advertisingInterval = void 0;
+    }
+    advertisingInterval = toolsSvc.setIntervalImmediate(() => {
+      for (const key in simulatedDevices) {
+        deviceAdvertisingCallback?.(simulatedDevices[key]);
+      }
+    }, 2e3);
+  };
+  for (const key in bridge) {
+    const fnName = key;
+    const originalFn = bridge[fnName];
+    bridge[fnName] = (device, ...args) => {
+      const deviceId = device.id;
+      const simulatedDevice = simulatedDevices[deviceId];
+      if (simulatedDevices) return bridgeSimulator[fnName](simulatedDevice, ...args);
+      else return originalFn(device, ...args);
+    };
+  }
+}
+
+class BridgeTcVehicleAxle {
+  targetPressure;
+  tyresCount = 2;
+  isSteer;
+  isSpare;
+  isDrive;
+  isLift;
+  spacesBelow;
+  maxTargetPressure;
+  minTargetPressure;
 }
 
 function createTirecheckDeviceSdk(bleImplementation) {
   setBleImplementation(bleImplementation);
   return {
-    bluetooth
+    /** Generic methods common for all devices */
+    bluetooth,
+    /** Methods for working with Tirecheck CAN Bridge */
+    bridge,
+    /** Methods for working with Tirecheck CAN Bridge in OTA mode */
+    bridgeOta,
+    /** Methods for working with Tirecheck TPMS FlexiGauge */
+    flexiGaugeTpms,
+    /** Allows simulating devices without actually using bluetooth */
+    simulator
   };
 }
 
+exports.BridgeTcVehicleAxle = BridgeTcVehicleAxle;
 exports.createTirecheckDeviceSdk = createTirecheckDeviceSdk;