@robdobsn/raftjs 1.1.1 → 1.3.1

package/examples/dashboard/src/SystemTypeCog/CogStateInfo.ts

@@ -1,144 +1,162 @@
 import { time } from "console";
 import RaftLog from "../../../../src/RaftLog";
-
-export interface IMUStateInfo {
-    gx: number;
-    gy: number;
-    gz: number;
-    ax: number;
-    ay: number;
-    az: number;
-    tsMs: number;
-}
-
-export interface DeviceLastTsState {
-    lastMs: number;
-    offsetMs: number;
-}
-
-export interface DeviceMsgJsonElem {
-    _t: string; // Device type
-    _o: string; // Device name
-    x: string; // Hex encoded message values
-}
-
-export interface DeviceMsgJsonBus {
-    [devAddr: string]: DeviceMsgJsonElem;
-}
+import { TextDecoder } from 'text-encoding';
+import { DeviceMsgJson } from "../../../../src/RaftDeviceMsg";
+
+// export interface IMUStateInfo {
+//     gx: number;
+//     gy: number;
+//     gz: number;
+//     ax: number;
+//     ay: number;
+//     az: number;
+//     tsMs: number;
+// }
+
+// export interface DeviceLastTsState {
+//     lastMs: number;
+//     offsetMs: number;
+// }
+
+// export interface DeviceMsgJsonElem {
+//     _t: string; // Device type
+//     _o: string; // Device name
+//     x: string; // Hex encoded message values
+// }
+
+// export interface DeviceMsgJsonBus {
+//     [devAddr: string]: DeviceMsgJsonElem;
+// }
   
-export interface DeviceMsgJson {
-    [busName: string]: DeviceMsgJsonBus;
-}
+// export interface DeviceMsgJson {
+//     [busName: string]: DeviceMsgJsonBus;
+// }
 
 export class CogStateInfo {
 
-    LSM6DS: IMUStateInfo = {gx: 0, gy: 0, gz: 0, ax: 0, ay: 0, az: 0, tsMs: 0};
+    // LSM6DS: IMUStateInfo = {gx: 0, gy: 0, gz: 0, ax: 0, ay: 0, az: 0, tsMs: 0};
 
-    // Last timestamp for each device
-    private _deviceLastTs: {[devName: string]: DeviceLastTsState} = {};
+    // // Last timestamp for each device
+    // private _deviceLastTs: {[devName: string]: DeviceLastTsState} = {};
     
+    public constructor(private _deviceManager: DeviceManager) {
+    }
+
     updateFromMsg(rxMsg: Uint8Array, frameTimeMs: number): Array<string> {
 
+        // Debug 
         // RaftLog.info(`CogStateInfo: updateFromMsg: rxMsg: ${rxMsg} frameTimeMs: ${frameTimeMs}`);
 
         // Convert Uint8Array to string
         const decoder = new TextDecoder('utf-8');
         const jsonString = decoder.decode(rxMsg.slice(2));
 
-        // Debug
-        // RaftLog.info(`CogStateInfo: updateFromMsg: jsonString: ${jsonString}`);
+        // Handle using device manager
+        this._deviceManager.handleClientMsgJson(jsonString);
 
         // Parse JSON string to TypeScript object
-        const deviceMsg: DeviceMsgJson = JSON.parse(jsonString);
-
-        // Debug
-        // for (const busName in deviceMsg) {
-        //     for (const devAddr in deviceMsg[busName]) {
-        //         for (const attrGroupName in deviceMsg[busName][devAddr]) {
-        //             RaftLog.info(`CogStateInfo: updateFromMsg: busName ${busName} devAddr ${devAddr} attrGroupName: ${attrGroupName}`);
-        //             RaftLog.info(`CogStateInfo: updateFromMsg: attrValue: ${deviceMsg[busName][devAddr][attrGroupName]}`);
-        //         }
-        //     }
-        // }
-
-        // Iterate over values and extract
-        for (const busName in deviceMsg) {
-            for (const devAddr in deviceMsg[busName]) {
-
-                // Validate
-                if ((deviceMsg[busName][devAddr].x === undefined) || (deviceMsg[busName][devAddr]._t === undefined)) {
-                    RaftLog.warn(`CogStateInfo: updateFromMsg: Invalid message`);
-                    continue;
-                }
-
-                // Extract message and device type
-                const msgHex = deviceMsg[busName][devAddr].x;
-                const devType = deviceMsg[busName][devAddr]._t;
-
-                // Check if message is empty
-                if (msgHex === '') {
-                    RaftLog.warn(`CogStateInfo: updateFromMsg: Empty message`);
-                    continue;
-                }
-
-                // Convert the hex string to an arraybuffer by converting each pair of hex chars to a byte
-                const msgBytes = this.hexToBytes(msgHex);
-
-                // Convert to a Buffer
-                const msgBuffer = Buffer.from(msgBytes);
-
-                // Extract timestamp
-                let timestamp = msgBuffer.readUInt16BE(0);
-                if (this._deviceLastTs[devType] === undefined) {
-                    this._deviceLastTs[devType] = {lastMs: 0, offsetMs: 0};
-                }
-                const devTsState = this._deviceLastTs[devType];
-                if (timestamp < devTsState.lastMs) {
-                    devTsState.offsetMs += 0x10000;
-                }
-                devTsState.lastMs = timestamp;
-                timestamp += devTsState.offsetMs;
-                let msgBufferOffset = 2;
-                // RaftLog.info(`CogStateInfo: updateFromMsg: timestamp: ${timestamp}`);
-
-                // Handle device types
-                switch (devType) {
-                    case 'LSM6DS':
-                        // RaftLog.info(`CogStateInfo: updateFromMsg: IMU`);
-
-                        // LSD6DS IMU data is coded as 16-bit signed integers little-endian
-                        // gx, gy, gz, ax, ay, az
-                        this.LSM6DS = {
-                            gx: msgBuffer.readInt16LE(msgBufferOffset) / 16.384,
-                            gy: msgBuffer.readInt16LE(msgBufferOffset + 2) / 16.384,
-                            gz: msgBuffer.readInt16LE(msgBufferOffset + 4) / 16.384,
-                            ax: msgBuffer.readInt16LE(msgBufferOffset + 6) / 8192,
-                            ay: msgBuffer.readInt16LE(msgBufferOffset + 8) / 8192,
-                            az: msgBuffer.readInt16LE(msgBufferOffset + 10) / 8192,
-                            tsMs: timestamp
-                        };
-
-                        // Debug
-                        // RaftLog.info(`CogStateInfo: updateFromMsg: LSM6DS: gx: ${this.LSM6DS.gx.toFixed(2)} gy: ${this.LSM6DS.gy.toFixed(2)} gz: ${this.LSM6DS.gz.toFixed(2)} ax: ${this.LSM6DS.ax.toFixed(2)} ay: ${this.LSM6DS.ay.toFixed(2)} az: ${this.LSM6DS.az.toFixed(2)} tsMs: ${this.LSM6DS.tsMs}`);
-
-
-
-                        // const imu = deviceMsg[busName][devAddr] as DeviceMsgJsonElem;
-                        // this.imu = {x: imu.x as number, y: imu.y as number, z: imu.z as number, lastMs: frameTimeMs};
-                        break;
-                }
-            }
+        let deviceMsg: DeviceMsgJson;
+        try {
+            deviceMsg = JSON.parse(jsonString);
+        } catch (error) {
+            RaftLog.warn(`CogStateInfo: updateFromMsg: JSON parse error: ${error}`);
+            return [];
         }
 
+    //     // Debug
+    //     // RaftLog.info(`CogStateInfo: updateFromMsg: jsonString: ${jsonString}`);
+
+    //     // Parse JSON string to TypeScript object
+    //     const deviceMsg: DeviceMsgJson = JSON.parse(jsonString);
+
+    //     // Debug
+    //     // for (const busName in deviceMsg) {
+    //     //     for (const devAddr in deviceMsg[busName]) {
+    //     //         for (const attrGroupName in deviceMsg[busName][devAddr]) {
+    //     //             RaftLog.info(`CogStateInfo: updateFromMsg: busName ${busName} devAddr ${devAddr} attrGroupName: ${attrGroupName}`);
+    //     //             RaftLog.info(`CogStateInfo: updateFromMsg: attrValue: ${deviceMsg[busName][devAddr][attrGroupName]}`);
+    //     //         }
+    //     //     }
+    //     // }
+
+    //     // Iterate over values and extract
+    //     for (const busName in deviceMsg) {
+    //         for (const devAddr in deviceMsg[busName]) {
+
+    //             // Validate
+    //             if ((deviceMsg[busName][devAddr].x === undefined) || (deviceMsg[busName][devAddr]._t === undefined)) {
+    //                 RaftLog.warn(`CogStateInfo: updateFromMsg: Invalid message`);
+    //                 continue;
+    //             }
+
+    //             // Extract message and device type
+    //             const msgHex = deviceMsg[busName][devAddr].x;
+    //             const devType = deviceMsg[busName][devAddr]._t;
+
+    //             // Check if message is empty
+    //             if (msgHex === '') {
+    //                 RaftLog.warn(`CogStateInfo: updateFromMsg: Empty message`);
+    //                 continue;
+    //             }
+
+    //             // Convert the hex string to an arraybuffer by converting each pair of hex chars to a byte
+    //             const msgBytes = this.hexToBytes(msgHex);
+
+    //             // Convert to a Buffer
+    //             const msgBuffer = Buffer.from(msgBytes);
+
+    //             // Extract timestamp
+    //             let timestamp = msgBuffer.readUInt16BE(0);
+    //             if (this._deviceLastTs[devType] === undefined) {
+    //                 this._deviceLastTs[devType] = {lastMs: 0, offsetMs: 0};
+    //             }
+    //             const devTsState = this._deviceLastTs[devType];
+    //             if (timestamp < devTsState.lastMs) {
+    //                 devTsState.offsetMs += 0x10000;
+    //             }
+    //             devTsState.lastMs = timestamp;
+    //             timestamp += devTsState.offsetMs;
+    //             let msgBufferOffset = 2;
+    //             // RaftLog.info(`CogStateInfo: updateFromMsg: timestamp: ${timestamp}`);
+
+    //             // Handle device types
+    //             switch (devType) {
+    //                 case 'LSM6DS':
+    //                     // RaftLog.info(`CogStateInfo: updateFromMsg: IMU`);
+
+    //                     // LSD6DS IMU data is coded as 16-bit signed integers little-endian
+    //                     // gx, gy, gz, ax, ay, az
+    //                     this.LSM6DS = {
+    //                         gx: msgBuffer.readInt16LE(msgBufferOffset) / 16.384,
+    //                         gy: msgBuffer.readInt16LE(msgBufferOffset + 2) / 16.384,
+    //                         gz: msgBuffer.readInt16LE(msgBufferOffset + 4) / 16.384,
+    //                         ax: msgBuffer.readInt16LE(msgBufferOffset + 6) / 8192,
+    //                         ay: msgBuffer.readInt16LE(msgBufferOffset + 8) / 8192,
+    //                         az: msgBuffer.readInt16LE(msgBufferOffset + 10) / 8192,
+    //                         tsMs: timestamp
+    //                     };
+
+    //                     // Debug
+    //                     // RaftLog.info(`CogStateInfo: updateFromMsg: LSM6DS: gx: ${this.LSM6DS.gx.toFixed(2)} gy: ${this.LSM6DS.gy.toFixed(2)} gz: ${this.LSM6DS.gz.toFixed(2)} ax: ${this.LSM6DS.ax.toFixed(2)} ay: ${this.LSM6DS.ay.toFixed(2)} az: ${this.LSM6DS.az.toFixed(2)} tsMs: ${this.LSM6DS.tsMs}`);
+
+
+
+    //                     // const imu = deviceMsg[busName][devAddr] as DeviceMsgJsonElem;
+    //                     // this.imu = {x: imu.x as number, y: imu.y as number, z: imu.z as number, lastMs: frameTimeMs};
+    //                     break;
+    //             }
+    //         }
+    //     }
+
         return [];
 
     }
 
-    private hexToBytes(hex: string): Uint8Array {
-        const bytes = new Uint8Array(hex.length / 2);
-        for (let i = 0; i < bytes.length; i++) {
-            bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
-        }
-        return bytes;
-    }    
+    // private hexToBytes(hex: string): Uint8Array {
+    //     const bytes = new Uint8Array(hex.length / 2);
+    //     for (let i = 0; i < bytes.length; i++) {
+    //         bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+    //     }
+    //     return bytes;
+    // }    
   }

package/examples/dashboard/src/SystemTypeCog/SystemTypeCog.ts

@@ -1,19 +1,14 @@
 import { RaftSubscribeForUpdatesCBType, RaftSystemType } from "../../../../src/RaftSystemType";
 import { RaftEventFn, RaftLog, RaftOKFail, RaftPublishEvent, RaftPublishEventNames, RaftSystemUtils } from "../../../../src/main";
 import { CogStateInfo } from "./CogStateInfo";
+import { DeviceManager } from "../../../../src/RaftDeviceManager";
 
 export default class SystemTypeCog implements RaftSystemType {
     nameForDialogs = "Robotical Cog";
     defaultWiFiHostname = "Cog";
     firmwareDestName = "ricfw";
     normalFileDestName = "fs";
-    connectorOptions = {wsSuffix: "wsjson"};
-
-    // Latest data from servos, IMU, etc
-    private _stateInfo: CogStateInfo = new CogStateInfo();
-    getStateInfo(): CogStateInfo {
-      return this._stateInfo;
-    }
+    connectorOptions = {wsSuffix: "wsjson", bleConnItvlMs: 50};
 
     // Event handler
     private _onEvent: RaftEventFn | null = null;
@@ -21,10 +16,20 @@ export default class SystemTypeCog implements RaftSystemType {
     // 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: CogStateInfo = new CogStateInfo(this._deviceManager);
+    getStateInfo(): CogStateInfo {
+      return this._stateInfo;
     }
 
     // Subscribe for updates
@@ -72,6 +77,8 @@ export default class SystemTypeCog implements RaftSystemType {
             frameTimeMs: frameTimeMs
           });
       }
-
     };
+
+    // Get device manager
+    deviceMgrIF = this._deviceManager;
   }

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

@@ -1,9 +1,11 @@
+import RaftDeviceMgrIF from "../../../../src/RaftDeviceMgrIF";
+import { DeviceAttributeState, DevicesState, DeviceState } from "../../../../src/RaftDeviceStates";
 import { RICSERIAL_PAYLOAD_POS } from "../../../../src/RaftProtocolDefs";
 import RICAddOnManager from "./RICAddOnManager";
 import RICCommsStats from "./RICCommsStats";
 import { RICROSSerial, ROSCameraData, ROSSerialAddOnStatusList, ROSSerialIMU, ROSSerialPowerStatus, ROSSerialRobotStatus, ROSSerialSmartServos } from "./RICROSSerial";
 
-export class RICStateInfo {
+export class RICStateInfo implements RaftDeviceMgrIF {
     smartServos: ROSSerialSmartServos = new ROSSerialSmartServos();
     smartServosValidMs = 0;
     imuData: ROSSerialIMU = new ROSSerialIMU();
@@ -28,5 +30,49 @@ export class RICStateInfo {
             frameTimeMs
           );    
     }
+
+    getDevicesState(): DevicesState {
+
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+        return {};
+    }
+
+    getDeviceState(deviceKey: string): DeviceState {
+
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+        return {
+            deviceTypeInfo: undefined,
+            deviceTimeline: {
+                timestampsUs: [],
+                lastReportTimestampUs: 0,
+                reportTimestampOffsetUs: 0
+            },
+            deviceAttributes: {},
+            deviceIsNew: false,
+            stateChanged: false,
+            isOnline: false
+        };
+    }
+
+    onNewDevice(callback: (deviceKey: string, state: DeviceState) => void): void {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+    }
+
+    onNewDeviceAttribute(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+    }
+
+    onNewAttributeData(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+    }
+
+    sendAction(deviceKey: string, action: any, data: any): void {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+    }
+
+    sendCompoundAction(deviceKey: string, action: any, data: any): void {
+        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
+    }
+
   }
   

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

@@ -11,7 +11,7 @@ export default class SystemTypeMarty implements RaftSystemType {
   defaultWiFiHostname = "Marty";
   firmwareDestName = "ricfw";
   normalFileDestName = "fs";
-  connectorOptions = {wsSuffix: "ws"};
+  connectorOptions = {wsSuffix: "ws", bleConnItvlMs: 7.5};
 
   // LED Pattern checker
   private _ledPatternChecker: RICLEDPatternChecker = new RICLEDPatternChecker();
@@ -109,5 +109,8 @@ export default class SystemTypeMarty implements RaftSystemType {
         });
     }
   }
+
+  // Device manager interface
+  deviceMgrIF = this._ricStateInfo;
 }