tirecheck-device-sdk 0.2.70 → 0.2.72

package/dist/index.mjs

@@ -127,6 +127,19 @@ function normalizeError(error) {
   return error;
 }
 
+const emptyBluetoothClassicSerialImplementation = {
+  list: async () => [],
+  discoverUnpaired: async () => [],
+  setDeviceDiscoveredListener: () => {
+  },
+  clearDeviceDiscoveredListener: () => {
+  }
+};
+let bluetoothClassicSerial = emptyBluetoothClassicSerialImplementation;
+function setBluetoothClassicSerialImplementation(bluetoothClassicSerialImplementation) {
+  bluetoothClassicSerial = bluetoothClassicSerialImplementation ?? emptyBluetoothClassicSerialImplementation;
+}
+
 const tyreLabels = getDefaultTyreLabels();
 const bridgeTools = {
   getBridgeFromStore,
@@ -159,7 +172,7 @@ const bridgeTools = {
     );
     const result = [];
     for (const key of keys) {
-      if (!structurizedObj[key]) throw new Error(`Missing key ${key} in the structure`);
+      if (structurizedObj[key] == null) throw new Error(`Missing key ${key} in the structure`);
       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);
@@ -199,7 +212,8 @@ const bridgeTools = {
       return this.asciiToDecimalArray(_data);
     }
     if (displayUnits === "decimal") {
-      return this.hexToDecimalArray(decimalToHex(_data)).reverse();
+      const hex = decimalToHex(_data);
+      return this.hexToDecimalArray(hex.length % 2 ? `0${hex}` : hex).reverse();
     }
     if (displayUnits === "reverseHex") {
       const byteArray = _data.match(/.{1,2}/g) || [];
@@ -650,6 +664,17 @@ const deviceMeta = {
       };
       return bleDevice;
     }
+  },
+  unitechRfid: {
+    nameRegex: /^RP902/i,
+    transport: "serial",
+    getDeviceInfoFromAdvertising: (device) => {
+      const bleDevice = {
+        ...device,
+        type: "unitechRfid"
+      };
+      return bleDevice;
+    }
   }
 };
 
@@ -686,6 +711,8 @@ const bluetooth = {
     deviceStateChangeCallback = callback;
   },
   scanDevices,
+  scanSerialDevicesPaired,
+  scanSerialDevicesUnpaired,
   stopScan() {
     ble.stopScan();
   },
@@ -716,6 +743,47 @@ async function scanDevices(services = [], duration) {
     (e) => console.error("ble.startScanWithOptions error:", e)
   );
 }
+async function scanSerialDevicesPaired() {
+  try {
+    const pairedDevices = await bluetoothClassicSerial.list();
+    for (const device of pairedDevices ?? []) handleSerialDevice(device);
+  } catch (e) {
+    console.error("scanPairedSerialDevices error:", e);
+  }
+}
+async function scanSerialDevicesUnpaired() {
+  bluetoothClassicSerial.setDeviceDiscoveredListener?.((device) => handleSerialDevice(device));
+  try {
+    const unpairedDevices = await bluetoothClassicSerial.discoverUnpaired();
+    for (const device of unpairedDevices ?? []) handleSerialDevice(device);
+  } catch (e) {
+    const message = (typeof e === "string" ? e : e?.message ?? "").toLowerCase();
+    const pickerDismissed = store.platform === "ios" && ["cancel", "alreadyconnected", "already connected", "notfound", "not found"].some((m) => message.includes(m));
+    if (pickerDismissed) {
+      console.log("discoverSerialDevices: accessory picker returned no unpaired device -", message);
+    } else {
+      console.error("discoverSerialDevices error:", e);
+    }
+  } finally {
+    bluetoothClassicSerial.clearDeviceDiscoveredListener?.();
+  }
+}
+function handleSerialDevice(device) {
+  const rawId = device.id ?? device.address;
+  const id = rawId != null ? String(rawId) : void 0;
+  if (!id) {
+    console.warn("handleSerialDevice: skipped, no id/address", device);
+    return;
+  }
+  const peripheral = { id, name: device.name, rssi: device.rssi ?? 0, advertising: {} };
+  const processedDevice = processDevice(peripheral);
+  if (!processedDevice) {
+    console.warn("handleSerialDevice: processDevice returned null (filtered out)", id, device.name);
+    return;
+  }
+  store.devices[processedDevice.id] = processedDevice;
+  deviceAdvertisingCallback?.(processedDevice);
+}
 async function connect$1(deviceId, disconnectCallback) {
   if (toolsSvc.canCommunicateWith(deviceId)) return console.warn("Connect Warn: Already connected to device");
   store.setState(deviceId, "connecting");
@@ -804,7 +872,8 @@ function processDevice(device) {
     console.warn("Error processing advertising", e);
     return;
   }
-  unreachableSvc.refresh(processedDevice.id, deviceUnreachableCallback);
+  const isSerial = deviceMeta[deviceType].transport === "serial";
+  if (!isSerial) unreachableSvc.refresh(processedDevice.id, deviceUnreachableCallback);
   return processedDevice;
 }
 function getDeviceTypeFromName(name) {
@@ -1777,6 +1846,109 @@ const bridgeCommandStructures = {
         description: "Bluetooth chip FW version: major.minor.patch + release type (e.g. 1.2.0 Release)"
       }
     }
+  },
+  bridgeConfiguration: {
+    id: [98, 1],
+    name: "bridgeConfiguration",
+    structure: {
+      configVersion: {
+        size: 4,
+        description: "Application configuration version details",
+        display: "decimal"
+      },
+      bleTxPower: {
+        size: 2,
+        description: "Used BLE Tx power (16 bit signed value; LSB = 0.1)",
+        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)"
+      },
+      wrongPinsUntilLockout: {
+        size: 1,
+        description: "Minimal number of wrong pins allowed before the lockout activates",
+        display: "decimal"
+      },
+      maxLockoutPeriodIncreases: {
+        size: 1,
+        description: "How many times the lockout period may be doubled",
+        display: "decimal"
+      },
+      wrongPinInitialLockoutTime: {
+        size: 1,
+        description: "Initial lockout time duration after too many wrong PINs",
+        display: "decimal"
+      },
+      securityConfiguration: {
+        size: 1,
+        description: "Bluetooth security configuration (0x03 - legacy pairing enabled; 0x07 - disabled)"
+      },
+      canEnabled: {
+        size: 1,
+        description: "CAN enabled state",
+        display: "decimal"
+      },
+      bleEnabled: {
+        size: 1,
+        description: "BLE Advertisement enabled state",
+        display: "decimal"
+      },
+      canBitrate: {
+        size: 2,
+        description: "CAN Bitrate [kbps]",
+        display: "decimal"
+      },
+      movementDetectionLimit: {
+        size: 2,
+        description: "Movement detection limit [1/256 kmph per bit]",
+        display: "decimal"
+      },
+      sensorInactivityTimeout: {
+        size: 2,
+        description: "Timeout [s] after which an inactive sensor is marked erroneous (max. 512 s)",
+        display: "decimal"
+      },
+      manufacturerCode: {
+        size: 4,
+        description: "Manufacturer Code as per SAE J1939",
+        display: "decimal"
+      },
+      identityNumber: {
+        size: 4,
+        description: "Identity number for ECU (max. 22 bits = 0x1FFFFF)",
+        display: "decimal"
+      },
+      manufacturerName: {
+        size: 20,
+        description: "Manufacturer Name (SPN 4304, max. 20 bytes)",
+        display: "ascii"
+      },
+      ecuPartNumber: {
+        size: 20,
+        description: "ECU Part Number (SPN 2901, max. 20 bytes)",
+        display: "ascii"
+      },
+      softwareVersion: {
+        size: 20,
+        description: "Software Version (SPN 234, max. 20 bytes)",
+        display: "ascii"
+      },
+      reservedConfiguration: {
+        size: 4,
+        description: "Reserved configuration",
+        display: "decimal"
+      }
+    }
   }
 };
 
@@ -1875,6 +2047,18 @@ const bridgeSecurity = {
     }
     return crc >>> 0;
   },
+  /** CRC-16/CCITT-FALSE (poly 0x1021, init 0xFFFF). Used for the RxSWIN (0xF18F) E010/E141 checksums. */
+  crc16Ccitt(msg) {
+    let crc = 65535;
+    const polynomial = 4129;
+    for (const byte of msg) {
+      crc ^= (byte & 255) << 8;
+      for (let j = 0; j < 8; j++) {
+        crc = crc & 32768 ? (crc << 1 ^ polynomial) & 65535 : crc << 1 & 65535;
+      }
+    }
+    return crc & 65535;
+  },
   getCrcArray(msg) {
     const crc = this.crc32mpeg2(msg);
     const crcHex = decimalToHex(crc).padStart(8, "0");
@@ -2280,6 +2464,21 @@ const bridgeCommands = {
       deviceData.advertisingData.fwVersion
     );
   },
+  async getBridgeConfiguration(deviceId) {
+    const deviceData = bridgeTools.getBridgeFromStore(deviceId);
+    const result = await this.readCommand(deviceData, subCommandIds.bridgeConfiguration);
+    const structurized = bridgeTools.convertBytesToStructure(
+      bridgeCommandStructures.bridgeConfiguration.structure,
+      result.data,
+      deviceData.advertisingData.fwVersion
+    );
+    console.log(
+      `[getBridgeConfiguration] raw payload (${result.data.length}B):`,
+      result.data.map((b) => decimalToHex(b)).join(" ")
+    );
+    console.log("[getBridgeConfiguration] decoded structure:", structurized, `(isFactory: ${result.isFactory})`);
+    return { ...structurized, isFactory: result.isFactory };
+  },
   async getErrorHistoryCounter(deviceId) {
     const deviceData = bridgeTools.getBridgeFromStore(deviceId);
     const result = await this.readCommand(deviceData, subCommandIds.errorHistoryCounter, {
@@ -2391,6 +2590,7 @@ const bridgeService = {
   setVehicle,
   getConfiguration,
   setConfiguration,
+  getRxSWIN,
   getSensorReading,
   getVehicleReadings,
   resetAutolearnStatuses,
@@ -2462,7 +2662,7 @@ async function setVehicleLayout(deviceId, tcVehicle) {
   }
   await bridgeCommands.setVehicleLayout(deviceId, result);
 }
-async function getConfiguration(deviceId, includeVehicleData = false) {
+async function getConfiguration(deviceId) {
   const customerCANSettings = await bridgeCommands.getCustomerCANSettings(deviceId);
   const workshopCANSettings = await bridgeCommands.getWorkshopCANSettings(deviceId);
   const customerPressureThresholds = await bridgeCommands.getCustomerPressureThresholds(deviceId);
@@ -2470,16 +2670,23 @@ async function getConfiguration(deviceId, includeVehicleData = false) {
   const customerImbalanceThresholds = await bridgeCommands.getCustomerImbalanceThresholds(deviceId);
   const pressuresPerAxle = await bridgeCommands.getPressuresPerAxle(deviceId);
   let autolearnSettings;
+  let autolearnIdStatus;
+  let autolearnUnknownSensors;
   let errorHistoryCounter;
   let eolStatus;
+  let firmwareVersion;
   if (bridgeTools.isVersionGreaterThan(deviceId, "0.9.7")) {
     autolearnSettings = await bridgeCommands.getAutolearnSettings(deviceId);
+    autolearnIdStatus = await bridgeCommands.getAutolearnIdStatus(deviceId);
+    autolearnUnknownSensors = await bridgeCommands.getAutolearnUnknownSensors(deviceId);
   }
   if (bridgeTools.isVersionGreaterThan(deviceId, "1.1.F")) {
     errorHistoryCounter = await bridgeCommands.getErrorHistoryCounter(deviceId);
     eolStatus = await bridgeCommands.getEolStatus(deviceId);
+    firmwareVersion = await bridgeCommands.getFirmwareVersion(deviceId);
   }
-  const configuration = {
+  const rxswin = await getRxSWIN(deviceId, { customerPressureThresholds, customerCANSettings });
+  return {
     customerCANSettings,
     workshopCANSettings,
     customerPressureThresholds,
@@ -2487,27 +2694,75 @@ async function getConfiguration(deviceId, includeVehicleData = false) {
     customerImbalanceThresholds,
     pressuresPerAxle,
     autolearnSettings,
+    autolearnIdStatus,
+    autolearnUnknownSensors,
     errorHistoryCounter,
-    eolStatus
+    eolStatus,
+    firmwareVersion,
+    rxswin
   };
-  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;
+}
+async function getRxSWIN(deviceId, configuration) {
+  if (!canCommunicateWith(deviceId)) throw new Error("Bridge not connected");
+  const bridgeConfiguration = bridgeTools.isVersionGreaterThan(deviceId, "1.1.F") ? await bridgeCommands.getBridgeConfiguration(deviceId) : {
+    canEnabled: 1,
+    movementDetectionLimit: 1280,
+    // Firmware default provided as 0x01FA for pre-1.2.0 bridges where record 0x01 is unavailable.
+    sensorInactivityTimeout: 506,
+    bleTxPower: 60,
+    bleTxChannels: "07"
+  };
+  const customerPressureThresholds = configuration?.customerPressureThresholds ?? await bridgeCommands.getCustomerPressureThresholds(deviceId);
+  const customerCANSettings = configuration?.customerCANSettings ?? await bridgeCommands.getCustomerCANSettings(deviceId);
+  const fwVersion = bridgeTools.getBridgeFromStore(deviceId).advertisingData.fwVersion;
+  const bleTxChannels = bridgeTools.hexToDecimalArray(bridgeConfiguration.bleTxChannels ?? "").reverse();
+  const axle01PressureThresholds = bridgeTools.hexToDecimalArray(customerPressureThresholds.axle01 ?? "");
+  const canProtocol = bridgeTools.hexToDecimalArray(customerCANSettings.canProtocol ?? "").reverse();
+  const transparentFilteredMode = bridgeTools.hexToDecimalArray(customerCANSettings.transparentFilteredMode ?? "").reverse();
+  const fwMajor = (fwVersion || "0").split(".")[0].charCodeAt(0) & 255;
+  const bleTxPower = bridgeTools.intToBytes(bridgeConfiguration.bleTxPower ?? 0, 2);
+  const canEnabled = bridgeTools.intToBytes(bridgeConfiguration.canEnabled ?? 0, 1);
+  const movementDetectionLimit = bridgeTools.intToBytes(bridgeConfiguration.movementDetectionLimit ?? 0, 2);
+  const sensorInactivityTimeout = bridgeTools.intToBytes(bridgeConfiguration.sensorInactivityTimeout ?? 0, 2);
+  const e010Input = [bleTxPower[0] ?? 0, bleTxPower[1] ?? 0, bleTxChannels[0] ?? 0];
+  const e141Input = [
+    canEnabled[0] ?? 0,
+    movementDetectionLimit[0] ?? 0,
+    movementDetectionLimit[1] ?? 0,
+    sensorInactivityTimeout[0] ?? 0,
+    sensorInactivityTimeout[1] ?? 0,
+    axle01PressureThresholds[0] ?? 0,
+    canProtocol[0] ?? 0,
+    transparentFilteredMode[0] ?? 0,
+    fwMajor
+  ];
+  console.log(`[getRxSWIN] e010: ${e010Input}`);
+  console.log(`[getRxSWIN] e141: ${e141Input}`);
+  const result = {
+    R10SWIN: decimalToHex(bridgeSecurity.crc16Ccitt(e010Input), 4),
+    R141SWIN: decimalToHex(bridgeSecurity.crc16Ccitt(e141Input), 4)
+  };
+  const item1Content = [
+    ...bridgeTools.asciiToDecimalArray("R010"),
+    32,
+    ...bridgeTools.asciiToDecimalArray(result.R10SWIN)
+  ];
+  const item2Content = [
+    ...bridgeTools.asciiToDecimalArray("R141"),
+    32,
+    ...bridgeTools.asciiToDecimalArray(result.R141SWIN)
+  ];
+  const item1 = [item1Content.length, ...item1Content];
+  const item2 = [item2Content.length, ...item2Content];
+  const payload = [...item1, ...item2];
+  console.log(
+    `[getRxSWIN] R010 item: "${String.fromCharCode(...item1.slice(1))}" (${item1.map((b) => decimalToHex(b)).join(" ")})`
+  );
+  console.log(
+    `[getRxSWIN] R141 item: "${String.fromCharCode(...item2.slice(1))}" (${item2.map((b) => decimalToHex(b)).join(" ")})`
+  );
+  console.log(`[getRxSWIN] final payload (${payload.length}B): ${payload.map((b) => decimalToHex(b)).join(" ")}`);
+  return result;
 }
 function bridgeVehiclesDifference(original, change) {
   const differences = [];
@@ -3086,6 +3341,7 @@ const bridge = {
   setVehicle: bridgeService.setVehicle,
   getConfiguration: bridgeService.getConfiguration,
   setConfiguration: bridgeService.setConfiguration,
+  getRxSWIN: bridgeService.getRxSWIN,
   getSensorReading: bridgeService.getSensorReading,
   getVehicleReadings: bridgeService.getVehicleReadings,
   getAutolearnStatuses: bridgeService.getAutolearnStatuses,
@@ -4153,6 +4409,95 @@ const torqueWrench = {
   onReading: torqueWrenchService.onReading
 };
 
+let unitech;
+function setUnitechRfidImplementation(unitechRfidImplementation) {
+  if (!unitechRfidImplementation)
+    return console.warn("Unitech RFID implementation is not provided, Unitech RFID functionality will not work");
+  unitech = unitechRfidImplementation;
+}
+
+const unitechRfidService = {
+  subscribeListeners(deviceId) {
+    unitech.addListener("readerState", (event) => {
+      simulatorSvc.triggerEvent("unitech:readerState", deviceId, event);
+      simulatorSvc.triggerEvent("unitech:readerStateConnect", deviceId, event);
+    });
+    unitech.addListener("actionState", (event) => simulatorSvc.triggerEvent("unitech:actionState", deviceId, event));
+    unitech.addListener("trigger", (event) => simulatorSvc.triggerEvent("unitech:trigger", deviceId, event));
+    unitech.addListener("tagRead", (event) => simulatorSvc.triggerEvent("unitech:tag", deviceId, event));
+    unitech.addListener("battery", (event) => simulatorSvc.triggerEvent("unitech:battery", deviceId, event));
+    unitech.addListener("temperature", (event) => simulatorSvc.triggerEvent("unitech:temperature", deviceId, event));
+  },
+  onReaderState(callback) {
+    simulatorSvc.registerEvent("unitech:readerState", callback);
+  },
+  onActionState(callback) {
+    simulatorSvc.registerEvent("unitech:actionState", callback);
+  },
+  onTrigger(callback) {
+    simulatorSvc.registerEvent("unitech:trigger", callback);
+  },
+  onTagRead(callback) {
+    simulatorSvc.registerEvent("unitech:tag", callback);
+  },
+  onBattery(callback) {
+    simulatorSvc.registerEvent("unitech:battery", callback);
+  },
+  onTemperature(callback) {
+    simulatorSvc.registerEvent("unitech:temperature", callback);
+  }
+};
+
+const unitechRfid = {
+  async connect(deviceId) {
+    const unitechDevices = Object.values(store.devices).filter((d) => d.type === "unitechRfid");
+    for (const device2 of unitechDevices) {
+      if (device2.id !== deviceId && store.deviceState[device2.id] === "paired") {
+        await this.disconnect(device2.id, "manualDisconnection");
+      }
+    }
+    store.setState(deviceId, "connecting");
+    await unitech.removeAllListeners();
+    const device = store.devices[deviceId];
+    if (store.platform === "ios") {
+      await unitech.startDetect({ deviceName: device.name });
+      await toolsSvc.delay(500);
+      await unitech.stopDetect();
+    }
+    const { connected } = await unitech.connect({ bluetoothAddress: device.id });
+    if (!connected) throw new Error("UnitechRfid Error: Unable to connect to the device.");
+    await unitechRfidService.subscribeListeners(deviceId);
+    await withTimeout(
+      new Promise((resolve) => {
+        simulatorSvc.registerEvent("unitech:readerStateConnect", (_deviceId, event) => {
+          if (event.state?.toLowerCase() === "connected") resolve();
+        });
+      }),
+      15e3
+    );
+    await unitech.initDeviceSettings();
+    store.setState(deviceId, "paired");
+  },
+  async disconnect(deviceId, reason) {
+    store.setState(deviceId, "disconnecting");
+    await unitech.removeAllListeners();
+    await unitech.disconnect();
+    store.setState(deviceId, void 0, reason ?? "manualDisconnection");
+  },
+  async startReading() {
+    await unitech.startInventory();
+  },
+  async stopReading() {
+    await unitech.stopInventory();
+  },
+  onReaderState: unitechRfidService.onReaderState,
+  onActionState: unitechRfidService.onActionState,
+  onTrigger: unitechRfidService.onTrigger,
+  onTagRead: unitechRfidService.onTagRead,
+  onBattery: unitechRfidService.onBattery,
+  onTemperature: unitechRfidService.onTemperature
+};
+
 const bridgeSimulator = {
   isRebootRequired(deviceId) {
     return store.bridgeRebootRequired[deviceId];
@@ -4190,6 +4535,32 @@ const bridgeSimulator = {
     const bridge = getSimulatedBridge(deviceId);
     bridge.simulatorData.configuration = _.cloneDeep(config);
   },
+  async getRxSWIN(deviceId) {
+    const bridge = getSimulatedBridge(deviceId);
+    const config = bridge.simulatorData.configuration;
+    const axle01PressureThresholds = bridgeTools.hexToDecimalArray(config.customerPressureThresholds?.axle01 ?? "");
+    const canProtocol = bridgeTools.hexToDecimalArray(config.customerCANSettings?.canProtocol ?? "");
+    const transparentFilteredMode = bridgeTools.hexToDecimalArray(
+      config.customerCANSettings?.transparentFilteredMode ?? ""
+    );
+    const fwMajor = (bridge.advertisingData.fwVersion || "0").split(".")[0].charCodeAt(0) & 255;
+    const e010Input = [0, 0, 0];
+    const e141Input = [
+      0,
+      0,
+      0,
+      0,
+      0,
+      axle01PressureThresholds[0] ?? 0,
+      canProtocol[0] ?? 0,
+      transparentFilteredMode[0] ?? 0,
+      fwMajor
+    ];
+    return {
+      R10SWIN: decimalToHex(bridgeSecurity.crc16Ccitt(e010Input), 4),
+      R141SWIN: decimalToHex(bridgeSecurity.crc16Ccitt(e141Input), 4)
+    };
+  },
   async getSensorReading(deviceId, positionId) {
     const bridge = getSimulatedBridge(deviceId);
     return bridge.simulatorData.sensors[positionId];
@@ -4794,11 +5165,13 @@ class BridgeTcVehicleAxle {
   minTargetPressure;
 }
 
-function createTirecheckDeviceSdk(platform, bleImplementation, securityKeys) {
+function createTirecheckDeviceSdk(platform, bleImplementation, securityKeys, unitechRfidImplementation, bluetoothClassicSerialImplementation) {
   store.platform = platform;
   bleImplementation = bleImplementation || emptyBleImplementation;
   store.securityKeys = securityKeys || {};
   setBleImplementation(bleImplementation);
+  setUnitechRfidImplementation(unitechRfidImplementation);
+  setBluetoothClassicSerialImplementation(bluetoothClassicSerialImplementation);
   return {
     /** Generic methods common for all devices */
     bluetooth,
@@ -4816,6 +5189,8 @@ function createTirecheckDeviceSdk(platform, bleImplementation, securityKeys) {
     simulator,
     /** Methods for working with Tirecheck Torque Wrench */
     torqueWrench,
+    /** Methods for working with Unitech RFID reader */
+    unitechRfid,
     utils: {
       bridge: {
         convertBarToKpaByte: bridgeTools.convertBarToKpaByte,

package/package.json

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