@robdobsn/raftjs 1.3.1 → 1.5.0

package/examples/dashboard/src/SystemTypeGeneric/SystemTypeGeneric.ts

@@ -0,0 +1,87 @@
+import { RaftSubscribeForUpdatesCBType, RaftSystemType } from "../../../../src/RaftSystemType";
+import { RaftEventFn, RaftLog, RaftOKFail, RaftPublishEvent, RaftPublishEventNames, RaftSystemUtils } from "../../../../src/main";
+import { StateInfoGeneric } from "./StateInfoGeneric";
+import { DeviceManager } from "../../../../src/RaftDeviceManager";
+
+export default class SystemTypeGeneric implements RaftSystemType {
+    nameForDialogs = "Generic System";
+    defaultWiFiHostname = "Generic";
+    firmwareDestName = "ricfw";
+    normalFileDestName = "fs";
+    connectorOptions = {wsSuffix: "wsjson", bleConnItvlMs: 50};
+    BLEServiceUUIDs = ["aa76677e-9cfd-4626-a510-0d305be57c8d", "da903f65-d5c2-4f4d-a065-d1aade7af874"];
+    BLECmdUUID = "aa76677e-9cfd-4626-a510-0d305be57c8e";
+    BLERespUUID = "aa76677e-9cfd-4626-a510-0d305be57c8f";
+
+    // Event handler
+    private _onEvent: RaftEventFn | null = null;
+
+    // Raft system utils
+    private _systemUtils: RaftSystemUtils | null = null;
+
+    // Device manager
+    private _deviceManager: DeviceManager = new DeviceManager();
+    
+    // Setup
+    setup(systemUtils: RaftSystemUtils, onEvent: RaftEventFn | null): void {
+      this._systemUtils = systemUtils;
+      this._onEvent = onEvent;
+      this._deviceManager.setup(systemUtils);
+    }
+
+    // Latest data from servos, IMU, etc
+    private _stateInfo: StateInfoGeneric = new StateInfoGeneric(this._deviceManager);
+    getStateInfo(): StateInfoGeneric {
+      return this._stateInfo;
+    }
+
+    // Subscribe for updates
+    subscribeForUpdates: RaftSubscribeForUpdatesCBType | null = async (systemUtils: RaftSystemUtils, enable: boolean) => {
+      // Subscription rate
+      const subscribeRateHz = 0.1;
+      try {
+        const subscribeDisable = '{"cmdName":"subscription","action":"update",' +
+          '"pubRecs":[' +
+          `{"name":"devjson","rateHz":0,}` +
+          ']}';
+        const subscribeEnable = '{"cmdName":"subscription","action":"update",' +
+          '"pubRecs":[' +
+          `{"name":"devjson","trigger":"timeorchange","rateHz":${subscribeRateHz.toString()}}` +
+          ']}';
+
+        const msgHandler = systemUtils.getMsgHandler();
+        const ricResp = await msgHandler.sendRICRESTCmdFrame<RaftOKFail>(
+          enable ? subscribeEnable : subscribeDisable
+        );
+
+        // Debug
+        RaftLog.debug(`subscribe enable/disable returned ${JSON.stringify(ricResp)}`);
+      } catch (error: unknown) {
+        RaftLog.warn(`getRICCalibInfo Failed subscribe for updates ${error}`);
+      }
+    };
+
+    // Invalidate state
+    stateIsInvalid(): void {};
+
+    // Other message type
+    rxOtherMsgType(payload: Uint8Array, frameTimeMs: number) {
+
+      // RICLog.debug(`rxOtherMsgType payload ${RICUtils.bufferToHex(payload)}`);
+      RaftLog.verbose(`rxOtherMsgType payloadLen ${payload.length}`);
+      const topicIDs = this._stateInfo.updateFromMsg(payload, frameTimeMs);
+
+      // Call event handler if registered
+      if (this._onEvent) {
+        this._onEvent("pub", RaftPublishEvent.PUBLISH_EVENT_DATA, RaftPublishEventNames[RaftPublishEvent.PUBLISH_EVENT_DATA],
+          {
+            topicIDs: topicIDs,
+            payload: payload,
+            frameTimeMs: frameTimeMs
+          });
+      }
+    };
+
+    // Get device manager
+    deviceMgrIF = this._deviceManager;
+  }

package/examples/dashboard/src/SystemTypeMarty/SystemTypeMarty.ts

@@ -12,6 +12,9 @@ export default class SystemTypeMarty implements RaftSystemType {
   firmwareDestName = "ricfw";
   normalFileDestName = "fs";
   connectorOptions = {wsSuffix: "ws", bleConnItvlMs: 7.5};
+  BLEServiceUUIDs = ["aa76677e-9cfd-4626-a510-0d305be57c8d"];
+  BLECmdUUID = "aa76677e-9cfd-4626-a510-0d305be57c8e";
+  BLERespUUID = "aa76677e-9cfd-4626-a510-0d305be57c8f";
 
   // LED Pattern checker
   private _ledPatternChecker: RICLEDPatternChecker = new RICLEDPatternChecker();

package/examples/dashboard/src/index.tsx

@@ -2,8 +2,6 @@ import React from 'react';
 import { createRoot } from 'react-dom/client';
 import Main from './Main';
 import './styles.css';
-import 'process';
-import 'buffer';
 
 // Find the root element
 const rootElement = document.getElementById('root');

package/examples/dashboard/src/styles.css

@@ -68,7 +68,13 @@ h1 {
 }
 
 .action-button {
-    margin-left: 10px;
+    color: #fff;
+    cursor: pointer;
+    background-color: #007bff;
+    border: none;
+    border-radius: 4px;
+    padding: 10px 20px;
+    font-size: 1rem;
 }
 
 .info-boxes {
@@ -98,8 +104,11 @@ h1 {
 }
 
 .ip-addr-input {
-    width: 100%;
+    border: 1px solid #ccc;
+    border-radius: 4px;
     margin-bottom: 10px;
+    padding: 10px;
+    width: 100%;
 }
 
 .command-input {
@@ -116,6 +125,7 @@ h1 {
     background-color: #007bff;
     color: white;
     cursor: pointer;
+    font-size: 1rem;
 }
 
 .send-command-button:hover {
@@ -203,6 +213,7 @@ h1 {
     color: #fff;
     cursor: pointer;
     margin-left: 10px;
+    font-size: 1rem;
 }
 
 .example-load-button:hover {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robdobsn/raftjs",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "Javascript/TS library for Raft library",
   "main": "dist/web/main.js",
   "types": "dist/web/main.d.ts",
@@ -25,31 +25,22 @@
     "build": "tsc -p tsconfig.json",
     "build:phone": "tsc -p tsconfig.react-native.json",
     "build-all": "npm run clean && npm run build && npm run build:phone",
-    "test": "jest",
     "lint": "eslint ./src",
     "clean": "rm -rf dist build package",
     "docs": "typedoc --entryPoints src/main.ts",
     "watch-all": "tsc -p tsconfig.json --watch & tsc -p tsconfig.react-native.json --watch"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.12",
     "@types/node": "^20.14.0",
-    "@types/python-struct": "^1.0.4",
-    "@types/semver": "^7.5.8",
     "@types/web-bluetooth": "^0.0.20",
     "@typescript-eslint/eslint-plugin": "^8.6.0",
     "eslint": "^9.4.0",
-    "jest": "^29.7.0",
-    "react-native-ble-plx": "^3.2.1",
-    "ts-jest": "^29.1.4",
+    "react-native-ble-plx": "^3.2.0",
     "typescript": "^5.4.5"
   },
   "dependencies": {
     "@types/text-encoding": "^0.0.39",
-    "axios": "^1.7.2",
     "isomorphic-ws": "^5.0.0",
-    "python-struct": "^1.1.3",
-    "semver": "^7.6.2",
     "text-encoding": "^0.7.0",
     "tslib": "^2.6.2"
   },

package/src/RaftAttributeHandler.ts

@@ -10,7 +10,7 @@
 import CustomAttrHandler from "./RaftCustomAttrHandler";
 import { DeviceTypeAttribute, DeviceTypePollRespMetadata, decodeAttrUnitsEncoding, isAttrTypeSigned } from "./RaftDeviceInfo";
 import { DeviceAttributesState, DeviceTimeline } from "./RaftDeviceStates";
-import struct from 'python-struct';
+import { structSizeOf, structUnpack } from "./RaftStruct";
 
 export default class AttributeHandler {
 
@@ -22,17 +22,17 @@ export default class AttributeHandler {
     private POLL_RESULT_WRAP_VALUE = this.POLL_RESULT_TIMESTAMP_SIZE === 2 ? 65536 : 4294967296;
     private POLL_RESULT_RESOLUTION_US = 1000;
     
-    public processMsgAttrGroup(msgBuffer: Buffer, msgBufIdx: number, deviceTimeline: DeviceTimeline, pollRespMetadata: DeviceTypePollRespMetadata, 
+    public processMsgAttrGroup(msgBuffer: Uint8Array, msgBufIdx: number, deviceTimeline: DeviceTimeline, pollRespMetadata: DeviceTypePollRespMetadata, 
                         devAttrsState: DeviceAttributesState, maxDataPoints: number): number {
         
         // console.log(`processMsgAttrGroup msg ${msgHexStr} timestamp ${timestamp} origTimestamp ${origTimestamp} msgBufIdx ${msgBufIdx}`)
 
         // Extract msg timestamp
-        let { newBufIdx, timestampUs } = this.extractTimestampAndAdvanceIdx(msgBuffer, msgBufIdx, deviceTimeline);
+        const { newBufIdx, timestampUs } = this.extractTimestampAndAdvanceIdx(msgBuffer, msgBufIdx, deviceTimeline);
         if (newBufIdx < 0)
             return -1;
         msgBufIdx = newBufIdx;
-        
+
         // Start of message data
         const msgDataStartIdx = msgBufIdx;
 
@@ -69,7 +69,10 @@ export default class AttributeHandler {
         }
         
         // Number of bytes in group
-        const pollRespSizeBytes = pollRespMetadata.b;
+        let pollRespSizeBytes = msgBufIdx - msgDataStartIdx;
+        if (pollRespSizeBytes < pollRespMetadata.b) {
+            pollRespSizeBytes = pollRespMetadata.b;
+        }
 
         // Check if any attributes were added (in addition to timestamp)
         if (newAttrValues.length === 0) {
@@ -78,7 +81,7 @@ export default class AttributeHandler {
         }
 
         // All attributes must have the same number of new values
-        let numNewDataPoints = newAttrValues[0].length;
+        const numNewDataPoints = newAttrValues[0].length;
         for (let i = 1; i < newAttrValues.length; i++) {
             if (newAttrValues[i].length !== numNewDataPoints) {
                 console.warn(`DeviceManager msg attrGroup ${pollRespMetadata} attrName ${pollRespMetadata.a[i].n} newAttrValues ${newAttrValues} do not have the same length`);
@@ -123,7 +126,7 @@ export default class AttributeHandler {
 
         // Handle the timestamps with increments if specified
         const timeIncUs: number = pollRespMetadata.us ? pollRespMetadata.us : 1000;
-        let timestampsUs = Array(numNewDataPoints).fill(0);
+        const timestampsUs = Array(numNewDataPoints).fill(0);
         for (let i = 0; i < numNewDataPoints; i++) {
             timestampsUs[i] =  timestampUs + i * timeIncUs;
         }
@@ -141,7 +144,7 @@ export default class AttributeHandler {
         return msgDataStartIdx+pollRespSizeBytes;
     }
 
-    private processMsgAttribute(attrDef: DeviceTypeAttribute, msgBuffer: Buffer, msgBufIdx: number, msgDataStartIdx: number): { values: number[], newMsgBufIdx: number} {
+    private processMsgAttribute(attrDef: DeviceTypeAttribute, msgBuffer: Uint8Array, msgBufIdx: number, msgDataStartIdx: number): { values: number[], newMsgBufIdx: number} {
 
         // Current field message string index
         let curFieldBufIdx = msgBufIdx;
@@ -169,11 +172,11 @@ export default class AttributeHandler {
         const maskOnSignedValue = "m" in attrDef && isAttrTypeSigned(attrTypesOnly);
 
         // Extract the value using python-struct
-        let unpackValues = struct.unpack(maskOnSignedValue ? attrTypesOnly.toUpperCase() : attrTypesOnly, attrBuf);
+        const unpackValues = structUnpack(maskOnSignedValue ? attrTypesOnly.toUpperCase() : attrTypesOnly, attrBuf);
         let attrValues = unpackValues as number[];
 
         // Get number of bytes consumed
-        const numBytesConsumed = struct.sizeOf(attrTypesOnly);
+        const numBytesConsumed = structSizeOf(attrTypesOnly);
 
         // // Check if sign extendable mask specified on signed value
         // if (mmSpecifiedOnSignedValue) {
@@ -252,7 +255,7 @@ export default class AttributeHandler {
         return value;
     }
 
-    private extractTimestampAndAdvanceIdx(msgBuffer: Buffer, msgBufIdx: number, timestampWrapHandler: DeviceTimeline): 
+    private extractTimestampAndAdvanceIdx(msgBuffer: Uint8Array, msgBufIdx: number, timestampWrapHandler: DeviceTimeline): 
                     { newBufIdx: number, timestampUs: number } {
 
         // Check there are enough characters for the timestamp
@@ -264,9 +267,9 @@ export default class AttributeHandler {
         const tsBuffer = msgBuffer.slice(msgBufIdx, msgBufIdx + this.POLL_RESULT_TIMESTAMP_SIZE);
         let timestampUs: number;
         if (this.POLL_RESULT_TIMESTAMP_SIZE === 2) { 
-            timestampUs = struct.unpack(">H", tsBuffer)[0] as number * this.POLL_RESULT_RESOLUTION_US;
+            timestampUs = structUnpack(">H", tsBuffer)[0] as number * this.POLL_RESULT_RESOLUTION_US;
         } else {
-            timestampUs = struct.unpack(">I", tsBuffer)[0] as number * this.POLL_RESULT_RESOLUTION_US;
+            timestampUs = structUnpack(">I", tsBuffer)[0] as number * this.POLL_RESULT_RESOLUTION_US;
         }
 
         // Check if time is before lastReportTimeMs - in which case a wrap around occurred to add on the max value

package/src/RaftChannelBLE.native.ts

@@ -14,28 +14,26 @@ import { RaftConnEvent, RaftConnEventFn } from "./RaftConnEvents";
 import RaftLog from "./RaftLog";
 import RaftMsgHandler from "./RaftMsgHandler";
 import RaftUtils from "./RaftUtils";
-import RICBLEScanner from "./RaftChannelBLEScanner.native";
-import { DiscoveredRIC } from "./RaftTypes";
+import RaftChannelBLEScanner from "./RaftChannelBLEScanner.native";
+import { DiscoveredDevice } from "./RaftTypes";
 
 const _bleManager = new BleManager();
 
 export default class RaftChannelPhoneBLE implements RaftChannel {
-  // BLE UUIDS
-  public static ServiceUUID = "aa76677e-9cfd-4626-a510-0d305be57c8d";
-  public static CmdUUID = "aa76677e-9cfd-4626-a510-0d305be57c8e";
-  public static RespUUID = "aa76677e-9cfd-4626-a510-0d305be57c8f";
-
-  // BleManager
-
 
   // Conn event fn
   private _onConnEvent: RaftConnEventFn | null = null;
 
+  // Default command and response UUIDs
+  _cmdUUID = 'aa76677e-9cfd-4626-a510-0d305be57c8e';
+  _respUUID = 'aa76677e-9cfd-4626-a510-0d305be57c8f';
+  _serviceUUIDs = ['aa76677e-9cfd-4626-a510-0d305be57c8d', 'da903f65-d5c2-4f4d-a065-d1aade7af874'];
+
   // BLE Scanner
-  _bleScanner: RICBLEScanner;
+  _bleScanner: RaftChannelBLEScanner;
 
-  // RIC to connect to using BLE
-  _ricToConnectTo: DiscoveredRIC | null = null;
+  // Device to connect to using BLE
+  _deviceToConnectTo: DiscoveredDevice | null = null;
 
   // Handle BLE disconnection through retry
   // May be set after connection checking (e.g. using LEDs)
@@ -48,11 +46,6 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
   _bleSubscrOnStateChange: Subscription | null = null;
   _bleDevice: Device | null = null;
 
-  // BLE UUIDS
-  _RICServiceUUID = 'aa76677e-9cfd-4626-a510-0d305be57c8d';
-  _RICCmdUUID = 'aa76677e-9cfd-4626-a510-0d305be57c8e';
-  _RICRespUUID = 'aa76677e-9cfd-4626-a510-0d305be57c8f';
-
   // MTU (Maximum Transmission Unit) size to request
   MTU_SIZE_TO_REQUEST = 512;
 
@@ -64,10 +57,6 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
   private _msgTxMinTimeBetweenMs = 1;
   private readonly maxRetries = 1;
 
-  // Connected flag and retries
-  private _isConnected = false;
-  // private readonly _maxConnRetries = 3;
-
   // File Handler parameters
   private _requestedBatchAckSize = 10;
   private _requestedFileBlockSize = 500;
@@ -78,9 +67,9 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     // _bleManager.setLogLevel(LogLevel.Verbose);
 
     // Scanner
-    this._bleScanner = new RICBLEScanner(
+    this._bleScanner = new RaftChannelBLEScanner(
       _bleManager,
-      [this._RICServiceUUID],
+      this._serviceUUIDs,
       this.scanningEvent.bind(this),
     );
 
@@ -102,7 +91,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
 
   // isConnected
   isConnected(): boolean {
-    return this._bleDevice !== null && this._isConnected;
+    return this._bleDevice !== null;
   }
 
   setOnConnEvent(connEventFn: RaftConnEventFn): void {
@@ -127,12 +116,12 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     this._retryConnectionIfLost = retry;
   }
 
-  async discoveryStart(): Promise<boolean> {
+  async discoveryStart(uuids: string[]): Promise<boolean> {
     // Disconnect any existing connection
     // await this.disconnect();
 
     // Start scanning
-    await this._bleScanner.scanningStart();
+    await this._bleScanner.scanningStart(uuids);
 
     // Event
     RaftLog.debug(`BLEChannel discoveryStart emitting BLE_SCANNING_STARTED`);
@@ -203,16 +192,16 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
    * @returns boolean (true if connected)
    *
    */
-  async connect(discoveredRIC: DiscoveredRIC): Promise<boolean> {
+  async connect(discoveredDevice: DiscoveredDevice): Promise<boolean> {
     RaftLog.debug('BLEChannel requested connection');
     this._retryConnectionIfLost = false;
     this._bleScanner.scanningStop();
 
     // Now connecting
-    this.emit(RaftConnEvent.CONN_CONNECTING, { deviceId: discoveredRIC.id });
+    this.emit(RaftConnEvent.CONN_CONNECTING, { deviceId: discoveredDevice.id });
 
     // Connect
-    this._ricToConnectTo = discoveredRIC;
+    this._deviceToConnectTo = discoveredDevice;
     const connOk = await this._configDeviceConnection();
 
     // Check if ok
@@ -224,8 +213,8 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
 
     // Emit success
     this.emit(RaftConnEvent.CONN_CONNECTED, {
-      deviceId: this._ricToConnectTo.id,
-      name: this._ricToConnectTo.name,
+      deviceId: this._deviceToConnectTo.id,
+      name: this._deviceToConnectTo.name,
     });
     return true;
   }
@@ -239,9 +228,9 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
   async disconnect(): Promise<void> {
     RaftLog.debug('BLEChannel disconnect requested');
     this._retryConnectionIfLost = false;
-    RaftLog.debug(`this._ricToConnectTo  ${this._ricToConnectTo}`);
-    const connectedRIC = this._ricToConnectTo;
-    this._ricToConnectTo = null;
+    RaftLog.debug(`this._ricToConnectTo  ${this._deviceToConnectTo}`);
+    const connectedRIC = this._deviceToConnectTo;
+    this._deviceToConnectTo = null;
 
     // this._invalidateConnectionInfo(); // //
 
@@ -251,9 +240,9 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
       this._bleSubscrOnDisconnect = null;
     }
     // Disconnect from the connected device
-    const connMarties = await _bleManager.connectedDevices([
-      this._RICServiceUUID,
-    ]);
+    const connMarties = await _bleManager.connectedDevices(
+      this._serviceUUIDs
+    );
     if (connMarties.length == 0) {
       RaftLog.debug('BLEChannel disconnect - no devices connected');
     } else {
@@ -280,7 +269,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
    */
   async _configDeviceConnection(): Promise<boolean> {
     // Check there is a RIC to connect to
-    if (this._ricToConnectTo === null) {
+    if (this._deviceToConnectTo === null) {
       return false;
     }
 
@@ -288,7 +277,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     for (let connRetry = 0; connRetry < 5; connRetry++) {
       try {
         deviceConnected = await _bleManager.connectToDevice(
-          this._ricToConnectTo.id,
+          this._deviceToConnectTo.id,
           {
             timeout: 3000,
           },
@@ -325,7 +314,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     // Request high-priority connection
     try {
       await _bleManager.requestConnectionPriorityForDevice(
-        this._ricToConnectTo.id,
+        this._deviceToConnectTo.id,
         ConnectionPriority.High,
       );
       RaftLog.debug(
@@ -352,10 +341,10 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     }
     // Monitor the inbound characteristic
     try {
-      if (this._bleDevice) {
+      if (this._bleDevice && this._bleDevice.serviceUUIDs) {
         this._bleSubscrOnRx = this._bleDevice.monitorCharacteristicForService(
-          this._RICServiceUUID,
-          this._RICRespUUID,
+          this._bleDevice.serviceUUIDs[0],
+          this._respUUID,
           (error: BleError | null, characteristic: Characteristic | null) => {
             this._onMsgRx(error, characteristic);
           },
@@ -425,15 +414,15 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
           // Check if scan in progress - and stop reconn attempts if so
           const scanInProgress = this._bleScanner.isScanInProgress();
           RaftLog.debug(
-            `onDeviceDisconnected considering reconnection RICToConnectTo ${this._ricToConnectTo?.name} scanInProgress ${scanInProgress} retryConnectionIfLost ${this._retryConnectionIfLost}`,
+            `onDeviceDisconnected considering reconnection RICToConnectTo ${this._deviceToConnectTo?.name} scanInProgress ${scanInProgress} retryConnectionIfLost ${this._retryConnectionIfLost}`,
           );
           if (
             !this._retryConnectionIfLost ||
             scanInProgress ||
-            !this._ricToConnectTo
+            !this._deviceToConnectTo
           ) {
             RaftLog.debug(
-              `onDeviceDisconnected DISCONNECTED_RIC RICToConnectTo ${this._ricToConnectTo?.name} scanInProgress ${scanInProgress} retryConnectionIfLost ${this._retryConnectionIfLost}`,
+              `onDeviceDisconnected DISCONNECTED_RIC RICToConnectTo ${this._deviceToConnectTo?.name} scanInProgress ${scanInProgress} retryConnectionIfLost ${this._retryConnectionIfLost}`,
             );
             if (this._retryConnectionIfLost) {
               // this.emit(RaftConnEvent.BLE_DISCONNECTED_RIC);
@@ -444,7 +433,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
           }
           if (await this._configDeviceConnection()) {
             RaftLog.debug(
-              `onDeviceDisconnected successful reconn RICToConnectTo ${this._ricToConnectTo?.name}`,
+              `onDeviceDisconnected successful reconn RICToConnectTo ${this._deviceToConnectTo?.name}`,
             );
 
             // Indicate connection issue resolved
@@ -454,7 +443,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
             return;
           }
           RaftLog.debug(
-            `onDeviceDisconnected retrying reconn RICToConnectTo ${this._ricToConnectTo?.name}`,
+            `onDeviceDisconnected retrying reconn RICToConnectTo ${this._deviceToConnectTo?.name}`,
           );
         }
       },
@@ -521,12 +510,12 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
 
       try {
         await this._bleDevice.writeCharacteristicWithoutResponseForService(
-          this._RICServiceUUID,
-          this._RICCmdUUID,
+          this._bleDevice.serviceUUIDs ? this._bleDevice.serviceUUIDs[0] : this._serviceUUIDs[0],
+          this._cmdUUID,
           msgFrameBase64!,
         );
         return true;
-      } catch (error) {
+      } catch {
         if (retryIdx === this.maxRetries - 1) {
           RaftLog.debug(`sendTxMsg failed after ${this.maxRetries} attempts`);
           return false;
@@ -560,12 +549,12 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
 
       try {
         this._bleDevice!.writeCharacteristicWithoutResponseForService(
-          this._RICServiceUUID,
-          this._RICCmdUUID,
+          this._bleDevice.serviceUUIDs ? this._bleDevice.serviceUUIDs[0] : this._serviceUUIDs[0],
+          this._cmdUUID,
           msgFrameBase64!,
         );
         return true;
-      } catch (error) {
+      } catch {
         if (retryIdx === this.maxRetries - 1) {
           RaftLog.debug(`sendTxMsgNoAwait failed after ${this.maxRetries} attempts`);
           return false;