tirecheck-device-sdk 0.2.26 → 0.2.28

package/dist/index.mjs

@@ -99,6 +99,13 @@ function stringToArrayBuffer(string) {
   }
   return array.buffer;
 }
+function stringToDecimalArray(string) {
+  const array = new Uint8Array(string.length);
+  for (let i = 0, l = string.length; i < l; i++) {
+    array[i] = string.charCodeAt(i);
+  }
+  return Array.from(array);
+}
 function decimalToHex(decimal, padStart = 2) {
   const hex = decimal.toString(16);
   return hex.padStart(padStart, "0");
@@ -120,7 +127,7 @@ const tyreLabels = getDefaultTyreLabels();
 const bridgeTools = {
   getBridgeFromStore(deviceId) {
     const deviceData = store.devices[deviceId];
-    if (!deviceData) throw new Error("Device data missing");
+    if (!deviceData) throw new Error(`No device data found: ${deviceId}`);
     if (deviceData.type !== "bridge") throw new Error("Device is not bridge");
     return deviceData;
   },
@@ -182,12 +189,12 @@ const bridgeTools = {
     }
     const _reversedData = _data.reverse();
     if (displayUnits === "decimal") {
-      return Number(`0x${_reversedData.map((dec) => this.decimalToHex(dec)).join("")}`.replace(/\r\n/g, ""));
+      return Number(`0x${_reversedData.map((dec) => decimalToHex(dec)).join("")}`.replace(/\r\n/g, ""));
     }
     if (displayUnits === "reverseHex") {
-      return _reversedData.map((dec) => this.decimalToHex(dec).split("").reverse().join("")).join("");
+      return _reversedData.map((dec) => decimalToHex(dec).split("").reverse().join("")).join("");
     }
-    return _reversedData.map((dec) => this.decimalToHex(dec)).join("");
+    return _reversedData.map((dec) => decimalToHex(dec)).join("");
   },
   encodeData(data, displayUnits) {
     const _data = _.clone(data);
@@ -195,7 +202,7 @@ const bridgeTools = {
       return this.asciiToDecimalArray(_data);
     }
     if (displayUnits === "decimal") {
-      return this.hexToDecimalArray(this.decimalToHex(_data)).reverse();
+      return this.hexToDecimalArray(decimalToHex(_data)).reverse();
     }
     if (displayUnits === "reverseHex") {
       const byteArray = _data.match(/.{1,2}/g) || [];
@@ -211,10 +218,6 @@ const bridgeTools = {
     }
     return array;
   },
-  decimalToHex(decimal) {
-    const hex = decimal.toString(16);
-    return hex.padStart(2, "0");
-  },
   asciiToDecimalArray(ascii) {
     return ascii.split("").map((x) => x.charCodeAt(0));
   },
@@ -227,7 +230,7 @@ const bridgeTools = {
       return "";
     }
     return payload.reduce((acc, current) => {
-      const value = this.decimalToHex(current);
+      const value = decimalToHex(current);
       acc.push(value[0] === "0" ? value[1] : value);
       return acc;
     }, []).join(".");
@@ -349,7 +352,7 @@ const bridgeAdvertisingParser = {
     if (adversitingType !== "connectable") return;
     const advertisingData = getAdvertisingData({ advertising: device.advertising, deviceName: device.name });
     if (!advertisingData) return;
-    const macArray = advertisingData?.macAddress?.map((n) => bridgeTools.decimalToHex(n).toUpperCase()).reverse() || [];
+    const macArray = advertisingData?.macAddress?.map((n) => decimalToHex(n).toUpperCase()).reverse() || [];
     const bridgeId = macArray.join("");
     const vin = String.fromCharCode(...advertisingData?.vinNum || []).split("\0").join("");
     const macString = macArray.join(":");
@@ -465,7 +468,7 @@ const bridgeOtaAdvertisingParser = {
     let processedByteCount = 0;
     if (store.platform === "ios") {
       if (!device.advertising.kCBAdvDataLeBluetoothDeviceAddress) return void 0;
-      const macAddress = Array.from(new Uint8Array(device.advertising.kCBAdvDataLeBluetoothDeviceAddress)).slice(-6).reverse().map((x) => bridgeTools.decimalToHex(x).toUpperCase());
+      const macAddress = Array.from(new Uint8Array(device.advertising.kCBAdvDataLeBluetoothDeviceAddress)).slice(-6).reverse().map((x) => decimalToHex(x).toUpperCase());
       deviceId = macAddress.join(":");
       bridgeId = macAddress.join("");
     } else {
@@ -478,7 +481,7 @@ const bridgeOtaAdvertisingParser = {
         }
         processedByteCount += length + 1;
         if (identificator === 27) {
-          const macAddress = packet.slice(-6).reverse().map((x) => bridgeTools.decimalToHex(x).toUpperCase());
+          const macAddress = packet.slice(-6).reverse().map((x) => decimalToHex(x).toUpperCase());
           deviceId = macAddress.join(":");
           bridgeId = macAddress.join("");
           processedByteCount = adv.length;
@@ -536,7 +539,8 @@ const deviceMeta = {
   //   },
   // },
   flexiGaugeTpms: {
-    nameRegex: /^Flexi.*TPMS.*/,
+    // after implementation of normal fg replace with /^Flexi.*TPMS.*/,
+    nameRegex: /^Flexi.*/,
     communication: {
       serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
       characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
@@ -1467,7 +1471,7 @@ const bridgeSecurity = {
     const { randomAdvNumber, configVersion } = device?.advertisingData || {};
     if (!randomAdvNumber || !_.isNumber(configVersion)) return console.error("random not present", randomAdvNumber);
     const rand = _.clone(randomAdvNumber);
-    const security_level = bridgeTools.decimalToHex(command[0]);
+    const security_level = decimalToHex(command[0]);
     const keyIndex = Number(security_level[0]);
     const keyShift = Number(security_level[1]);
     let paddedCommand = [];
@@ -1482,8 +1486,8 @@ const bridgeSecurity = {
     const key = store.securityKeys.bridge.signatureKeys[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 shiftedKey = startArray.concat(endArray).map((n) => decimalToHex(n)).join("");
+    const dataIn = [...rand.reverse(), ...Array.from({ length: 8 }).fill(8)].map((x) => decimalToHex(x)).join("");
     const keyWA = CryptoJs.enc.Hex.parse(shiftedKey);
     const dataInWA = CryptoJs.enc.Hex.parse(dataIn);
     const encrypted = CryptoJs.AES.encrypt(dataInWA, keyWA, {
@@ -1501,8 +1505,8 @@ const bridgeSecurity = {
       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.enc.Hex.parse(xorBlock.map((x) => bridgeTools.decimalToHex(x)).join(""));
+      const vector = blockVector.map((x) => decimalToHex(x)).join("");
+      const dataWa = CryptoJs.enc.Hex.parse(xorBlock.map((x) => decimalToHex(x)).join(""));
       const testo = CryptoJs.AES.encrypt(dataWa, keyWA, {
         iv: CryptoJs.enc.Hex.parse(vector),
         mode: CryptoJs.mode.ECB,
@@ -1519,8 +1523,8 @@ const bridgeSecurity = {
     if (deviceData?.type !== "bridge") throw new Error("Device data missing 1 ");
     const { randomAdvNumber, macAddress, configVersion } = deviceData.advertisingData || {};
     if (!randomAdvNumber || !macAddress || !_.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 mac = macAddress.map((n) => decimalToHex(n)).join("");
+    const rand = randomAdvNumber.map((n) => decimalToHex(n)).join("");
     const message = `${mac}0000${rand}`;
     if (!store.securityKeys?.bridge?.pinKeys?.[configVersion]) throw new Error("No pin key found");
     const key = store.securityKeys?.bridge?.pinKeys[configVersion];
@@ -1532,9 +1536,7 @@ const bridgeSecurity = {
     const keyHex = CryptoJs.enc.Hex.parse(key);
     const encrypted = CryptoJs.AES.encrypt(messageHex, keyHex, {
       mode: CryptoJs.mode.ECB,
-      // You can use other modes like CBC or CTR for additional security
       padding: CryptoJs.pad.ZeroPadding
-      // You can use other padding modes as well
     });
     const encryptedByteString = CryptoJs.enc.Hex.stringify(encrypted.ciphertext).slice(0, 32);
     const hexArray = this.encryptedStringToNum(encryptedByteString);
@@ -1561,7 +1563,7 @@ const bridgeSecurity = {
   },
   getCrcArray(msg) {
     const crc = this.crc32mpeg2(msg);
-    const crcHex = bridgeTools.decimalToHex(crc).padStart(8, "0");
+    const crcHex = decimalToHex(crc).padStart(8, "0");
     return bridgeTools.hexToDecimalArray(crcHex).reverse();
   },
   uint32ToLittleEndian(value) {
@@ -1579,7 +1581,7 @@ const devicePromiseQueue$1 = {};
 const deviceCurrentResolve$1 = {};
 const deviceCurrentReject$1 = {};
 const deviceResponseIdentifier$1 = {};
-const promiseQueue = {
+const promiseQueue$1 = {
   clearQueue(deviceId, message) {
     if (deviceCurrentReject$1[deviceId]) {
       deviceCurrentReject$1[deviceId](new Error(message ?? "Stopped sending commands"));
@@ -1620,7 +1622,7 @@ const promiseQueue = {
           );
         }
       });
-      return withTimeout(promise, 5e3, `Command timed out ${deviceResponseIdentifier$1[device.id]}, ${device.id}`);
+      return withTimeout(promise, 8e3, `Command timed out ${deviceResponseIdentifier$1[device.id]}, ${device.id}`);
     });
     return devicePromiseQueue$1[device.id];
   },
@@ -1993,7 +1995,7 @@ const bridgeCommands = {
   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 timestamp = decimalToHex(Math.floor(Date.now() / 1e3));
     const parsedTimestamp = timestamp.match(/.{2}/g)?.map((x) => Number.parseInt(x, 16)).reverse();
     if (parsedTimestamp?.length !== 4) throw new Error("Wrong timestamp format");
     const paddedTimestamp = [...parsedTimestamp, 0, 0, 0, 0];
@@ -2031,7 +2033,7 @@ const bridgeCommands = {
       }
       this.sendKeepAliveCommand(device);
     }, 8e3);
-    return promiseQueue.enqueue(device, writeCommand);
+    return promiseQueue$1.enqueue(device, writeCommand);
   }
 };
 
@@ -2222,7 +2224,7 @@ function getVehicleAxlesTypes(tcVehicle) {
     if (axle?.isDrive) {
       binaryRepresentation |= 16;
     }
-    return bridgeTools.decimalToHex(binaryRepresentation);
+    return decimalToHex(binaryRepresentation);
   });
   return axleTypesBinary;
 }
@@ -2377,7 +2379,7 @@ async function setVehicle(deviceId, tcVehicle) {
 }
 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 sensorId = value.slice(5, 9).reverse().map((s) => decimalToHex(s).toUpperCase()).join("");
   const correctedSensorId = bridgeTools.convertSensorIdFromBridge(sensorId);
   return {
     date: Date.now() - value[14] * 2e3,
@@ -2419,7 +2421,7 @@ async function getAutolearnStatuses(deviceId, tcVehicle) {
     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 axleData = axleInfo.map((i) => 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]
@@ -2629,7 +2631,7 @@ async function assignTyres(deviceId, tcVehicle) {
   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 axleData = axleInfo.map((i) => 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]
@@ -2705,7 +2707,7 @@ const bridge = {
 };
 async function connect(deviceId, accessLevel) {
   if (canCommunicateWith(deviceId)) return;
-  await promiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
+  await promiseQueue$1.clearQueue(deviceId, "Previous pending commands aborted");
   const bridgeMeta = deviceMeta.bridge;
   await bluetooth.connect(deviceId, disconnect);
   if (store.deviceState[deviceId] === "paired") {
@@ -2720,7 +2722,7 @@ async function connect(deviceId, accessLevel) {
       _deviceId,
       bridgeMeta.communication.serviceId,
       bridgeMeta.communication.characteristicId,
-      (notification) => promiseQueue.processMessage(deviceId, notification),
+      (notification) => promiseQueue$1.processMessage(deviceId, notification),
       (error) => console.error("startNotification Error", error)
     );
     store.deviceAccessLevel[deviceId] = accessLevel ?? "driver";
@@ -2734,7 +2736,7 @@ async function connect(deviceId, accessLevel) {
 }
 async function disconnect(deviceId, reason) {
   store.setState(deviceId, "disconnecting");
-  promiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
+  promiseQueue$1.clearQueue(deviceId, "Previous pending commands aborted");
   await bluetooth.disconnect(deviceId);
   delete store.devices[deviceId];
   deviceUnreachableCallback?.(deviceId);
@@ -2765,10 +2767,118 @@ const simulatorSvc = {
   }
 };
 
+const devicePromiseQueue = {};
+const deviceCurrentResolve = {};
+const deviceCurrentReject = {};
+const deviceResponseIdentifier = {};
+const deviceCurrentPartialMessage = {};
+const promiseQueue = {
+  clearQueue(deviceId, message) {
+    if (deviceCurrentReject[deviceId]) {
+      deviceCurrentReject[deviceId](new Error(message ?? "Stopped sending commands"));
+    }
+    devicePromiseQueue[deviceId] = Promise.resolve();
+    deviceResponseIdentifier[deviceId] = void 0;
+  },
+  async enqueue(deviceId, communication, payload, responseIdentifier, mtu = 20) {
+    if (devicePromiseQueue[deviceId] === void 0) devicePromiseQueue[deviceId] = Promise.resolve();
+    devicePromiseQueue[deviceId] = devicePromiseQueue[deviceId].then(() => {
+      const promise = new Promise((resolve, reject) => {
+        deviceCurrentResolve[deviceId] = resolve;
+        deviceCurrentReject[deviceId] = reject;
+        deviceResponseIdentifier[deviceId] = responseIdentifier;
+        deviceCurrentPartialMessage[deviceId] = [];
+        if (!toolsSvc.canCommunicateWith(deviceId)) return reject(new Error("Torque wrench not connected"));
+        const chunks = [];
+        for (let i = 0; i < payload.length; i += mtu) {
+          chunks.push(payload.slice(i, i + mtu));
+        }
+        for (const chunk of chunks) {
+          const convertedChunk = new Uint8Array(chunk).buffer;
+          bluetooth.write(deviceId, communication.serviceId, communication.characteristicId, convertedChunk);
+        }
+      });
+      return withTimeout(promise, 5e3, `Command timed out ${deviceResponseIdentifier[deviceId]}, ${deviceId}`);
+    });
+    return devicePromiseQueue[deviceId];
+  },
+  async processMessage(deviceId, payload, getIdentifier, isComplete, isError) {
+    const numberArray = Array.from(new Uint8Array(payload));
+    if (!deviceCurrentPartialMessage[deviceId]) deviceCurrentPartialMessage[deviceId] = [];
+    deviceCurrentPartialMessage[deviceId] = _.concat(deviceCurrentPartialMessage[deviceId], numberArray);
+    if (!isComplete(deviceCurrentPartialMessage[deviceId])) {
+      return;
+    }
+    if (isError(deviceCurrentPartialMessage[deviceId])) {
+      return deviceCurrentReject[deviceId](
+        new Error("Error response", { cause: deviceCurrentPartialMessage[deviceId] })
+      );
+    }
+    const identifier = getIdentifier(deviceCurrentPartialMessage[deviceId]);
+    if (deviceResponseIdentifier[deviceId] === identifier) {
+      deviceCurrentResolve[deviceId](deviceCurrentPartialMessage[deviceId]);
+    }
+  }
+};
+
+const flexiGaugeTpmsSecurity = {
+  getCommandsSignature(seed) {
+    const key = store.securityKeys?.flexiGaugeTpms?.signatureKeys.allLFCommands;
+    if (!key) throw new Error("No Command key found");
+    return aesToCrc32(seed, key);
+  },
+  getWriteSignature(seed) {
+    const key = store.securityKeys?.flexiGaugeTpms?.signatureKeys.writeConfiguration;
+    if (!key) throw new Error("No Write key found");
+    return aesToCrc32(seed, key);
+  },
+  getCrc(message) {
+    const messageHex = message.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) ?? [];
+    const crc = crc16CCITT(messageHex);
+    return decimalToHex(crc, 4).toUpperCase();
+  }
+};
+function aesToCrc32(message, key) {
+  const keyString = key.map((n) => decimalToHex(n)).join("");
+  const messageHex = CryptoJs.enc.Hex.parse(message);
+  const keyHex = CryptoJs.enc.Hex.parse(keyString);
+  const encrypted = CryptoJs.AES.encrypt(messageHex, keyHex, {
+    mode: CryptoJs.mode.ECB,
+    padding: CryptoJs.pad.ZeroPadding
+  });
+  const encryptedByteString = CryptoJs.enc.Hex.stringify(encrypted.ciphertext).slice(0, 8).toUpperCase();
+  return encryptedByteString;
+}
+function crc16CCITT(msg) {
+  let crc = 65535;
+  const polynomial = 4129;
+  for (let i = 0; i < msg.length; i++) {
+    const b = msg[i];
+    crc ^= b << 8;
+    for (let j = 0; j < 8; j++) {
+      if (crc & 32768) {
+        crc = crc << 1 ^ polynomial;
+      } else {
+        crc <<= 1;
+      }
+      crc &= 65535;
+    }
+  }
+  return crc;
+}
+
 const flexiGaugeTpmsMeta = deviceMeta.flexiGaugeTpms;
 const flexiGaugeTpmsCommands = {
   startTpmsScan,
-  getBattery
+  getBattery,
+  vdaRequestSensor,
+  vdaRequestSeed,
+  vdaSendWriteModePin,
+  vdaReadConfiguration,
+  vdaSendConfiguration,
+  vdaRequestCommandsAccess,
+  vdaRequestWriteAccess,
+  processMessage
 };
 async function startTpmsScan(deviceId) {
   if (!canCommunicateWith(deviceId)) throw new Error("Flexi Gauge not connected");
@@ -2789,23 +2899,92 @@ async function getBattery(deviceId) {
   const battery = Array.from(new Uint8Array(batteryValue))[0];
   return battery;
 }
+async function vdaRequestSensor(deviceId) {
+  const scanMsg = "*VDA_LF_SEND SID=A0 LID=1A";
+  return await sendCommand(deviceId, scanMsg);
+}
+async function vdaRequestSeed(deviceId, sensorId) {
+  const sensorIdReversed = getReversedSensorId(sensorId);
+  const scanMsg = `*VDA_LF_SEND SID=A0 LID=AA PAR=04 DATA=${sensorIdReversed}CE9A5713`;
+  return await sendCommand(deviceId, scanMsg);
+}
+async function vdaRequestCommandsAccess(deviceId, sensorId, signature) {
+  const sensorIdReversed = getReversedSensorId(sensorId);
+  const scanMsg = `*VDA_LF_SEND SID=A0 LID=AA PAR=00 DATA=${sensorIdReversed}${signature}`;
+  return await sendCommand(deviceId, scanMsg);
+}
+async function vdaRequestWriteAccess(deviceId, sensorId, signature) {
+  const sensorIdReversed = getReversedSensorId(sensorId);
+  const scanMsg = `*VDA_LF_SEND SID=A0 LID=AA PAR=02 DATA=${sensorIdReversed}${signature}`;
+  return await sendCommand(deviceId, scanMsg);
+}
+async function vdaSendWriteModePin(deviceId) {
+  const scanMsg = stringToArrayBuffer("*VDA_LF_SEND SID=A0 LID=AA PAR=00 DATA=FCCC71F6\r\n");
+  await bluetooth.write(
+    deviceId,
+    flexiGaugeTpmsMeta.communication.serviceId,
+    flexiGaugeTpmsMeta.communication.characteristicId,
+    scanMsg
+  );
+}
+async function vdaReadConfiguration(deviceId) {
+  const scanMsg = "*VDA_LF_SEND SID=A0 LID=DA PAR=17";
+  return await sendCommand(deviceId, scanMsg);
+}
+async function vdaSendConfiguration(deviceId, configuration) {
+  if (configuration.length !== 60) throw new Error("Invalid sensor configuration");
+  const crc = flexiGaugeTpmsSecurity.getCrc(configuration);
+  const scanMsg = `*VDA_LF_SEND SID=A0 LID=EA PAR=17 DATA=${configuration}${crc}`;
+  return await sendCommand(deviceId, scanMsg);
+}
+async function sendCommand(deviceId, command) {
+  const message = `${command}\r
+`;
+  const decimalArray = stringToDecimalArray(message);
+  let result;
+  try {
+    result = await promiseQueue.enqueue(deviceId, flexiGaugeTpmsMeta.communication, decimalArray, "VDA");
+  } catch (error) {
+    flexiGaugeTpms.disconnect(deviceId, "lostConnection");
+    throw error;
+  }
+  return result.map((num) => String.fromCharCode(num)).join("");
+}
+function processMessage(deviceId, payload) {
+  promiseQueue.processMessage(deviceId, payload, getIdentifier$1, isComplete$1, isError$1);
+}
+function isComplete$1(message) {
+  const completeCommand = message.at(-1) === 10;
+  return completeCommand;
+}
+function isError$1(message) {
+  return false;
+}
+function getIdentifier$1(message) {
+  const messageString = message.map((num) => String.fromCharCode(num)).join("");
+  return messageString.slice(0, 3);
+}
+function getReversedSensorId(sensorId) {
+  return sensorId.match(/.{1,2}/g).reverse().join("");
+}
 
 let sensorReadings = [];
 const capabilities$1 = [
   {
     id: "td",
     processFn: processTreadDepth,
-    regex: /^\*TD.*/
+    regex: /^\*?TD.*/
+    // old fw sends * for some responses and new fw doesnt send * on any response
   },
   {
     id: "button",
     processFn: processButtonPress,
-    regex: /^\*[UDLRC] $/
+    regex: /^\*?[UDLRC] $/
   },
   {
     id: "tpms",
     processFn: processTpms,
-    regex: /^\*TPMS.*/
+    regex: /^\*?TPMS.*/
   }
 ];
 const flexiGaugeTpmsService = {
@@ -2833,7 +3012,9 @@ const flexiGaugeTpmsService = {
         return capability.processFn(deviceId, stringFromBytes);
       }
     }
-  }
+    flexiGaugeTpmsCommands.processMessage(deviceId, message);
+  },
+  programSensor
 };
 function processTreadDepth(deviceId, value) {
   const treadDepth = value.match(/\d+/)?.[0];
@@ -2872,6 +3053,44 @@ function processTpms(deviceId, value) {
     simulatorSvc.triggerEvent("fg:tpms", deviceId, strongestReading);
   }
 }
+async function programSensor(deviceId, oldSensorId, newSensorId) {
+  await findSensor(deviceId, oldSensorId);
+  const seed = await getSeed(deviceId, oldSensorId);
+  const commandsSignature = await flexiGaugeTpmsSecurity.getCommandsSignature(seed);
+  const writeSignature = await flexiGaugeTpmsSecurity.getWriteSignature(seed);
+  await flexiGaugeTpmsCommands.vdaRequestCommandsAccess(deviceId, oldSensorId, commandsSignature);
+  await flexiGaugeTpmsCommands.vdaRequestWriteAccess(deviceId, oldSensorId, writeSignature);
+  const config = await getSensorConfiguration(deviceId);
+  const newConfig = config.replace(/^.{8}/, newSensorId);
+  await flexiGaugeTpmsCommands.vdaSendConfiguration(deviceId, newConfig);
+  await findSensor(deviceId, newSensorId);
+}
+async function getSeed(deviceId, sensorId) {
+  const response = await vdaRepeat(flexiGaugeTpmsCommands.vdaRequestSeed(deviceId, sensorId));
+  return response[3];
+}
+async function findSensor(deviceId, sensorId) {
+  let seen = 0;
+  for (let i = 0; i < 13; i++) {
+    const response = await vdaRepeat(flexiGaugeTpmsCommands.vdaRequestSensor(deviceId));
+    if (response[2] === sensorId) seen++;
+    if (seen === 3) return;
+  }
+  throw new Error(`Sensor ${sensorId} not found`);
+}
+async function getSensorConfiguration(deviceId) {
+  const response = await vdaRepeat(flexiGaugeTpmsCommands.vdaReadConfiguration(deviceId));
+  return response[3].slice(2, -4);
+}
+async function vdaRepeat(fn) {
+  for (let i = 0; i < 5; i++) {
+    const response = await fn;
+    const groupedValue = response.split(" ");
+    if (groupedValue[1].includes("TIMEOUT")) continue;
+    if (response) return groupedValue;
+  }
+  throw new Error("VDA Timeout");
+}
 
 const flexiGaugeTpms = {
   async connect(deviceId) {
@@ -2895,7 +3114,8 @@ const flexiGaugeTpms = {
   onButtonPress: flexiGaugeTpmsService.onButton,
   onTpms: flexiGaugeTpmsService.onTpms,
   getBattery: flexiGaugeTpmsService.getBattery,
-  startTpmsScan: flexiGaugeTpmsService.startTpmsScan
+  startTpmsScan: flexiGaugeTpmsService.startTpmsScan,
+  programSensor: flexiGaugeTpmsService.programSensor
 };
 
 const capabilities = [
@@ -2947,60 +3167,6 @@ const pressureStick = {
   onPressure: pressureStickService.onPressure
 };
 
-const devicePromiseQueue = {};
-const deviceCurrentResolve = {};
-const deviceCurrentReject = {};
-const deviceResponseIdentifier = {};
-const deviceCurrentPartialMessage = {};
-const torqueWrenchPromiseQueue = {
-  clearQueue(deviceId, message) {
-    if (deviceCurrentReject[deviceId]) {
-      deviceCurrentReject[deviceId](new Error(message ?? "Stopped sending commands"));
-    }
-    devicePromiseQueue[deviceId] = Promise.resolve();
-    deviceResponseIdentifier[deviceId] = void 0;
-  },
-  async enqueue(deviceId, communication, payload, responseIdentifier, mtu = 20) {
-    if (devicePromiseQueue[deviceId] === void 0) devicePromiseQueue[deviceId] = Promise.resolve();
-    devicePromiseQueue[deviceId] = devicePromiseQueue[deviceId].then(() => {
-      const promise = new Promise((resolve, reject) => {
-        deviceCurrentResolve[deviceId] = resolve;
-        deviceCurrentReject[deviceId] = reject;
-        deviceResponseIdentifier[deviceId] = responseIdentifier;
-        deviceCurrentPartialMessage[deviceId] = [];
-        if (!toolsSvc.canCommunicateWith(deviceId)) return reject(new Error("Torque wrench not connected"));
-        const chunks = [];
-        for (let i = 0; i < payload.length; i += mtu) {
-          chunks.push(payload.slice(i, i + mtu));
-        }
-        for (const chunk of chunks) {
-          const convertedChunk = new Uint8Array(chunk).buffer;
-          bluetooth.write(deviceId, communication.serviceId, communication.characteristicId, convertedChunk);
-        }
-      });
-      return withTimeout(promise, 5e3, `Command timed out ${deviceResponseIdentifier[deviceId]}, ${deviceId}`);
-    });
-    return devicePromiseQueue[deviceId];
-  },
-  async processMessage(deviceId, payload, getIdentifier, isComplete, isError) {
-    const numberArray = Array.from(new Uint8Array(payload));
-    if (!deviceCurrentPartialMessage[deviceId]) deviceCurrentPartialMessage[deviceId] = [];
-    deviceCurrentPartialMessage[deviceId] = _.concat(deviceCurrentPartialMessage[deviceId], numberArray);
-    if (!isComplete(deviceCurrentPartialMessage[deviceId])) {
-      return;
-    }
-    if (isError(deviceCurrentPartialMessage[deviceId])) {
-      return deviceCurrentReject[deviceId](
-        new Error("Error response", { cause: deviceCurrentPartialMessage[deviceId] })
-      );
-    }
-    const identifier = getIdentifier(deviceCurrentPartialMessage[deviceId]);
-    if (deviceResponseIdentifier[deviceId] === identifier) {
-      deviceCurrentResolve[deviceId](deviceCurrentPartialMessage[deviceId]);
-    }
-  }
-};
-
 const commandStart = "$9";
 const commandEnd = "*";
 const commandIds = {
@@ -3060,16 +3226,15 @@ const torqueWrenchCommands = {
     const decimalArray = Array.from(array);
     let result;
     try {
-      result = await torqueWrenchPromiseQueue.enqueue(deviceId, twMeta.communication, decimalArray, commandIds[command]);
+      result = await promiseQueue.enqueue(deviceId, twMeta.communication, decimalArray, commandIds[command]);
     } catch (error) {
       const formattedError = formatError(error);
-      torqueWrench.disconnect(deviceId, "lostConnection");
       throw new Error(formattedError);
     }
     return result.map((num) => String.fromCharCode(num)).join("");
   },
   processMessage(deviceId, payload) {
-    torqueWrenchPromiseQueue.processMessage(deviceId, payload, getIdentifier, isComplete, isError);
+    promiseQueue.processMessage(deviceId, payload, getIdentifier, isComplete, isError);
   }
 };
 function isComplete(message) {
@@ -3092,7 +3257,7 @@ function getChecksum(message) {
   return decimalToHex(checksum).toUpperCase();
 }
 function formatError(error) {
-  if (!error.cause) throw new Error(error);
+  if (!error.cause) throw error;
   const message = error.cause.slice(6, 8);
   const errorId = message.map((num) => String.fromCharCode(num)).join("");
   return errors[errorId] || "Unknown error";
@@ -3204,8 +3369,7 @@ const torqueWrenchService = {
   },
   async getTime(deviceId) {
     const message = await torqueWrenchCommands.sendCommand(deviceId, "getTime");
-    const match = message.match(/209,([^*]*)\*/);
-    console.log("\u{1F680} ~ getTime ~ match:", match);
+    const match = message.match(/209,([^*]*)\*/) ?? [];
     if (!match[1]) throw new Error("Invalid time response");
     const hh = match[1].substring(0, 2);
     const mm = match[1].substring(2, 4);
@@ -3254,7 +3418,7 @@ const torqueWrench = {
   async connect(deviceId) {
     const twMeta = deviceMeta.torqueWrench;
     await bluetooth.connect(deviceId, this.disconnect);
-    await torqueWrenchPromiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
+    await promiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
     await ble.startNotification(
       deviceId,
       twMeta.communication.serviceId,
@@ -3274,7 +3438,7 @@ const torqueWrench = {
       await torqueWrenchService.stopJob(deviceId);
     } catch {
     }
-    await torqueWrenchPromiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
+    await promiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
     await bluetooth.disconnect(deviceId);
     store.setState(deviceId, void 0, reason ?? "manualDisconnection");
   },
@@ -3625,6 +3789,9 @@ const flexiGaugeTpmsSimulator = {
     await toolsSvc.delay(200);
     return fg.simulatorData.battery;
   },
+  programSensor(deviceId, oldSensorId, newSensorId) {
+    return new Promise((resolve) => resolve());
+  },
   onButtonPress(callback) {
   },
   onTpms(callback) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirecheck-device-sdk",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "SDK for working with various devices produced by Tirecheck via Bluetooth (CAN Bridge, Routers, Sensors, FlexiGauge, PressureStick, etc)",
   "author": "Leonid Buneev <leonid.buneev@tirecheck.com>",
   "license": "ISC",