@kuriousdesign/machine-sdk/src/custom-types/Devices/Device.ts

Shared data types and helpers for machine-related repositories

import { DeviceTypes } from './DeviceTypes'

export interface DeviceRegistration {
  mnemonic: string; // short hand notation for the device, e.g. IB for Bufferwall, IBG for gantry
  id: number; // this device id
  childIdArray: number[]; // array of child device ids
  parentId: number; // this is the parent id
  deviceType: DeviceTypes; // type of the device
}

export const initialDeviceRegistration: DeviceRegistration = {
  mnemonic: '',
  id: 0,
  childIdArray: [],
  parentId: 0,
  deviceType: DeviceTypes.Base // Assuming Unknown exists in DeviceTypes enum
};

export interface DeviceCfg {
  safetyZoneId: number;
  controllableByHmi: boolean;
  autoReset: boolean;
  ignore: boolean;
  //ignore--OutboundAxisInterlocks: AxisInterlockCfgData[];
}

export const initialDeviceCfg: DeviceCfg = {
  safetyZoneId: 0,
  controllableByHmi: false,
  autoReset: false,
  ignore: false
};

export interface FaultData {
  DeviceId: number;
  Code: number; // this is deprecated
  Msg: string;
  AutoReset: boolean; // if this is true, the code will be reset by the fault monitor
  ResetFlag: boolean; // used by the fault monitor to know whether to clear an fault or not
  LogFlag: boolean; // when true, this fault hasn't been logged yet
  TimeStamp: Date;
  StepNum: number; // of this device
  ParentStepNum: number;
}

export const initialFaultData: FaultData = {
  DeviceId: 0,
  Code: 0,
  Msg: '',
  AutoReset: false,
  ResetFlag: false,
  LogFlag: false,
  TimeStamp: new Date(),
  StepNum: 0,
  ParentStepNum: 0
};

export interface DeviceFaultData {
  List: FaultData[]; // Array of fault data
  Present: boolean; // status
  ChildrenPresent: boolean; // status that children have errors
}

export const initialDeviceFaultData: DeviceFaultData = {
  List: [],
  Present: false,
  ChildrenPresent: false
};

export interface DeviceStatus {
  state: number; // enum for States enum, same as the boolean states in the data structure
  stepNum: number;
  stepDescription: string;
  
  colorCode: number; // color to indicate the current status for HMI purposes
  statusMsg: string; // status string
  
  error: boolean; // state, device or child has an error
  killed: boolean; // device is de-energized
  inactive: boolean; // waiting to be reset
  resetting: boolean; // taking action to be idle
  idle: boolean; // ready for auto tasks
  running: boolean; // performing an active task (excludes tasks that just involve data exchange like recipe changing)
  stopping: boolean;
  paused: boolean; // action paused mid-task, able to be resumed (finish the task) or stopped (abandon task and back to idle or inactive)
  aborting: boolean; // Aborting (Reacting TO E-Stop)
  done: boolean; // finished with task, waiting for parent to drop the request
  manual: boolean;

  idleOrError: boolean; // useful to check for stopping
  iifkm: boolean; // IdleOrInactiveOrFaultedOrKilledOrManual
  rri: boolean; // ResettingOrRunningOrIdle
  ipr: boolean; // IdleOrPausedOrRunning
  kei: boolean; // KilledErrorOrInactive
  runningOrStopping: boolean;
  
  // Children Status
  allChildrenIdle: boolean;
  allChildrenKilled: boolean;
  allChildrenInactive: boolean;
  allChildrenIdleOrError: boolean;
  
  commanderId: number; // used for external control
  
  recordingLogs: boolean;
}

export const initialDeviceStatus: DeviceStatus = {
  state: 0,
  stepNum: 0,
  stepDescription: '',
  colorCode: 0,
  statusMsg: '',
  error: false,
  killed: false,
  inactive: false,
  resetting: false,
  idle: false,
  running: false,
  stopping: false,
  paused: false,
  aborting: false,
  done: false,
  manual: false,
  idleOrError: false,
  iifkm: false,
  rri: false,
  ipr: false,
  kei: false,
  runningOrStopping: false,
  allChildrenIdle: false,
  allChildrenKilled: false,
  allChildrenInactive: false,
  allChildrenIdleOrError: false,
  commanderId: 0,
  recordingLogs: false
};

export interface Device {
  is: DeviceStatus;
  errors: DeviceFaultData;
  warnings: DeviceFaultData;
  registration: DeviceRegistration;
  cfg: DeviceCfg;
  //ignore--instants: DeviceInstants;

  //ignore--instantsexecMethod: ProcessData;
  //ignore--instantstask: ProcessData;
  //ignore--instantsprocess: ProcessData; //read-only
  //ignore--instantsscript: ProcessData; //read-only

  //ignore--instantsmission: ProcessData;
  //ignore--instantssettings: DeviceSettings;
  connectionStatus: boolean;

  //ignore--instantsrequests: Array<DeviceActionRequestData>; //this can be written to outside of the device fb;
  //ignore--instantsapiOpcua: ApiOpcuaData;
  //ignore--instantsudp: UdpData;
}

export const initialDevice: Device = {
  is: initialDeviceStatus,
  errors: initialDeviceFaultData,
  warnings: initialDeviceFaultData,
  registration: initialDeviceRegistration,
  cfg: initialDeviceCfg,
  connectionStatus: false
};