@robotical/raftjs 1.3.5 → 1.4.0

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`);
@@ -100,7 +103,8 @@ export default class AttributeHandler {
                 devAttrsState[attrDef.n] = {
                     name: attrDef.n,
                     newAttribute: true,
-                    newData: true,
+                    newData: false,
+                    numNewValues: 0,
                     values: [],
                     units: decodeAttrUnitsEncoding(attrDef.u || ""),
                     range: attrDef.r || [0, 0],
@@ -119,11 +123,12 @@ export default class AttributeHandler {
             // Add the new values
             devAttrsState[attrDef.n].values.push(...newAttrValues[attrIdx]);
             devAttrsState[attrDef.n].newData = newAttrValues[attrIdx].length > 0;
+            devAttrsState[attrDef.n].numNewValues = newAttrValues[attrIdx].length;
         }
 
         // 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 +146,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 +174,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) {
@@ -236,6 +241,10 @@ export default class AttributeHandler {
         // Move buffer position if using relative positioning
         msgBufIdx += attrUsesAbsPos ? 0 : numBytesConsumed;
 
+        // if (attrDef.n === "amb0") {
+        //     console.log(`${new Date().toISOString()} ${attrDef.n} ${attrValues}`);
+        // }
+
         // Return the value
         return { values: attrValues, newMsgBufIdx: msgBufIdx };
     }
@@ -252,7 +261,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 +273,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,29 +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 CogServiceUUID = "da903f65-d5c2-4f4d-a065-d1aade7af874";
-  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)
@@ -49,7 +46,6 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
   _bleSubscrOnStateChange: Subscription | null = null;
   _bleDevice: Device | null = null;
 
-
   // MTU (Maximum Transmission Unit) size to request
   MTU_SIZE_TO_REQUEST = 512;
 
@@ -61,23 +57,22 @@ 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;
 
+  // Connected device UUID
+  private _connectedDeviceServiceUUID?: string;
+
   constructor() {
     RaftLog.debug('BLEChannel constructor');
 
     // _bleManager.setLogLevel(LogLevel.Verbose);
 
     // Scanner
-    this._bleScanner = new RICBLEScanner(
+    this._bleScanner = new RaftChannelBLEScanner(
       _bleManager,
-      [RaftChannelPhoneBLE.ServiceUUID, RaftChannelPhoneBLE.CogServiceUUID],
+      this._serviceUUIDs,
       this.scanningEvent.bind(this),
     );
 
@@ -87,6 +82,10 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     }, true);
   }
 
+  setConnectedDeviceUUID(serviceUUID: string) {
+    this._connectedDeviceServiceUUID = serviceUUID;
+  }
+
   getBleManager(): BleManager {
     return _bleManager;
   }
@@ -99,7 +98,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
 
   // isConnected
   isConnected(): boolean {
-    return this._bleDevice !== null && this._isConnected;
+    return this._bleDevice !== null;
   }
 
   setOnConnEvent(connEventFn: RaftConnEventFn): void {
@@ -124,12 +123,23 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     this._retryConnectionIfLost = retry;
   }
 
-  async discoveryStart(uuid?: string): Promise<boolean> {
+  async discoveryStart(uuids: string[], tries = 10): Promise<boolean> {
+    if (tries <= 0) {
+      RaftLog.debug(`BLEChannel discoveryStart failed after 5 tries`);
+      return false;
+    }
     // Disconnect any existing connection
     // await this.disconnect();
 
+    // wait until the bt is powered on
+    const state = await _bleManager.state();
+    if (state !== State.PoweredOn) {
+      RaftLog.debug(`BLEChannel discoveryStart waiting for BLE powered on`);
+      await new Promise(resolve => setTimeout(resolve, 500));
+      return this.discoveryStart(uuids, tries - 1);
+    }
     // Start scanning
-    await this._bleScanner.scanningStart(uuid);
+    await this._bleScanner.scanningStart(uuids);
 
     // Event
     RaftLog.debug(`BLEChannel discoveryStart emitting BLE_SCANNING_STARTED`);
@@ -200,16 +210,18 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
    * @returns boolean (true if connected)
    *
    */
-  async connect(discoveredRIC: DiscoveredRIC): Promise<boolean> {
-    RaftLog.debug('BLEChannel requested connection');
+  async connect(discoveredDevice: DiscoveredDevice): Promise<boolean> {
+    RaftLog.debug('BLEChannel requested connection ' + JSON.stringify(discoveredDevice));
+    this._connectedDeviceServiceUUID = discoveredDevice.serviceUUIDs ? discoveredDevice.serviceUUIDs[0] : undefined;
+
     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
@@ -221,8 +233,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;
   }
@@ -236,9 +248,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(); // //
 
@@ -248,9 +260,9 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
       this._bleSubscrOnDisconnect = null;
     }
     // Disconnect from the connected device
-    const connMarties = await _bleManager.connectedDevices([
-      RaftChannelPhoneBLE.ServiceUUID,
-    ]);
+    const connMarties = await _bleManager.connectedDevices(
+      this._serviceUUIDs
+    );
     if (connMarties.length == 0) {
       RaftLog.debug('BLEChannel disconnect - no devices connected');
     } else {
@@ -277,7 +289,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;
     }
 
@@ -285,7 +297,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,
           },
@@ -322,7 +334,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(
@@ -350,9 +362,13 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     // Monitor the inbound characteristic
     try {
       if (this._bleDevice) {
+        if (!this._connectedDeviceServiceUUID) {
+          RaftLog.error('BLEChannel _configDeviceConnection - no connected device service UUID');
+          return false;
+        }
         this._bleSubscrOnRx = this._bleDevice.monitorCharacteristicForService(
-          RaftChannelPhoneBLE.ServiceUUID,
-          RaftChannelPhoneBLE.RespUUID,
+          this._connectedDeviceServiceUUID,
+          this._respUUID,
           (error: BleError | null, characteristic: Characteristic | null) => {
             this._onMsgRx(error, characteristic);
           },
@@ -422,15 +438,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);
@@ -441,7 +457,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
@@ -451,7 +467,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
             return;
           }
           RaftLog.debug(
-            `onDeviceDisconnected retrying reconn RICToConnectTo ${this._ricToConnectTo?.name}`,
+            `onDeviceDisconnected retrying reconn RICToConnectTo ${this._deviceToConnectTo?.name}`,
           );
         }
       },
@@ -482,7 +498,7 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
     const rxFrame = RaftUtils.atob(msgFrameBase64!);
 
     // Debug
-    // RaftLog.debug('_onMsgRx from BLE ' + RICUtils.bufferToHex(rxFrame));
+    // RaftLog.debug('_onMsgRx from BLE ' + RaftUtils.bufferToHex(rxFrame));
 
     // Send
     if (rxFrame !== null && this._raftMsgHandler) {
@@ -517,13 +533,17 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
       const msgFrameBase64 = RaftUtils.btoa(msg);
 
       try {
-        await this._bleDevice.writeCharacteristicWithoutResponseForService(
-          RaftChannelPhoneBLE.ServiceUUID,
-          RaftChannelPhoneBLE.CmdUUID,
+        if (!this._connectedDeviceServiceUUID) {
+          RaftLog.error('BLEChannel sendTxMsg - no connected device service UUID');
+          return false;
+        }
+        await this._bleDevice!.writeCharacteristicWithoutResponseForService(
+          this._connectedDeviceServiceUUID,
+          this._cmdUUID,
           msgFrameBase64!,
         );
         return true;
-      } catch (error) {
+      } catch {
         if (retryIdx === this.maxRetries - 1) {
           RaftLog.debug(`sendTxMsg failed after ${this.maxRetries} attempts`);
           return false;
@@ -556,13 +576,17 @@ export default class RaftChannelPhoneBLE implements RaftChannel {
       const msgFrameBase64 = RaftUtils.btoa(msg);
 
       try {
+        if (!this._connectedDeviceServiceUUID) {
+          RaftLog.error('BLEChannel sendTxMsgNoAwait - no connected device service UUID');
+          return false;
+        }
         this._bleDevice!.writeCharacteristicWithoutResponseForService(
-          RaftChannelPhoneBLE.ServiceUUID,
-          RaftChannelPhoneBLE.CmdUUID,
+          this._connectedDeviceServiceUUID,
+          this._cmdUUID,
           msgFrameBase64!,
         );
         return true;
-      } catch (error) {
+      } catch {
         if (retryIdx === this.maxRetries - 1) {
           RaftLog.debug(`sendTxMsgNoAwait failed after ${this.maxRetries} attempts`);
           return false;

package/src/RaftChannelBLE.web.ts

@@ -16,12 +16,12 @@ import { ConnectorOptions } from "./RaftSystemType";
 import RaftUtils from "./RaftUtils";
 
 export default class RaftChannelBLE implements RaftChannel {
-  // BLE UUIDS
-  public static RICServiceUUID = "aa76677e-9cfd-4626-a510-0d305be57c8d";
-  public static CogServiceUUID = "da903f65-d5c2-4f4d-a065-d1aade7af874";
-  public static CmdUUID = "aa76677e-9cfd-4626-a510-0d305be57c8e";
-  public static RespUUID = "aa76677e-9cfd-4626-a510-0d305be57c8f";
 
+  // 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'];
+  
   // Device and characteristics
   private _bleDevice: BluetoothDevice | null = null;
   private _characteristicTx: BluetoothRemoteGATTCharacteristic | null = null;
@@ -143,7 +143,7 @@ export default class RaftChannelBLE implements RaftChannel {
             try {
               let service: BluetoothRemoteGATTService | null = null;
               // iterate over known services
-              for (const serviceUUID of [RaftChannelBLE.CogServiceUUID, RaftChannelBLE.RICServiceUUID]) {
+              for (const serviceUUID of this._serviceUUIDs) {
                 try {
                   service = await this._bleDevice.gatt.getPrimaryService(serviceUUID);
                   if (service) {
@@ -169,13 +169,13 @@ export default class RaftChannelBLE implements RaftChannel {
               try {
                 // Get Tx and Rx characteristics
                 this._characteristicTx = await service.getCharacteristic(
-                  RaftChannelBLE.CmdUUID
+                  this._cmdUUID
                 );
                 RaftLog.debug(
                   `RaftChannelBLE.connect - found char ${this._characteristicTx.uuid}`
                 );
                 this._characteristicRx = await service.getCharacteristic(
-                  RaftChannelBLE.RespUUID
+                  this._respUUID
                 );
                 RaftLog.debug(
                   `RaftChannelBLE.connect - found char ${this._characteristicRx.uuid}`