@robotical/raftjs 1.3.5 → 1.4.0

package/src/RaftStruct.ts

@@ -0,0 +1,209 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RaftStruct
+// Part of RaftJS
+//
+// Rob Dobson 2024
+// (C) 2024 All rights reserved
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+export function structUnpack(format: string, data: Uint8Array): number[] {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const results: number[] = [];
+    let offset = 0;
+    let littleEndian = false;
+
+    for (const char of format) {
+        switch (char) {
+            case "<":
+                littleEndian = true;
+                break;
+            case ">":
+                littleEndian = false;
+                break;
+            case "x": // Padding byte
+                offset += 1;
+                break;
+            case "c": // Char
+                results.push(view.getUint8(offset));
+                offset += 1;
+                break;
+            case "b": // Signed 8-bit integer
+                results.push(view.getInt8(offset));
+                offset += 1;
+                break;
+            case "B": // Unsigned 8-bit integer
+                results.push(view.getUint8(offset));
+                offset += 1;
+                break;
+            case "h": // Signed 16-bit integer
+                results.push(view.getInt16(offset, littleEndian));
+                offset += 2;
+                break;
+            case "H": // Unsigned 16-bit integer (big-endian)
+                results.push(view.getUint16(offset, littleEndian));
+                offset += 2;
+                break;
+            case "i": // Signed 32-bit integer (big-endian)
+                results.push(view.getInt32(offset, littleEndian));
+                offset += 4;
+                break;
+            case "I": // Unsigned 32-bit integer (big-endian)
+                results.push(view.getUint32(offset, littleEndian));
+                offset += 4;
+                break;
+            case "l": // Signed 32-bit integer (big-endian)
+                results.push(view.getInt32(offset, littleEndian));
+                offset += 4;
+                break;
+            case "L": // Unsigned 32-bit integer (big-endian)
+                results.push(view.getUint32(offset, littleEndian));
+                offset += 4;
+                break;
+            // case "q": // Signed 64-bit integer (big-endian)
+            //     results.push(view.getBigInt64(offset, littleEndian));
+            //     offset += 8;
+            //     break;
+            // case "Q": // Unsigned 64-bit integer (big-endian)
+            //     results.push(view.getBigUint64(offset, littleEndian));
+            //     offset += 8;
+            //     break;
+            case "f": // 32-bit float (big-endian)
+                results.push(view.getFloat32(offset, littleEndian));
+                offset += 4;
+                break;
+            case "d": // 64-bit float (big-endian)
+                results.push(view.getFloat64(offset, littleEndian));
+                offset += 8;
+                break;
+            default:
+                throw new Error(`Unknown format character: ${char}`);
+        }
+    }
+
+    return results;
+}
+
+export function structSizeOf(format: string): number {
+    let size = 0;
+    for (const char of format) {
+        switch (char) {
+            case "<":
+            case ">":
+                break;
+            case "x": // Padding byte
+                size += 1;
+                break;
+            case "c": // Char
+            case "b": // Signed 8-bit integer
+            case "B": // Unsigned 8-bit integer
+                size += 1;
+                break;
+            case "h": // Signed 16-bit integer
+            case "H": // Unsigned 16-bit integer
+                size += 2;
+                break;
+            case "i": // Signed 32-bit integer
+            case "I": // Unsigned 32-bit integer
+            case "l": // Signed 32-bit integer
+            case "L": // Unsigned 32-bit integer
+                size += 4;
+                break;
+            // case "q": // Signed 64-bit integer
+            // case "Q": // Unsigned 64-bit integer
+            //     size += 8;
+            //     break;
+            case "f": // 32-bit float
+                size += 4;
+                break;
+            case "d": // 64-bit float
+                size += 8;
+                break;
+            default:
+                throw new Error(`Unknown format character: ${char}`);
+        }
+    }
+    return size;
+}
+
+export function structPack(format: string, values: number[]): Uint8Array {
+    const size = structSizeOf(format);
+    const buffer = new ArrayBuffer(size);
+    const view = new DataView(buffer);
+    let offset = 0;
+    let littleEndian = false;
+
+    let valIdx = 0;
+    for (let i = 0; i < format.length; i++) {
+        const char = format[i];
+        const value = values[valIdx];
+        switch (char) {
+            case "<":
+                littleEndian = true;
+                break;
+            case ">":
+                littleEndian = false;
+                break;
+            case "x": // Padding byte
+                offset += 1;
+                break;
+            case "c": // Char
+                view.setInt8(offset, value);
+                offset += 1;
+                break;
+            case "b": // Signed 8-bit integer
+                view.setInt8(offset, value);
+                offset += 1;
+                break;
+            case "B": // Unsigned 8-bit integer
+                view.setUint8(offset, value);
+                offset += 1;
+                break;
+            case "h": // Signed 16-bit integer
+                view.setInt16(offset, value, littleEndian);
+                offset += 2;
+                break;
+            case "H": // Unsigned 16-bit integer
+                view.setUint16(offset, value, littleEndian);
+                offset += 2;
+                break;
+            case "i": // Signed 32-bit integer
+                view.setInt32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            case "I": // Unsigned 32-bit integer
+                view.setUint32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            case "l": // Signed 32-bit integer
+                view.setInt32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            case "L": // Unsigned 32-bit integer
+                view.setUint32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            // case "q": // Signed 64-bit integer
+            //     view.setBigInt64(offset, BigInt(value), littleEndian);
+            //     offset += 8;
+            //     break;
+            // case "Q": // Unsigned 64-bit integer
+            //     view.setBigUint64(offset, BigInt(value), littleEndian);
+            //     offset += 8;
+            //     break;
+            case "f": // 32-bit float
+                view.setFloat32(offset, value, littleEndian);
+                offset += 4;
+                break;
+            case "d": // 64-bit float
+                view.setFloat64(offset, value, littleEndian);
+                offset += 8;
+                break;
+            default:
+                throw new Error(`Unknown format character: ${char}`);
+        }
+    }
+
+    return new Uint8Array(buffer);
+}

package/src/RaftSysTypeManager.ts

@@ -0,0 +1,60 @@
+import { RaftSystemType } from "./RaftSystemType";
+
+type RaftSystemTypeCreator = () => RaftSystemType;
+
+export default class RaftSysTypeManager {
+  // Singleton instance
+  private static _instance: RaftSysTypeManager;
+
+  // System type map
+  private _sysTypes: Map<string, RaftSystemTypeCreator> = new Map();
+  private _defaultSysTypeFactory: RaftSystemTypeCreator | null = null;
+
+  // Get instance (Singleton)
+  public static getInstance(): RaftSysTypeManager {
+    if (!RaftSysTypeManager._instance) {
+      RaftSysTypeManager._instance = new RaftSysTypeManager();
+    }
+    return RaftSysTypeManager._instance;
+  }
+
+  // Add a system type by name with its factory
+  public addSystemType(sysType: string, factory: RaftSystemTypeCreator): void {
+    if (this._sysTypes.has(sysType)) {
+      throw new Error(`System type '${sysType}' is already registered.`);
+    }
+    this._sysTypes.set(sysType, factory);
+  }
+
+  // Set the default system type factory
+  public addDefaultSystemType(factory: RaftSystemTypeCreator): void {
+    this._defaultSysTypeFactory = factory;
+  }
+
+  // Create a system type by name
+  public createSystemType(sysType: string): RaftSystemType | null {
+    const factory = this._sysTypes.get(sysType);
+    if (!factory) {
+      return null;
+    }
+    return factory();
+  }
+
+  // Create the default system type
+  public createDefaultSystemType(): RaftSystemType | null {
+    if (!this._defaultSysTypeFactory) {
+      return null;
+    }
+    return this._defaultSysTypeFactory();
+  }
+
+  // Get a list of all unique BLE service UUIDs
+  getAllServiceUUIDs(): string[] {
+    const serviceUUIDs = new Set<string>();
+    this._sysTypes.forEach((factory) => {
+      const sysType = factory();
+      sysType.BLEServiceUUIDs.forEach((uuid) => serviceUUIDs.add(uuid));
+    });
+    return Array.from(serviceUUIDs);
+  }
+}

package/src/RaftSystemType.ts

@@ -16,6 +16,9 @@ export interface ConnectorOptions {
 export interface RaftSystemType {
   nameForDialogs: string;
   defaultWiFiHostname: string;
+  BLEServiceUUIDs: string[];
+  BLECmdUUID: string;
+  BLERespUUID: string;
   firmwareDestName: string;
   normalFileDestName: string;
   connectorOptions: ConnectorOptions;

package/src/RaftTypes.ts

@@ -32,7 +32,7 @@ export type RaftEventFn = (
   eventType: string,
   eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent,
   eventName: string,
-  data?: object | string | null,
+  data?: object | string | null
 ) => void;
 
 export interface RaftSubscription {
@@ -59,30 +59,22 @@ export class RaftSystemInfo {
   Friendly? = "";
 }
 
-export class RaftCalibInfo {
-  rslt = '';
-  calDone = 0;
-  validMs? = 0;
+export type RaftCalibInfo = {
+  rslt: string;
+  calDone: number;
+  validMs? : number;
 }
 
+// NOTE: Do not put any methods in any of the response classes as they 
+// are simply wrappers around JSON and will not necessarily be constructed
+// as objects
 export class RaftOKFail {
-  RAFT_OK = 'ok';
-  set(rsltFlag: boolean) {
-    if (rsltFlag) {
-      this.rslt = this.RAFT_OK;
-    } else {
-      this.rslt = 'fail';
-    }
-  }
-  rslt = 'commsFail';
-  isOk() {
-    return this.rslt === this.RAFT_OK;
-  }
+  rslt = 'failComms';
 }
 
-export class RaftReportMsg {
+export type RaftReportMsg = {
   msgType?: string;
-  rslt = '';
+  rslt: string;
   timeReceived?: number;
   hexRd?: string;
   elemName?: string;
@@ -92,19 +84,19 @@ export class RaftReportMsg {
   msgBody?: string;
 }
 
-export class RaftHWFWStat {
-  s = '';
-  m = '';
-  v = '';
-  n = '';
-  p = 0;
-  i = 0;
+export type RaftHWFWStat = {
+  s: string;
+  m: string;
+  v: string;
+  n: string;
+  p: number;
+  i: number;
 }
 
-export class RaftHWFWUpdRslt {
-  req = '';
-  rslt = 'commsFail';
-  st: RaftHWFWStat = new RaftHWFWStat();
+export type RaftHWFWUpdRslt = {
+  req: string;
+  rslt: string;
+  st: RaftHWFWStat;
 }
 
 export type RaftFWInfo = {
@@ -248,16 +240,18 @@ export type PystatusMsgType = {
 };
 
 // Phone BLE 
-export class DiscoveredRIC {
+export class DiscoveredDevice {
   _localName = '';
   _name = '';
   _id = '';
   _rssi = -150;
-  constructor(localName: string, name: string, id: string, rssi: number) {
+  _serviceUUIDs: string[] | null = [];
+  constructor(localName: string, name: string, id: string, rssi: number, serviceUUIDs: string[] | null) {
     this._localName = localName;
     this._name = name;
     this._id = id;
     this._rssi = rssi;
+    this._serviceUUIDs = serviceUUIDs;
   }
   get name(): string {
     if (this._localName !== null && this._localName.length > 0) {
@@ -276,6 +270,9 @@ export class DiscoveredRIC {
     if (this._rssi !== null) return this._rssi;
     return -100;
   }
+  get serviceUUIDs(): string[] | null {
+    return this._serviceUUIDs;
+  }
 }
 
-export type DiscoveredRICsCB = (discoveredRICs: DiscoveredRIC[]) => void;
+export type DiscoveredDevicesCB = (discoveredDevicess: DiscoveredDevice[]) => void;

package/src/RaftUpdateManager.ts

@@ -8,7 +8,6 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-import axios from "axios";
 import RaftChannel from "./RaftChannel";
 import RaftFileHandler from "./RaftFileHandler";
 import RaftLog from "./RaftLog";
@@ -91,8 +90,12 @@ export default class RICUpdateManager {
 
       // debug
       RaftLog.debug(`Update URL: ${updateURL}`);
-      const response = await axios.get(updateURL);
-      this._latestVersionInfo = response.data;
+      const response = await fetch(updateURL, { method: 'GET' });
+      if (!response.ok) {
+        RaftLog.debug(`HTTP error! status: ${response.status}`);
+        return RaftUpdateEvent.UPDATE_CANT_REACH_SERVER;
+      }
+      this._latestVersionInfo = await response.json();
     } catch (error) {
       RaftLog.debug(`Failed to get latest version from internet ${error}`);
     }

package/src/RaftUtils.ts

@@ -9,8 +9,6 @@
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 import RaftLog from "./RaftLog";
-import semverGt from "semver/functions/gt";
-import semverEq from "semver/functions/eq";
 
 export default class RaftUtils {
   static _isEndianSet = false;
@@ -446,9 +444,21 @@ export default class RaftUtils {
     }
   }
 
+  static semverGt(v1: string, v2: string): boolean {
+    const [major1, minor1, patch1] = v1.split('.').map(Number);
+    const [major2, minor2, patch2] = v2.split('.').map(Number);
+    if (major1 !== major2) return major1 > major2;
+    if (minor1 !== minor2) return minor1 > minor2;
+    return patch1 > patch2;
+  }
+
   static isVersionGreater(v1: string, v2: string) {
     try {
-      return semverGt(v1, v2);
+      const [major1, minor1, patch1] = v1.split('.').map(Number);
+      const [major2, minor2, patch2] = v2.split('.').map(Number);
+      if (major1 !== major2) return major1 > major2;
+      if (minor1 !== minor2) return minor1 > minor2;
+      return patch1 > patch2;
     } catch (e) {
       // one of the two versions is invalid, return true
       RaftLog.warn(`isVersionGreater - invalid version ${v1} or ${v2} ${e}`);
@@ -458,7 +468,7 @@ export default class RaftUtils {
 
   static isVersionEqual(v1: string, v2: string) {
     try {
-      return semverEq(v1, v2);
+      return v1 === v2;
     } catch (e) {
       // one of the two versions is invalid, return false
       RaftLog.error(`isVersionEqual - invalid version ${v1} or ${v2} ${e}`);

package/src/main.ts

@@ -23,10 +23,10 @@ export { default as RaftMsgHandler } from './RaftMsgHandler'
 export { default as RaftStreamHandler } from './RaftStreamHandler';
 export { default as RaftSystemUtils } from './RaftSystemUtils';
 export { default as RaftUtils } from './RaftUtils';
-export { DeviceManager } from './RaftDeviceManager';
+export { default as RaftSysTypeManager } from './RaftSysTypeManager';
+export { default as RaftDeviceMgrIF } from './RaftDeviceMgrIF';
 export { DeviceManager as RaftDeviceManager } from './RaftDeviceManager';
 
-
 export * from './RaftTypes';
 export * from './RaftSystemType';
 export * from './RaftWifiTypes';