@robdobsn/raftjs 1.7.2 → 1.7.5

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

@@ -1,146 +0,0 @@
-/**
- * The RICServoFaultDetection class is responsible for detecting faults in the RIC servos.
- * These are the faults that can currently be detected:
-    1) Wiring fault - Intermittent connection to servo potentiometer
-    2) Wiring fault - no connection to servo potentiometer
-    3) Wiring fault - faulty connection to servo drive
-    4) Servo horn has shifted out of position
-
- * To detect these faults:
-    1) get the list of all servos
-        1.1) We filter out the servos that don't have the fault bit enabled in their status byte
-    2) sending an atomic read command to the servos
-        2.1) the servos will respond with a report msg
-        2.2) the fault flags are on the 11th byte of the report msg
-        2.3) The 'fault' byte has 8 bits, each of which corresponds to a specific type of fault (there are only 4 types of faults so far, so the remaining 4 bits are unused.)
-            Bit 0: Intermittent connection to potentiometer
-            Bit 1: No connection to potentiometer
-            Bit 2: Faulty connection to motor drive
-            Bit 3: Servo horn position error
-    3) in a second phase, we receive the report msg from the app, and check the fault flags
- */
-
-import { RICServoFaultFlags } from "./RICTypes";
-import { RICStateInfo } from "./RICStateInfo";
-import RaftMsgHandler from "../../../../src/RaftMsgHandler";
-import RaftLog from "../../../../src/RaftLog";
-import { RICHWElemList_Min } from "./RICHWElem";
-import { RaftReportMsg } from "../../../../src/RaftTypes";
-
-export default class RICServoFaultDetector {
-    private _raftMsgHandler: RaftMsgHandler;
-    private static expirationDate: Date = new Date();
-    private static _servoList: string[] = [];
-    private ricStateReference: RICStateInfo;
-
-    constructor(raftMsgHandler: RaftMsgHandler, ricStateReference: RICStateInfo) {
-        this._raftMsgHandler = raftMsgHandler;
-        this.ricStateReference = ricStateReference;
-    }
-
-    private async getAllServos(): Promise<void> {
-        RICServoFaultDetector._servoList = [];
-        const response = await this._raftMsgHandler.sendRICRESTURL<RICHWElemList_Min>("hwstatus/minstat?filterByType=SmartServo");
-        if (!response || !response.hw) {
-            RaftLog.warn("RICServoFaultDetector: Error getting servo list");
-            return;
-        }
-        const servosWithIdAndName = response.hw.map((smartServo) => ({ id: smartServo.I, name: smartServo.n }));
-        // filter only the servos that they have enabled the fault bit in their status byte
-        const servosWithFaultBitEnabled = servosWithIdAndName.filter((smartServo) => {
-            const foundSmartServoStatus = this.ricStateReference.smartServos.smartServos.find((smartServoStat) => smartServoStat.id === +smartServo.id);
-            if (!foundSmartServoStatus) {
-                return false;
-            }
-            return RICServoFaultDetector.isFaultBitEnabled(foundSmartServoStatus.status);
-        });
-        const filteredServoArrayWithNames = servosWithFaultBitEnabled.map((smartServo) => smartServo.name);
-        try {
-            RICServoFaultDetector._servoList = filteredServoArrayWithNames;
-        } catch (e) {
-            console.log("Error getting servo list");
-        }
-    }
-
-    async atomicReadOperation(expirationTime = 5000): Promise<void> {
-        await this.getAllServos();
-        // setting an expiration date within which the interpreter should receive the report msg
-        RICServoFaultDetector.expirationDate = new Date(Date.now() + expirationTime);
-        for (let i = 0; i < RICServoFaultDetector._servoList.length; i++) {
-            const servoName = RICServoFaultDetector._servoList[i];
-            try {
-                await this._raftMsgHandler.sendRICRESTURL<void>(`elem/${servoName}/json?cmd=raw&numToRd=11&msgKey=100${i}`);
-            } catch (e) {
-                RaftLog.warn(`RICServoFaultDetector: Error sending atomic read command to servo ${servoName}`);
-            }
-        }
-    }
-
-    static interpretReportMsg(reportMsg: RaftReportMsg): RICServoFaultFlags | undefined {
-        // make sure the report msg is not expired
-        if (new Date() > RICServoFaultDetector.expirationDate) {
-            RaftLog.warn(`RICServoFaultDetector: Received report msg after expiration date: ${reportMsg}`);
-            return;
-        }
-        // make sure this is a raw report msg
-        if (reportMsg.msgType !== "raw") {
-            RaftLog.warn(`RICServoFaultDetector: Received non-raw report msg: ${reportMsg}`);
-            return;
-        }
-        // making sure the report msg is from a servo
-        if (reportMsg.elemName && !RICServoFaultDetector._servoList.includes(reportMsg.elemName)) {
-            RaftLog.warn(`RICServoFaultDetector: Received report msg from non-servo: ${reportMsg}`);
-            return;
-        }
-        const hexRd = reportMsg.hexRd;
-        if (!hexRd) {
-            RaftLog.warn(`RICServoFaultDetector: Received report msg with no hexRd: ${reportMsg}`);
-            return;
-        }
-        const faultByteHex = hexRd.slice(20, 22); // the fault byte is the 11th byte of the report msg
-        if (!faultByteHex || hexRd.length !== 22) { // since we are reading 11 bytes, the hexRd should be 22 characters long
-            RaftLog.warn(`RICServoFaultDetector: Received report msg with invalid hexRd: ${reportMsg}`);
-            return;
-        }
-        try {
-            return RICServoFaultDetector.decodeFault(faultByteHex);
-        } catch (e) {
-            RaftLog.warn(`RICServoFaultDetector: Received report msg with invalid fault byte: ${reportMsg}`);
-            return;
-        }
-    }
-
-    private static decodeFault(faultByteHex: string): RICServoFaultFlags {
-        const byte = parseInt(faultByteHex, 16);
-        return {
-            intermittentConnection: !!(byte & 0b0001),
-            noConnection: !!(byte & 0b0010),
-            faultyConnection: !!(byte & 0b0100),
-            servoHornPositionError: !!(byte & 0b1000)
-        };
-    }
-
-    public static isFaultBitEnabled(input: number | string): boolean {
-        let num: number;
-
-        // If input is a hexadecimal string, convert it to a decimal number
-        if (typeof input === "string") {
-            if (!input.startsWith("0x")) {
-                throw new Error("Input string must start with '0x' for hexadecimal representation");
-            }
-            num = parseInt(input, 16);
-        } else {
-            num = input;
-        }
-
-        // Check if number is an 8-bit number
-        if (num < 0 || num > 255 || !Number.isInteger(num)) {
-            throw new Error("Input is not an 8-bit number");
-        }
-
-        // Check if the 6th bit (from the right) is enabled
-        return Boolean(num & 64);
-    }
-
-
-}

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

@@ -1,97 +0,0 @@
-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 implements RaftDeviceMgrIF {
-    smartServos: ROSSerialSmartServos = new ROSSerialSmartServos();
-    smartServosValidMs = 0;
-    imuData: ROSSerialIMU = new ROSSerialIMU();
-    imuDataValidMs = 0;
-    power: ROSSerialPowerStatus = new ROSSerialPowerStatus();
-    powerValidMs = 0;
-    addOnInfo: ROSSerialAddOnStatusList = new ROSSerialAddOnStatusList();
-    addOnInfoValidMs = 0;
-    robotStatus: ROSSerialRobotStatus = new ROSSerialRobotStatus();
-    robotStatusValidMs = 0;
-    cameraData: ROSCameraData = new ROSCameraData();
-    cameraDataValidMs = 0;
-
-    updateFromROSSerialMsg(rxMsg: Uint8Array, commsStats: RICCommsStats, 
-              addOnManager: RICAddOnManager, frameTimeMs: number): Array<number> {
-        return RICROSSerial.decode(
-            rxMsg,
-            RICSERIAL_PAYLOAD_POS,
-            commsStats,
-            addOnManager,
-            this,
-            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,
-            deviceAddress: "",
-            deviceType: "",
-            busName: ""
-        };
-    }
-
-    setMaxDataPointsToStore(maxDataPointsToStore: number): void {
-        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
-    }
-
-    addNewDeviceCallback(callback: (deviceKey: string, state: DeviceState) => void): void {
-        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
-    }
-
-    removeNewDeviceCallback(callback: (deviceKey: string, state: DeviceState) => void): void {
-        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
-    }
-
-    addNewAttributeCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
-        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
-    }
-
-    removeNewAttributeCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
-        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
-    }
-
-    addAttributeDataCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void {
-        // TODO - implement if RICStateInfo is to be used as a DeviceMgr
-    }
-
-    removeAttributeDataCallback(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/RICSystemUtils.ts

@@ -1,371 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// RICJS
-// Communications Library
-//
-// Rob Dobson & Chris Greening 2020-2022
-// (C) 2020-2022
-//
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-import RaftLog from "../../../../src/RaftLog";
-import RaftMsgHandler from "../../../../src/RaftMsgHandler";
-import { RaftOKFail, RaftReportMsg } from "../../../../src/RaftTypes";
-import { RICConfiguredAddOns } from "./RICAddOn";
-import RICAddOnManager from "./RICAddOnManager";
-import { RICHWElem, RICHWElemList, RICHWElemList_Str } from "./RICHWElem";
-import { RICCalibInfo } from "./RICTypes";
-
-export default class RICSystemUtils {
-
-  // Message handler
-  private _msgHandler: RaftMsgHandler;
-
-  // Add-on manager
-  private _addOnManager: RICAddOnManager;
-
-  // HWElems (connected to RIC) - excluding AddOns
-  private _hwElemsExcludingAddOns: Array<RICHWElem> = new Array<RICHWElem>();
-  private _connectedAddOns: Array<RICHWElem> = new Array<RICHWElem>();
-
-  // Calibration info
-  private _calibInfo: RICCalibInfo | null = null;
-
-  /**
-   * constructor
-   * @param raftMsgHandler
-   * @param addOnManager
-   */
-  constructor(msgHandler: RaftMsgHandler, addOnManager: RICAddOnManager) {
-    this._msgHandler = msgHandler;
-    this._addOnManager = addOnManager;
-  }
-
-  /**
-   * invalidate
-   */
-  invalidate() {
-    // Invalidate system info
-    this._hwElemsExcludingAddOns = new Array<RICHWElem>();
-    this._connectedAddOns = new Array<RICHWElem>();
-    this._addOnManager.clear();
-    this._calibInfo = null;
-    RaftLog.debug("RICSystem information invalidated");
-  }
-
-  /**
-   *  getSystemInfo - get system info
-   * @returns Promise<RICSystemInfo>
-   *
-   */
-  async retrieveInfo(): Promise<boolean> {
-    // Get HWElems (connected to RIC)
-    try {
-      await this.getHWElemList();
-    } catch (error) {
-      RaftLog.warn("retrieveInfo - failed to get HWElems " + error);
-      return false;
-    }
-
-    // Get calibration info
-    try {
-      await this.getRICCalibInfo(true);
-    } catch (error) {
-      RaftLog.warn("retrieveInfo - failed to get calib info " + error);
-      return false;
-    }
-
-    // Get HWElems (connected to RIC)
-    try {
-      await this.getHWElemList();
-    } catch (error) {
-      RaftLog.warn("retrieveInfo - failed to get HWElems " + error);
-      return false;
-    }
-    return true;
-  }
-
-  /**
- * Get information Marty system
- *
- *  @return void
- *
- */
-  async retrieveMartySystemInfo(): Promise<boolean> {
-
-    // Retrieve system info
-    try {
-      const retrieveResult = await this.retrieveInfo();
-      return retrieveResult;
-    } catch (err) {
-      RaftLog.error(`retrieveMartySystemInfo: error ${err}`);
-    }
-    return false;
-  }
-
-  // Mark: Calibration -----------------------------------------------------------------------------------------
-
-  async calibrate(
-    cmd: string,
-    jointList: Array<string>,
-    jointNames: { [key: string]: string }
-  ) {
-    let overallResult = true;
-    if (cmd === "set") {
-      // Set calibration
-      for (const jnt of jointList) {
-        try {
-          // Set calibration on joint
-          const cmdUrl = "calibrate/set/" + jnt;
-          const rsl = await this._msgHandler.sendRICRESTURL<RaftOKFail>(
-            cmdUrl
-          );
-          // saving the calibration... (For the new servo boards it is necessary
-          // to send a "save" command after the calibration ones or any servo
-          // parameter changes in order to save any changes made into nonvolatile storage)
-          const saveCalibCmd = `elem/${jnt}/saveparams`;
-          await this._msgHandler.sendRICRESTURL<RaftOKFail>(saveCalibCmd);
-          if (rsl.rslt != "ok") overallResult = false;
-        } catch (error) {
-          console.log(`calibrate failed on joint ${jnt}`, error);
-        }
-
-        // Wait as writing to flash blocks servo access
-        // as of v0.0.113 of firmware, the pause is no longer required
-        //await new Promise(resolve => setTimeout(resolve, 3000));
-      }
-
-      // ensure all joints are enabled
-      for (const jnt in jointNames) {
-        try {
-          // enable joint
-          const cmdUrl = "servo/" + jnt + "/enable/1";
-          const rsl = await this._msgHandler.sendRICRESTURL<RaftOKFail>(
-            cmdUrl
-          );
-          if (rsl.rslt != "ok") overallResult = false;
-        } catch (error) {
-          console.log(`enable failed on joint ${jnt}`, error);
-        }
-      }
-
-      // Result
-      console.log("Set calibration flag to true");
-      const rslt = new RaftOKFail();
-      rslt.rslt = overallResult ? "ok" : "fail";
-      return rslt;
-    }
-    return false;
-  }
-
-  /**
-   *
-   * getRICCalibInfo
-   * @returns Promise<RICCalibInfo>
-   *
-   */
-  async getRICCalibInfo(forceGetFromRIC = false): Promise<RICCalibInfo> {
-    if (!forceGetFromRIC && this._calibInfo) {
-      return this._calibInfo;
-    }
-    try {
-      this._calibInfo = await this._msgHandler.sendRICRESTURL<RICCalibInfo>(
-        "calibrate"
-      );
-      RaftLog.debug("getRICCalibInfo returned " + this._calibInfo);
-      this._calibInfo.validMs = Date.now();
-      return this._calibInfo;
-    } catch (error) {
-      RaftLog.debug(`getRICCalibInfo Failed to get version ${error}`);
-      return new RICCalibInfo();
-    }
-  }
-
-  /**
-   *
-   * getHWElemList - get the list of hardware elements connected to the robot
-   *               - the result (if successful) is processed as follows:
-   *                       = if no filter is applied then all non-add-ons found are stored in
-   *                         this._hwElemsExcludingAddOns and all addons are stored in this._connectedAddOns
-   *                       = if a filter is applied and this filter is RSAddOns then this._connectedAddOns is
-   *                         updated with the new list of addons
-   *                       = in all cases the discovered list is returned
-   *
-   * @returns Promise<RICHWElemList>
-   *
-   */
-
-  async getHWElemList(filterByType?: string): Promise<Array<RICHWElem>> {
-    // Form a list of the requests to make
-    const reqList: Array<string> = [];
-    let addToNonAddOnsList = false;
-    if (!filterByType) {
-      reqList.push("SmartServo");
-      reqList.push("RSAddOn");
-      reqList.push("BusPixels");
-      reqList.push("!SmartServo,RSAddOn,BusPixels"); // not SmartServo or RSAddOn or BusPixels
-      this._hwElemsExcludingAddOns = new Array<RICHWElem>();
-      addToNonAddOnsList = true;
-    } else if (filterByType === "RSAddOn") {
-      // we treat BusPixels as an RSAddOn
-      // (batch 4 led eye add-ons have type BusPixels)
-      reqList.push("RSAddOn");
-      reqList.push("BusPixels");
-      this._connectedAddOns = new Array<RICHWElem>();
-    } else {
-      reqList.push(filterByType);
-    }
-
-    // Make the requests
-    const fullListOfElems = new Array<RICHWElem>();
-    this._connectedAddOns = [];
-    for (const reqType of reqList) {
-      try {
-        const hwElemList_Str = await this._msgHandler.sendRICRESTURL<
-          RICHWElemList_Str
-        >(`hwstatus/strstat?filterByType=${reqType}`);
-        // if the results of hwElem indicates that we are on an older fw version
-        // send the old hwstatus command and don't expand()
-        // the logic behind deciding if we are on a fw version that
-        // supports strstat is: given that hwElemList_Str.hw === object[]
-        // if we get back string[], then we know we are on an older version
-        // if hw === empty array, then we don't have any hw elems in which
-        // case we can stop at that point
-        const hwElems = hwElemList_Str.hw;
-        let hwElemList;
-        if (hwElems.length) {
-          if (typeof hwElems[0] !== "object") {
-            // we are on an older version
-            hwElemList = await this._msgHandler.sendRICRESTURL<
-              RICHWElemList
-            >(`hwstatus?filterByType=${reqType}`);
-          } else {
-            // we are on the fw version that supports strstat
-            hwElemList = RICHWElemList_Str.expand(hwElemList_Str);
-          }
-        }
-        if (hwElemList && hwElemList.rslt && hwElemList.rslt === "ok") {
-          fullListOfElems.push(...hwElemList.hw);
-          if (reqType === "RSAddOn") {
-            this._connectedAddOns = hwElemList.hw;
-            this._addOnManager.setHWElems(this._connectedAddOns);
-            // Debug
-            RaftLog.debug(
-              `getHWElemList: found ${hwElemList.hw.length} addons/buspixels`
-            );
-          } else if (reqType === "BusPixels") {
-            // BusPixels are treated as an RSAddOn
-            this._connectedAddOns.push(...hwElemList.hw);
-            this._addOnManager.setHWElems(this._connectedAddOns);
-            // Debug
-            RaftLog.debug(
-              `getHWElemList: found ${hwElemList.hw.length} addons/buspixels`
-            
-          } else if (addToNonAddOnsList) {
-            this._hwElemsExcludingAddOns.push(...hwElemList.hw);
-            // Debug
-            RaftLog.debug(
-              `getHWElemList: found ${hwElemList.hw.length} elems matching ${reqType}`
-            );
-          }
-        }
-      } catch (error) {
-        RaftLog.debug(`getHWElemList failed to get ${reqType} ${error}`);
-        return new Array<RICHWElem>();
-      }
-    }
-
-    // Handle any callbacks
-    try {
-      const reports: Array<RaftReportMsg> = [];
-      // add callback to subscribe to report messages
-      this._msgHandler.reportMsgCallbacksSet("getHWElemCB", function (
-        report: RaftReportMsg
-      ) {
-        reports.push(report);
-        RaftLog.debug(`getHWElemCB Report callback ${JSON.stringify(report)}`);
-      });
-
-      // run any required initialisation for the addons
-      const initCmds = this._addOnManager.getInitCmds();
-      // send init commands to the robot
-      const timeInitStart = Date.now();
-      for (let i = 0; i < initCmds.length; i++) {
-        this.runCommand(initCmds[i], {});
-      }
-      // wait a couple of seconds for any report messages to be received
-      await new Promise((resolve) => setTimeout(resolve, 2000));
-      // pass report messages to add on manager for processing
-      this._addOnManager.processReportMsg(reports, timeInitStart);
-
-      // clean up callback
-      this._msgHandler.reportMsgCallbacksDelete("getHWElemCB");
-    } catch (error) {
-      RaftLog.debug(`getHWElemList failed processing callback reports ${error}`);
-      return new Array<RICHWElem>();
-    }
-
-    // return the full list of elements
-    return fullListOfElems;
-  }
-
-  /**
-   *
-   * getAddOnConfigs - get list of add-ons configured on the robot
-   * @returns Promise<RICConfiguredAddOns>
-   *
-   */
-  async getAddOnConfigs(): Promise<RICConfiguredAddOns> {
-    try {
-      const addOnList = await this._msgHandler.sendRICRESTURL<
-        RICConfiguredAddOns
-      >("addon/list");
-      RaftLog.debug("getAddOnConfigs returned " + addOnList);
-      return addOnList;
-    } catch (error) {
-      RaftLog.debug(`getAddOnConfigs Failed to get list of add-ons ${error}`);
-      return new RICConfiguredAddOns();
-    }
-  }
-
-  /**
-     *
-     * runCommand
-     * @param commandName command API string
-     * @param params parameters (simple name value pairs only) to parameterize trajectory
-     * @returns Promise<RaftOKFail>
-     *
-     */
-  async runCommand(commandName: string, params: object): Promise<RaftOKFail> {
-    try {
-      // Format the paramList as query string
-      const paramEntries = Object.entries(params);
-      let paramQueryStr = "";
-      for (const param of paramEntries) {
-        if (paramQueryStr.length > 0) paramQueryStr += "&";
-        paramQueryStr += param[0] + "=" + param[1];
-      }
-      // Format the url to send
-      if (paramQueryStr.length > 0) commandName += "?" + paramQueryStr;
-      return await this._msgHandler.sendRICRESTURL<RaftOKFail>(commandName);
-    } catch (error) {
-      RaftLog.debug(`RaftSystemUtils runCommand failed ${error}`);
-      return new RaftOKFail();
-    }
-  }
-
-  getCachedAddOnList(): Array<RICHWElem> {
-    return this._connectedAddOns;
-  }
-
-  getCachedAllHWElems(): Array<RICHWElem> {
-    const allHWElems = new Array<RICHWElem>();
-    allHWElems.push(...this._connectedAddOns);
-    allHWElems.push(...this._hwElemsExcludingAddOns);
-    return allHWElems;
-  }
-
-  getCachedCalibInfo(): RICCalibInfo | null {
-    return this._calibInfo;
-  }
-}

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

@@ -1,20 +0,0 @@
-export type RICLEDPatternCheckerColour = {
-    led: string;
-    lcd: string;
-  }
-
-  export type RICLedLcdColours = Array<RICLEDPatternCheckerColour>;
-
-  export type RICServoFaultFlags = {
-    intermittentConnection: boolean,
-    noConnection: boolean,
-    faultyConnection: boolean,
-    servoHornPositionError: boolean
-  };
-
-  export class RICCalibInfo {
-    rslt = '';
-    calDone = 0;
-    validMs?= 0;
-  }
-