tirecheck-device-sdk 0.2.21 → 0.2.23

package/dist/index.cjs

@@ -47,6 +47,8 @@ const store = {
   // undefined => connecting => connected => paired => disconnecting => undefined
   /** some bridge commands require bridge reboot to be completed */
   bridgeRebootRequired: {},
+  /** Torque wrench properties, about device settings, mainly used for unit conversion */
+  torqueWrenchProperties: {},
   //** Ios uses generated device Id, bridges send mac address in advertising so internaly we always use mac address but when real device id is needed we check mapping table for it */
   deviceIdMapingTable: {},
   /** Used to change device state in store, also notifies app via calback. Every undefined state should have its reason so that app can handle it accordingly */
@@ -104,6 +106,10 @@ function stringToArrayBuffer(string) {
   }
   return array.buffer;
 }
+function decimalToHex(decimal, padStart = 2) {
+  const hex = decimal.toString(16);
+  return hex.padStart(padStart, "0");
+}
 const toolsSvc = {
   delay,
   setIntervalImmediate,
@@ -518,8 +524,26 @@ const deviceMeta = {
     },
     getDeviceInfoFromAdvertising: bridgeOtaAdvertisingParser.getDeviceInfoFromAdvertising
   },
+  // flexiGauge: {
+  //   nameRegex: /^Flexi.*v.*/,
+  //   communication: {
+  //     serviceId: '4880c12c-fdcb-4077-8920-a450d7f9b907',
+  //     characteristicId: 'fec26ec4-6d71-4442-9f81-55bc21d658d6',
+  //   },
+  //   battery: {
+  //     serviceId: '180f',
+  //     characteristicId: '2a19',
+  //   },
+  //   getDeviceInfoFromAdvertising: (device: PeripheralData) => {
+  //     const bleDevice: BleDevice = {
+  //       ...device,
+  //       type: 'flexiGauge',
+  //     }
+  //     return bleDevice
+  //   },
+  // },
   flexiGaugeTpms: {
-    nameRegex: /^Flexi.*/,
+    nameRegex: /^Flexi.*TPMS.*/,
     communication: {
       serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
       characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
@@ -534,9 +558,7 @@ const deviceMeta = {
         type: "flexiGaugeTpms"
       };
       return bleDevice;
-    },
-    reconnect: true
-    // Do we need it here?
+    }
   },
   pressureStick: {
     nameRegex: /Pressure Stick.*/,
@@ -551,6 +573,42 @@ const deviceMeta = {
       };
       return bleDevice;
     }
+  },
+  // ateq: {
+  //   nameRegex: /ATEQ.*/,
+  //   communication: {
+  //     serviceId: 'a002',
+  //     characteristicId: 'c305',
+  //   },
+  //   indicate: {
+  //     serviceId: 'a002',
+  //     characteristicId: 'c306',
+  //   },
+  //   getDeviceInfoFromAdvertising: (device: PeripheralData) => {
+  //     const bleDevice: BleDevice = {
+  //       ...device,
+  //       type: 'ateq',
+  //     }
+  //     return bleDevice
+  //   },
+  // },
+  torqueWrench: {
+    nameRegex: /^\d+(lbft|NM)-\d+$/i,
+    communication: {
+      serviceId: "49535343-fe7d-4ae5-8fa9-9fafd205e455",
+      characteristicId: "49535343-1e4d-4bd9-ba61-23c647249616"
+    },
+    battery: {
+      serviceId: "180f",
+      characteristicId: "2a19"
+    },
+    getDeviceInfoFromAdvertising: (device) => {
+      const bleDevice = {
+        ...device,
+        type: "torqueWrench"
+      };
+      return bleDevice;
+    }
   }
 };
 
@@ -1524,26 +1582,26 @@ const bridgeSecurity = {
 };
 
 const bridgeMeta = deviceMeta.bridge;
-const devicePromiseQueue = {};
-const deviceCurrentResolve = {};
-const deviceCurrentReject = {};
-const deviceResponseIdentifier = {};
+const devicePromiseQueue$1 = {};
+const deviceCurrentResolve$1 = {};
+const deviceCurrentReject$1 = {};
+const deviceResponseIdentifier$1 = {};
 const promiseQueue = {
   clearQueue(deviceId, message) {
-    if (deviceCurrentReject[deviceId]) {
-      deviceCurrentReject[deviceId](new Error(message ?? "Stopped sending commands"));
+    if (deviceCurrentReject$1[deviceId]) {
+      deviceCurrentReject$1[deviceId](new Error(message ?? "Stopped sending commands"));
     }
-    devicePromiseQueue[deviceId] = Promise.resolve();
-    deviceResponseIdentifier[deviceId] = [];
+    devicePromiseQueue$1[deviceId] = Promise.resolve();
+    deviceResponseIdentifier$1[deviceId] = [];
   },
   async enqueue(device, payload) {
-    if (devicePromiseQueue[device.id] === void 0) devicePromiseQueue[device.id] = Promise.resolve();
-    devicePromiseQueue[device.id] = devicePromiseQueue[device.id].then(() => {
+    if (devicePromiseQueue$1[device.id] === void 0) devicePromiseQueue$1[device.id] = Promise.resolve();
+    devicePromiseQueue$1[device.id] = devicePromiseQueue$1[device.id].then(() => {
       const promise = new Promise((resolve, reject) => {
-        deviceCurrentResolve[device.id] = resolve;
-        deviceCurrentReject[device.id] = reject;
-        const isKeepAlive = payload[3] === commandIds.keepAlive;
-        deviceResponseIdentifier[device.id] = [isKeepAlive ? 126 : 0, payload[4]];
+        deviceCurrentResolve$1[device.id] = resolve;
+        deviceCurrentReject$1[device.id] = reject;
+        const isKeepAlive = payload[3] === commandIds$1.keepAlive;
+        deviceResponseIdentifier$1[device.id] = [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) {
@@ -1569,21 +1627,21 @@ const promiseQueue = {
           );
         }
       });
-      return withTimeout(promise, 5e3, `Command timed out ${deviceResponseIdentifier[device.id]}, ${device.id}`);
+      return withTimeout(promise, 5e3, `Command timed out ${deviceResponseIdentifier$1[device.id]}, ${device.id}`);
     });
-    return devicePromiseQueue[device.id];
+    return devicePromiseQueue$1[device.id];
   },
   async processMessage(deviceId, payload) {
     const numberArray = Array.from(new Uint8Array(payload));
     if (numberArray[3] === 127) {
       console.error(numberArray);
-      return deviceCurrentReject[deviceId](new Error(`Command not succesful: ${numberArray[4]}`));
+      return deviceCurrentReject$1[deviceId](new Error(`Command not succesful: ${numberArray[4]}`));
     }
     if ([226, 81].includes(numberArray[3]) && numberArray[4] && toolsSvc.canCommunicateWith(deviceId)) {
       store.bridgeRebootRequired[deviceId] = true;
     }
-    if ((!deviceResponseIdentifier[deviceId][0] || numberArray[3] === deviceResponseIdentifier[deviceId][0]) && (!deviceResponseIdentifier[deviceId][1] || numberArray[4] === deviceResponseIdentifier[deviceId][1])) {
-      return deviceCurrentResolve[deviceId](numberArray);
+    if ((!deviceResponseIdentifier$1[deviceId][0] || numberArray[3] === deviceResponseIdentifier$1[deviceId][0]) && (!deviceResponseIdentifier$1[deviceId][1] || numberArray[4] === deviceResponseIdentifier$1[deviceId][1])) {
+      return deviceCurrentResolve$1[deviceId](numberArray);
     }
     console.warn("message from the device not belonging to the pending promise: ", numberArray);
   }
@@ -1600,7 +1658,7 @@ const messageTypeIds = {
   command: 0,
   response: 1
 };
-const commandIds = {
+const commandIds$1 = {
   readData: 34,
   writeData: 46,
   keepAlive: 62,
@@ -1649,7 +1707,7 @@ const subCommandIds = {
   autolearnIdStatus: 176,
   autolearnUnknownSensors: 192
 };
-___default.invert(commandIds);
+___default.invert(commandIds$1);
 ___default.invert(subCommandIds);
 const keepAliveTimer = {};
 const bridgeCommands = {
@@ -1660,7 +1718,7 @@ const bridgeCommands = {
   },
   async setAxlesPressure(deviceId, data) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
-    await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.pressurePerAxle, data);
+    await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.pressurePerAxle, data);
   },
   async setVehicleLayout(deviceId, structurizedPayload) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
@@ -1669,7 +1727,7 @@ const bridgeCommands = {
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
-    await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.vehicleLayout, payload);
+    await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.vehicleLayout, payload);
   },
   async getCustomerCANSettings(deviceId) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
@@ -1722,18 +1780,18 @@ const bridgeCommands = {
     return { ...structurized, isFactory: result.isFactory };
   },
   async sendKeepAliveCommand(device) {
-    return this.promisify(device, [...this.getCommandHeader(device), 2, commandIds.keepAlive, 0]);
+    return this.promisify(device, [...this.getCommandHeader(device), 2, commandIds$1.keepAlive, 0]);
   },
   async sendOtaRequest(deviceId) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
-    const command = [commandIds.otaRequest, 0];
+    const command = [commandIds$1.otaRequest, 0];
     const result = await this.promisify(deviceData, [...this.getCommandHeader(deviceData), command.length, ...command]);
     return result;
   },
   async sendPinCommand(deviceId) {
     const deviceData = await bridgeTools.getBridgeFromStore(deviceId);
     const pin = await bridgeSecurity.getPin(deviceId);
-    return this.promisify(deviceData, [...this.getCommandHeader(deviceData), 18, commandIds.pin, 0, ...pin]);
+    return this.promisify(deviceData, [...this.getCommandHeader(deviceData), 18, commandIds$1.pin, 0, ...pin]);
   },
   async setBridgeToRestart(deviceId) {
     if (store.bridgeRebootRequired[deviceId]) return;
@@ -1742,7 +1800,7 @@ const bridgeCommands = {
     await this.promisify(deviceData, [
       ...this.getCommandHeader(deviceData),
       2,
-      useNewCommand ? commandIds.ecuReset : commandIds.reboot,
+      useNewCommand ? commandIds$1.ecuReset : commandIds$1.reboot,
       useNewCommand ? subCommandIds.ecuResetSubCommand : subCommandIds.rebootSubCommand
     ]);
   },
@@ -1753,7 +1811,7 @@ const bridgeCommands = {
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
-    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.customerCanSettings, payload);
+    return await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.customerCanSettings, payload);
   },
   async setWorkshopCANSettings(deviceId, structurizedPayload) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
@@ -1762,7 +1820,7 @@ const bridgeCommands = {
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
-    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.workshopCanSettings, payload);
+    return await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.workshopCanSettings, payload);
   },
   async setCustomerPressureThresholds(deviceId, structurizedPayload) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
@@ -1771,7 +1829,7 @@ const bridgeCommands = {
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
-    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.customerPressureThresholds, payload);
+    return await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.customerPressureThresholds, payload);
   },
   async setCustomerTemperatureThresholds(deviceId, structurizedPayload) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
@@ -1782,7 +1840,7 @@ const bridgeCommands = {
     );
     return await this.writeCommand(
       deviceData,
-      commandIds.writeData,
+      commandIds$1.writeData,
       subCommandIds.customerTemperatureThresholds,
       payload
     );
@@ -1794,7 +1852,7 @@ const bridgeCommands = {
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
-    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.customerImbalanceThresholds, payload);
+    return await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.customerImbalanceThresholds, payload);
   },
   async getAutolearnSettings(deviceId) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
@@ -1823,7 +1881,7 @@ const bridgeCommands = {
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
-    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.autolearnSettings, payload);
+    return await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.autolearnSettings, payload);
   },
   async setAutolearnIdStatus(deviceId, structurizedPayload) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
@@ -1832,7 +1890,7 @@ const bridgeCommands = {
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
-    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.autolearnIdStatus, payload);
+    return await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.autolearnIdStatus, payload);
   },
   async getAutolearnUnknownSensors(device) {
     const result = await this.readCommand(device, subCommandIds.autolearnUnknownSensors);
@@ -1853,7 +1911,7 @@ const bridgeCommands = {
   // move logic to bridge svc
   async setAxleInfo(deviceId, axleIndex, data) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
-    await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.idsPerWheel(axleIndex), data);
+    await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.idsPerWheel(axleIndex), data);
   },
   async getAxlesPressure(deviceId) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
@@ -1877,7 +1935,7 @@ const bridgeCommands = {
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
-    return await this.writeCommand(deviceData, commandIds.writeData, subCommandIds.pressurePerAxle, payload);
+    return await this.writeCommand(deviceData, commandIds$1.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
@@ -1920,7 +1978,7 @@ const bridgeCommands = {
     }
     const result = await this.writeCommand(
       deviceData,
-      commandIds.sensorMeasurement,
+      commandIds$1.sensorMeasurement,
       subCommandIds.sensorMeasurementPerWheel(axlePosition, tyrePosition, isTwinTyre, isSpare),
       []
     );
@@ -1931,7 +1989,7 @@ const bridgeCommands = {
     const result = await this.promisify(device, [
       ...this.getCommandHeader(device),
       commandLength,
-      commandIds.readData,
+      commandIds$1.readData,
       subCommandId
     ]);
     const data = result.slice(19, result.length - 8);
@@ -2896,6 +2954,342 @@ 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] = ___default.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 = {
+  error: "004",
+  acknowledge: "005",
+  commTest: "100",
+  getProperties: "120",
+  startJob: "204",
+  stopJob: "206",
+  getNumberOfReadings: "224",
+  getReading: "200",
+  // Can only be called once for each reading.
+  getReadingAgain: "202",
+  getBattery: "150",
+  getTime: "209",
+  setTime: "208"
+};
+const errors = {
+  "01": "Bad string",
+  "02": "Bad checksum",
+  "03": "Unknown command",
+  "04": "No device present for command to act on",
+  "05": "Invalid sample speed",
+  "06": "Torque module offset difference bigger than 25%",
+  "07": "Torque module gain outside 0.9 to 1.1",
+  "08": "No RF properties",
+  "09": "No reply from RF",
+  "0A": "RF device already paired on this device",
+  "0C": "Invalid frequency",
+  "0D": "Invalid LED selection",
+  "0F": "Transducer preloaded",
+  "10": "No more readings",
+  "11": "Job already loaded",
+  "12": "No trace stored",
+  "13": "Wrong transducers selected for Multi Start Mode",
+  "14": "No short trace stored",
+  "15": "Job finished",
+  "16": "Missing time and date",
+  "17": "Bad units for wrench type",
+  "18": "Battery low"
+};
+const twMeta = deviceMeta.torqueWrench;
+const torqueWrenchCommands = {
+  async sendCommand(deviceId, command, params) {
+    const commandId = commandIds[command];
+    let message = `${commandStart}${commandId}`;
+    if (params?.length) {
+      message += `,${params.join(",")}`;
+    }
+    message += commandEnd;
+    const crc = getChecksum(message);
+    message += `${crc}\r`;
+    const array = new Uint8Array(message.length);
+    for (let i = 0, l = message.length; i < l; i++) {
+      array[i] = message.charCodeAt(i);
+    }
+    const decimalArray = Array.from(array);
+    let result;
+    try {
+      result = await torqueWrenchPromiseQueue.enqueue(deviceId, twMeta.communication, decimalArray, commandIds[command]);
+    } catch (error) {
+      const formattedError = formatError(error);
+      throw new Error(formattedError);
+    }
+    return result.map((num) => String.fromCharCode(num)).join("");
+  },
+  processMessage(deviceId, payload) {
+    torqueWrenchPromiseQueue.processMessage(deviceId, payload, getIdentifier, isComplete, isError);
+  }
+};
+function isComplete(message) {
+  const completeReading = message[0] === 123 && message.at(-1) === 13;
+  const completeCommand = message[0] === 36 && message.at(-1) === 13;
+  return completeReading || completeCommand;
+}
+function isError(message) {
+  return message[4] === 52;
+}
+function getIdentifier(message) {
+  if (message[0] === 123) return "200";
+  return message.slice(6, 9).map((num) => String.fromCharCode(num)).join("");
+}
+function getChecksum(message) {
+  let checksum = 0;
+  for (const ch of message) {
+    checksum ^= ch.charCodeAt(0);
+  }
+  return decimalToHex(checksum).toUpperCase();
+}
+function formatError(error) {
+  if (!error.cause) throw new Error(error);
+  const message = error.cause.slice(6, 8);
+  const errorId = message.map((num) => String.fromCharCode(num)).join("");
+  return errors[errorId] || "Unknown error";
+}
+
+let jobInterval = null;
+const torqueWrenchService = {
+  onReading(callback) {
+    simulatorSvc.registerEvent("tw:reading", callback);
+  },
+  async getProperties(deviceId) {
+    const result = {
+      serialNumber: "",
+      span: 0,
+      calibrationDate: "",
+      ppr: 0,
+      units: "Nm",
+      threshold: 10
+    };
+    const message = await torqueWrenchCommands.sendCommand(deviceId, "getProperties");
+    const params = getMessageParams(message);
+    if (params[4] === "3") result.units = "Nm";
+    else if (params[4] === "7") result.units = "lb-ft";
+    result.serialNumber = params[0];
+    result.span = Number.parseInt(params[1]);
+    if (result.units === "lb-ft") result.span = Math.floor(result.span * 0.738);
+    result.calibrationDate = params[2];
+    result.ppr = Number.parseInt(params[3]);
+    return result;
+  },
+  async startJob(deviceId, params) {
+    await this.stopJob(deviceId);
+    const { units, span, ppr, threshold } = store.torqueWrenchProperties[deviceId];
+    const { torqueMin, torqueMax, angleMin, angleMax, direction, jobTimeout } = params;
+    const msgParams = {
+      id: "01",
+      nuts: decimalToHex(params.nuts),
+      mode: units === "lb-ft" ? "20" : "1",
+      // Peak measurement mode
+      cycle: "7",
+      // 10 seconds cycle (probably for measurements - not sure what it does exactly, not specified in docs)
+      control: torqueMin != null || torqueMax != null ? "0" : "1",
+      direction: direction === "counter-clockwise" ? "1" : "0",
+      minTorqueThreshold: torqueToAdcParam(threshold, span, units),
+      torqueMin: torqueToAdcParam(torqueMin ?? 0, span, units),
+      torqueMax: torqueToAdcParam(torqueMax ?? -1, span, units),
+      clickThreshold: torqueToAdcParam(threshold, span, units),
+      // Probably not used in our case (for this specified mode).
+      angleMin: angleToPulsesParam(angleMin ?? 0, ppr),
+      angleMax: angleToPulsesParam(angleMax ?? -1, ppr),
+      frequency: "0542"
+      // No idea
+    };
+    const paramsString = Object.values(msgParams);
+    await torqueWrenchCommands.sendCommand(deviceId, "startJob", paramsString);
+    jobInterval = setInterval(async () => {
+      const numberOfReading = await this.getNumberOfReadings(deviceId);
+      if (numberOfReading.count > 0) this.getReading(deviceId);
+    }, 2e3);
+    if (jobTimeout) {
+      await new Promise(
+        (resolve) => setTimeout(() => {
+          this.stopJob(deviceId);
+          resolve("");
+        }, jobTimeout * 1e3)
+      );
+    }
+  },
+  async stopJob(deviceId) {
+    clearInterval(jobInterval);
+    return torqueWrenchCommands.sendCommand(deviceId, "stopJob");
+  },
+  async getNumberOfReadings(deviceId) {
+    const message = await torqueWrenchCommands.sendCommand(deviceId, "getNumberOfReadings");
+    const params = getMessageParams(message);
+    return { count: Number(params[0]), jobId: params[1] };
+  },
+  async getReading(deviceId) {
+    const reading = await torqueWrenchCommands.sendCommand(deviceId, "getReading");
+    const properties = {
+      jobId: reading.slice(2, 4),
+      nut: reading.slice(4, 6),
+      torqueAdc: reading.slice(6, 10),
+      anglePulses: reading.slice(10, 14),
+      duration: reading.slice(14, 18)
+    };
+    const torque = adcToTorque(
+      properties.torqueAdc,
+      store.torqueWrenchProperties[deviceId].span,
+      store.torqueWrenchProperties[deviceId].units
+    );
+    const angle = pulsesToAngle(properties.anglePulses, store.torqueWrenchProperties[deviceId].ppr);
+    const formattedReading = {
+      jobId: Number.parseInt(properties.jobId, 16),
+      nut: Number.parseInt(properties.nut, 16),
+      torque,
+      angle,
+      duration: Number.parseInt(properties.duration, 16) / 1e3
+    };
+    simulatorSvc.triggerEvent("tw:reading", deviceId, formattedReading);
+  },
+  // getReadingAgain(deviceId: string) {
+  //   return torqueWrenchCommands.sendCommand(deviceId, 'getNumberOfReadings')
+  // },
+  async getBattery(deviceId) {
+    const message = await torqueWrenchCommands.sendCommand(deviceId, "getBattery");
+    const params = getMessageParams(message);
+    return Number(params[0]);
+  },
+  async getTime(deviceId) {
+    const message = await torqueWrenchCommands.sendCommand(deviceId, "getTime");
+    const match = message.match(/209,([^*]*)\*/);
+    console.log("\u{1F680} ~ getTime ~ match:", match);
+    if (!match[1]) throw new Error("Invalid time response");
+    const hh = match[1].substring(0, 2);
+    const mm = match[1].substring(2, 4);
+    const ss = match[1].substring(4, 6);
+    const dd = match[1].substring(6, 8);
+    const MM = match[1].substring(8, 10);
+    const yy = match[1].substring(10, 12);
+    const fullYear = `20${yy}`;
+    return /* @__PURE__ */ new Date(`${fullYear}-${MM}-${dd}T${hh}:${mm}:${ss}Z`);
+  },
+  setTime(deviceId, date) {
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    const seconds = String(date.getSeconds()).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const year = String(date.getFullYear()).slice(-2);
+    const params = [hours, minutes, seconds, day, month, year];
+    return torqueWrenchCommands.sendCommand(deviceId, "setTime", params);
+  }
+};
+function torqueToAdcParam(value, span, deviceUnits) {
+  if (value < 0) return "FFFF";
+  if (deviceUnits !== "Nm") value = value * 0.738;
+  const adc = Math.round(value / span * 16384);
+  return decimalToHex(adc, 4).toUpperCase();
+}
+function angleToPulsesParam(value, ppr) {
+  if (value < 0) return "FFFF";
+  const pulses = Math.round(value * ppr / 90);
+  return decimalToHex(pulses, 4).toUpperCase();
+}
+function getMessageParams(message) {
+  return message.match(/^\$[^,]+,[^,]+,(.*)\*/)?.[1].split(",") || [];
+}
+function adcToTorque(value, span, units) {
+  const torque = Number.parseInt(value, 16) * span / 16384;
+  if (units !== "Nm") return torque / 0.738;
+  return torque;
+}
+function pulsesToAngle(value, ppr) {
+  return Number.parseInt(value, 16) * 90 / ppr;
+}
+
+const torqueWrench = {
+  async connect(deviceId) {
+    const twMeta = deviceMeta.torqueWrench;
+    await bluetooth.connect(deviceId, this.disconnect);
+    await ble.startNotification(
+      deviceId,
+      twMeta.communication.serviceId,
+      twMeta.communication.characteristicId,
+      (notification) => {
+        torqueWrenchCommands.processMessage(deviceId, notification);
+      },
+      (error) => console.warn("ble.startNotification error", error)
+    );
+    const properties = await torqueWrenchService.getProperties(deviceId);
+    store.torqueWrenchProperties[deviceId] = properties;
+    store.setState(deviceId, "paired");
+  },
+  async disconnect(deviceId, reason) {
+    store.setState(deviceId, "disconnecting");
+    await torqueWrenchService.stopJob(deviceId);
+    await bluetooth.disconnect(deviceId);
+    store.setState(deviceId, void 0, reason ?? "manualDisconnection");
+  },
+  getProperties: torqueWrenchService.getProperties,
+  setTime: torqueWrenchService.setTime,
+  startJob: torqueWrenchService.startJob,
+  stopJob: torqueWrenchService.stopJob,
+  getNumberOfReadings: torqueWrenchService.getNumberOfReadings,
+  getReading: torqueWrenchService.getReading,
+  getBattery: torqueWrenchService.getBattery,
+  getTime: torqueWrenchService.getTime,
+  onReading: torqueWrenchService.onReading
+};
+
 const bridgeSimulator = {
   isRebootRequired(deviceId) {
     return store.bridgeRebootRequired[deviceId];
@@ -3496,10 +3890,14 @@ function createTirecheckDeviceSdk(platform, bleImplementation, securityKeys) {
     bridgeOta,
     /** Methods for working with Tirecheck TPMS FlexiGauge */
     flexiGaugeTpms,
+    // flexiGauge,
     /** Methods for working with Tirecheck Pressure Stick */
     pressureStick,
+    // ateq,
     /** Allows simulating devices without actually using bluetooth */
-    simulator
+    simulator,
+    /** Methods for working with Tirecheck Torque Wrench */
+    torqueWrench
   };
 }