tirecheck-device-sdk 0.2.65 → 0.2.67

package/dist/index.mjs

@@ -221,6 +221,14 @@ const bridgeTools = {
   hexToDecimalArray(hex) {
     return hex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || [];
   },
+  /** Combine little-endian bytes (low byte first) into a single integer. */
+  bytesToInt(bytes) {
+    return bytes.reduce((acc, byte, index) => acc + ((byte || 0) << 8 * index), 0);
+  },
+  /** Split an integer into `byteCount` little-endian bytes (low byte first). */
+  intToBytes(value, byteCount) {
+    return Array.from({ length: byteCount }, (_unused, index) => value >> 8 * index & 255);
+  },
   getFwVersion(payload) {
     if (payload?.length !== 3) {
       console.warn("Could not process FwVersion ", payload);
@@ -239,9 +247,7 @@ const bridgeTools = {
   },
   convertBarToKpaByte(deviceId, value) {
     if (!value) return 0;
-    const deviceData = getBridgeFromStore(deviceId);
-    if (!deviceData) throw new Error(`Cannot convert bar to kpa byte, no device data found: ${deviceId}`);
-    const bitValue = deviceData.name.includes("030717") ? 6.7 : 5.0625;
+    const bitValue = this.usesKpaPressure(deviceId) ? 1 : 5.0625;
     return _.round((value + 1) * 100 / bitValue);
   },
   convertSensorIdForBridge(sensorId) {
@@ -264,9 +270,7 @@ const bridgeTools = {
     if (!_.isNumber(value)) {
       throw new TypeError("Value has to be a number");
     }
-    const deviceData = getBridgeFromStore(deviceId);
-    if (!deviceData) throw new Error(`Cannot convert kpa byte to bar, no device data found: ${deviceId}`);
-    const bitValue = deviceData.name.includes("030717") ? 6.7 : 5.0625;
+    const bitValue = this.usesKpaPressure(deviceId) ? 1 : 5.0625;
     const rawBar = value * bitValue / 100;
     return _.round(Math.max(rawBar - decrementValue, 0), 1);
   },
@@ -280,6 +284,9 @@ const bridgeTools = {
     }
     return false;
   },
+  usesKpaPressure(deviceId) {
+    return this.isVersionGreaterThan(deviceId, "1.1.F");
+  },
   convertSensorIdFromBridge(sensorId) {
     if (sensorId.startsWith("B")) {
       return Number.parseInt(sensorId, 16).toString();
@@ -1259,6 +1266,78 @@ const bridgeCommandStructures = {
       }
     }
   },
+  /**
+   * kPa per-axle pressure layout used from FW 1.2.0 onwards (same sub-command 0x30 as `pressuresPerAxle`).
+   * Each axle packs the same three values (set; min; max) but every value is a 2-byte little-endian raw kPa
+   * uint16 (no 5.0625 bit scaling), so each axle is 6 bytes instead of 3. Selected at runtime via
+   * `bridgeTools.usesKpaPressure(deviceId)`.
+   */
+  pressuresPerAxleKpa: {
+    id: [98, 48],
+    name: "pressuresPerAxleKpa",
+    structure: {
+      axle01: {
+        size: 6,
+        description: "Axle 01 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle02: {
+        size: 6,
+        description: "Axle 02 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle03: {
+        size: 6,
+        description: "Axle 03 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle04: {
+        size: 6,
+        description: "Axle 04 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle05: {
+        size: 6,
+        description: "Axle 05 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle06: {
+        size: 6,
+        description: "Axle 06 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle07: {
+        size: 6,
+        description: "Axle 07 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle08: {
+        size: 6,
+        description: "Axle 08 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle09: {
+        size: 6,
+        description: "Axle 09 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle10: {
+        size: 6,
+        description: "Axle 10 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle11: {
+        size: 6,
+        description: "Axle 11 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle12: {
+        size: 6,
+        description: "Axle 12 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle13: {
+        size: 6,
+        description: "Axle 13 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle14: {
+        size: 6,
+        description: "Axle 14 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      },
+      axle15: {
+        size: 6,
+        description: "Axle 15 set pressure; min pressure; max pressure (2-byte little-endian kPa values)"
+      }
+    }
+  },
   autolearnSettings: {
     id: [98, 160],
     name: "autolearnSettings",
@@ -1564,6 +1643,95 @@ const bridgeCommandStructures = {
         version: "1.0.3"
       }
     }
+  },
+  idsPerWheel: {
+    // base sub-command id, the actual axle is addressed via `0x20 + axleIndex` (0x20 - 0x2F)
+    id: [98, 32],
+    name: "idsPerWheel",
+    structure: {
+      wheel01: {
+        size: 4,
+        description: "Wheel 01 sensor ID (4-byte, little-endian)"
+      },
+      wheel02: {
+        size: 4,
+        description: "Wheel 02 sensor ID (4-byte, little-endian)"
+      },
+      wheel03: {
+        size: 4,
+        description: "Wheel 03 sensor ID (4-byte, little-endian)"
+      },
+      wheel04: {
+        size: 4,
+        description: "Wheel 04 sensor ID (4-byte, little-endian)"
+      },
+      wheel05: {
+        size: 4,
+        description: "Wheel 05 sensor ID (4-byte, little-endian)"
+      },
+      wheel06: {
+        size: 4,
+        description: "Wheel 06 sensor ID (4-byte, little-endian), left-outer position"
+      },
+      wheel07: {
+        size: 4,
+        description: "Wheel 07 sensor ID (4-byte, little-endian), left-inner position"
+      },
+      wheel08: {
+        size: 4,
+        description: "Wheel 08 sensor ID (4-byte, little-endian), center / spare position"
+      },
+      wheel09: {
+        size: 4,
+        description: "Wheel 09 sensor ID (4-byte, little-endian), right-inner position"
+      },
+      wheel10: {
+        size: 4,
+        description: "Wheel 10 sensor ID (4-byte, little-endian), right-outer position"
+      },
+      wheel11: {
+        size: 4,
+        description: "Wheel 11 sensor ID (4-byte, little-endian)"
+      },
+      wheel12: {
+        size: 4,
+        description: "Wheel 12 sensor ID (4-byte, little-endian)"
+      },
+      wheel13: {
+        size: 4,
+        description: "Wheel 13 sensor ID (4-byte, little-endian)"
+      },
+      wheel14: {
+        size: 4,
+        description: "Wheel 14 sensor ID (4-byte, little-endian)"
+      },
+      wheel15: {
+        size: 4,
+        description: "Wheel 15 sensor ID (4-byte, little-endian)"
+      }
+    }
+  },
+  firmwareVersion: {
+    id: [98, 144],
+    name: "firmwareVersion",
+    structure: {
+      bluetoothStackVersion: {
+        size: 20,
+        description: "Bluetooth stack version + bootloader (e.g. BT stack 4.0.0.191)"
+      },
+      configurationDataVersion: {
+        size: 4,
+        description: "Configuration data version"
+      },
+      bleChipFwCompilationDate: {
+        size: 7,
+        description: "BLE chip FW compilation date: second, minute, hour, day, month, year (2-byte, big-endian)"
+      },
+      bluetoothChipFwVersion: {
+        size: 4,
+        description: "Bluetooth chip FW version: major.minor.patch + release type (e.g. 1.2.0 Release)"
+      }
+    }
   }
 };
 
@@ -1973,12 +2141,13 @@ const bridgeCommands = {
     );
     return await this.writeCommand(deviceData, commandIds$1.writeData, subCommandIds.autolearnIdStatus, payload);
   },
-  async getAutolearnUnknownSensors(device) {
-    const result = await this.readCommand(device, subCommandIds.autolearnUnknownSensors);
+  async getAutolearnUnknownSensors(deviceId) {
+    const deviceData = bridgeTools.getBridgeFromStore(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.autolearnUnknownSensors);
     const structurized = bridgeTools.convertBytesToStructure(
       bridgeCommandStructures.autolearnUnknownSensors.structure,
       result.data,
-      device.advertisingData.fwVersion
+      deviceData.advertisingData.fwVersion
     );
     return { ...structurized, isFactory: result.isFactory };
   },
@@ -2002,8 +2171,9 @@ const bridgeCommands = {
   async getPressuresPerAxle(deviceId) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
     const result = await this.readCommand(deviceData, subCommandIds.pressurePerAxle);
+    const structure = bridgeTools.usesKpaPressure(deviceId) ? bridgeCommandStructures.pressuresPerAxleKpa.structure : bridgeCommandStructures.pressuresPerAxle.structure;
     const structurizedData = bridgeTools.convertBytesToStructure(
-      bridgeCommandStructures.pressuresPerAxle.structure,
+      structure,
       result.data,
       deviceData.advertisingData.fwVersion
     );
@@ -2011,8 +2181,9 @@ const bridgeCommands = {
   },
   async setPressuresPerAxle(deviceId, structurizedPayload) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
+    const structure = bridgeTools.usesKpaPressure(deviceId) ? bridgeCommandStructures.pressuresPerAxleKpa.structure : bridgeCommandStructures.pressuresPerAxle.structure;
     const payload = bridgeTools.convertStructureToBytes(
-      bridgeCommandStructures.pressuresPerAxle.structure,
+      structure,
       structurizedPayload,
       deviceData.advertisingData.fwVersion
     );
@@ -2049,6 +2220,18 @@ const bridgeCommands = {
     );
     return structurizedData;
   },
+  async getFirmwareVersion(deviceId) {
+    const deviceData = bridgeTools.getBridgeFromStore(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.firmwareVersion, {
+      headerLength: 5,
+      footerLength: 0
+    });
+    return bridgeTools.convertBytesToStructure(
+      bridgeCommandStructures.firmwareVersion.structure,
+      result.data,
+      deviceData.advertisingData.fwVersion
+    );
+  },
   async getSensorMeasurement(deviceId, positionId) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
     const isSpare = String(positionId).endsWith("0");
@@ -2062,7 +2245,7 @@ const bridgeCommands = {
     const result = await this.writeCommand(deviceData, commandIds$1.sensorMeasurement, subCommandId, []);
     return result;
   },
-  async readCommand(device, subCommandId) {
+  async readCommand(device, subCommandId, { headerLength = 19, footerLength = 8 } = {}) {
     const commandLength = 2;
     const result = await this.promisify(device, [
       ...this.getCommandHeader(device),
@@ -2070,9 +2253,9 @@ const bridgeCommands = {
       commandIds$1.readData,
       subCommandId
     ]);
-    const data = result.slice(19, result.length - 8);
-    const crc = result.slice(result.length - 8, result.length - 4);
-    const isFactory = crc.every((n) => n === 0);
+    const data = result.slice(headerLength, result.length - footerLength);
+    const crc = result.slice(result.length - footerLength, result.length - footerLength + 4);
+    const isFactory = crc.length === 4 && crc.every((n) => n === 0);
     return { data, isFactory };
   },
   async writeCommand(device, commandId, subCommandId, payload) {
@@ -2209,7 +2392,7 @@ async function setVehicleLayout(deviceId, tcVehicle) {
   }
   await bridgeCommands.setVehicleLayout(deviceId, result);
 }
-async function getConfiguration(deviceId) {
+async function getConfiguration(deviceId, includeVehicleData = false) {
   const customerCANSettings = await bridgeCommands.getCustomerCANSettings(deviceId);
   const workshopCANSettings = await bridgeCommands.getWorkshopCANSettings(deviceId);
   const customerPressureThresholds = await bridgeCommands.getCustomerPressureThresholds(deviceId);
@@ -2220,7 +2403,7 @@ async function getConfiguration(deviceId) {
   if (bridgeTools.isVersionGreaterThan(deviceId, "0.9.7")) {
     autolearnSettings = await bridgeCommands.getAutolearnSettings(deviceId);
   }
-  return {
+  const configuration = {
     customerCANSettings,
     workshopCANSettings,
     customerPressureThresholds,
@@ -2229,6 +2412,24 @@ async function getConfiguration(deviceId) {
     pressuresPerAxle,
     autolearnSettings
   };
+  if (includeVehicleData) {
+    configuration.vehicleLayout = await bridgeCommands.getVehicleLayout(deviceId);
+    configuration.axleInfo = [];
+    for (let axleIndex = 0; axleIndex < 15; axleIndex++) {
+      const axleBytes = await bridgeCommands.getAxleInfo(deviceId, axleIndex);
+      configuration.axleInfo.push(
+        bridgeTools.convertBytesToStructure(bridgeCommandStructures.idsPerWheel.structure, axleBytes)
+      );
+    }
+    if (bridgeTools.isVersionGreaterThan(deviceId, "1.1.F")) {
+      configuration.firmwareVersion = await bridgeCommands.getFirmwareVersion(deviceId);
+    }
+    if (bridgeTools.isVersionGreaterThan(deviceId, "0.9.7")) {
+      configuration.autolearnIdStatus = await bridgeCommands.getAutolearnIdStatus(deviceId);
+      configuration.autolearnUnknownSensors = await bridgeCommands.getAutolearnUnknownSensors(deviceId);
+    }
+  }
+  return configuration;
 }
 function bridgeVehiclesDifference(original, change) {
   const differences = [];
@@ -2397,6 +2598,8 @@ async function setAxleInfo(deviceId, tcVehicle) {
 async function setAxlesPressure(deviceId, axles) {
   let data = [];
   let bridgeAxlesPressureData;
+  const width = bridgeTools.usesKpaPressure(deviceId) ? 2 : 1;
+  const maxFallback = width === 2 ? 65535 : 255;
   for (let index = 0; index < 15; index++) {
     let { targetPressure, maxTargetPressure, minTargetPressure, isSpare } = axles[index] || {};
     maxTargetPressure = bridgeTools.convertBarToKpaByte(deviceId, maxTargetPressure);
@@ -2410,14 +2613,19 @@ async function setAxlesPressure(deviceId, axles) {
       if (!bridgeAxlesPressureData) {
         bridgeAxlesPressureData = await bridgeCommands.getAxlesPressure(deviceId);
       }
-      maxTargetPressure = bridgeAxlesPressureData.data[index * 3] || 255;
+      const base = index * width * 3;
+      maxTargetPressure = bridgeTools.bytesToInt(bridgeAxlesPressureData.data.slice(base, base + width)) || maxFallback;
     }
     if (targetPressure > maxTargetPressure) {
       targetPressure = maxTargetPressure;
     } else if (targetPressure < minTargetPressure) {
       targetPressure = minTargetPressure;
     }
-    data = data.concat([maxTargetPressure, minTargetPressure, targetPressure]);
+    data = data.concat([
+      ...bridgeTools.intToBytes(maxTargetPressure, width),
+      ...bridgeTools.intToBytes(minTargetPressure, width),
+      ...bridgeTools.intToBytes(targetPressure, width)
+    ]);
   }
   await bridgeCommands.setAxlesPressure(deviceId, data);
 }
@@ -2764,21 +2972,20 @@ async function assignTyres(deviceId, tcVehicle) {
 }
 async function assignAxlePressureLimits(deviceId, tcVehicle, tcVehicleAxle, axleIndex, bridgeAxlesPressureData) {
   const axlesPressureData = bridgeAxlesPressureData ?? (await bridgeCommands.getAxlesPressure(deviceId)).data;
-  if (axlesPressureData[axleIndex * 3]) {
-    tcVehicleAxle.maxTargetPressure = _.floor(
-      bridgeTools.convertKpaByteToBar(deviceId, axlesPressureData[axleIndex * 3]),
-      1
-    );
+  const width = bridgeTools.usesKpaPressure(deviceId) ? 2 : 1;
+  const base = axleIndex * width * 3;
+  const maxRaw = bridgeTools.bytesToInt(axlesPressureData.slice(base, base + width));
+  const minRaw = bridgeTools.bytesToInt(axlesPressureData.slice(base + width, base + width * 2));
+  const setRaw = bridgeTools.bytesToInt(axlesPressureData.slice(base + width * 2, base + width * 3));
+  if (maxRaw) {
+    tcVehicleAxle.maxTargetPressure = _.floor(bridgeTools.convertKpaByteToBar(deviceId, maxRaw), 1);
   }
-  if (axlesPressureData[axleIndex * 3 + 1]) {
-    tcVehicleAxle.minTargetPressure = _.ceil(
-      bridgeTools.convertKpaByteToBar(deviceId, axlesPressureData[axleIndex * 3 + 1]),
-      1
-    );
+  if (minRaw) {
+    tcVehicleAxle.minTargetPressure = _.ceil(bridgeTools.convertKpaByteToBar(deviceId, minRaw), 1);
   }
-  if (axlesPressureData[axleIndex * 3 + 2]) {
+  if (setRaw) {
     tcVehicleAxle.targetPressure = _.round(
-      bridgeTools.convertKpaByteToBar(deviceId, axlesPressureData[axleIndex * 3 + 2], void 0),
+      bridgeTools.convertKpaByteToBar(deviceId, setRaw, void 0),
       1
     );
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirecheck-device-sdk",
-  "version": "0.2.65",
+  "version": "0.2.67",
   "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",