@kuriousdesign/machine-sdk 1.0.0 → 1.0.2

package/src/custom-types/Devices/Axis.ts

@@ -0,0 +1,159 @@
+export enum AxisDriveTypes {
+	STINGRAY = 0,
+	BOSCH_FSOE = 1
+}
+
+//ignored-
+export interface AxisCfg {
+    DriveType: AxisDriveTypes;
+    DriveId: number; // use either the BoschDrives enum or the Nautilus Drives enum
+    Unit: string;
+    AtPosTol: number; // note: this may already be defined in the drive (if using bosch fsoe) difference between data.actualPosition and data.targetPosition below threshold and used during validation to determine if checked position matches the stored mastering position
+
+    
+    IgnoreSoftwareLimits: boolean;
+    IgnoreLimitSwitches: boolean;
+    
+    Ignores: boolean[]; // use AxisPermissives ENUM
+    
+    SoftwareLimitPositive: number; // this is the limit that will produce an error if exceeded
+    SoftwareLimitNegative: number;
+    OperationalPositionMin: number; // this is the nominal operation minimum
+    OperationalPositionMax: number;
+    HardStopPositive: number;
+    HardStopNegative: number;
+    SensorPositions: number[];
+    //ignored-MotionProfiles: AxisMotionProfileData[]; // normal use case motion profiles, not e-stopping or error related
+    AxisType: number;
+    
+    //ignored-ValidationSensor: AxisSensors; // used for homing or position verification
+    //ignored-PositionReferencingMethod: PositionReferencingMethods; // homing or position verification
+    VerificationSensorOffsetFromZero: number;
+    SearchDistance: number; // allowed distance to search beyond operation limit to find the validation sensor
+    hasRailBrakes: boolean;
+    AutoPositionVerifyDuringReset: boolean; // set to true if you want the axis to automatically try to position verify during reset
+    hasDynamicPositiveLimit: boolean;
+    hasDynamicNegativeLimit: boolean;
+    
+    HomingToHardstopDir: number; // use -1.0 for negative and 1.0 for positive
+    MaxCurrentWhileHomingToHardstop: number; // if homing in neg direction, then use a negative value only used if using home_to_hardstop_<dir> as the position verification method.
+    MaxCurrentNormalOperation: number; // max current allowed during normal operation, ignore unless using homing to hardstop
+    
+    updateScalingIsNeeded: boolean; // set this to TRUE to enforce scaling changes
+    //ignored-SoftMotionScalingParams: SoftMotionScalingParams;
+    
+    // DUAL AXIS ONLY
+    GearingPositionTolerance: number; // mm, (dual Axis only) used for checking differences between geared axes while synced
+    AxesPositionToleranceForSkew: number; // mm, (dual Axis only) used for checking if axes have gone beyond their mechanical limit for position differences before ruining the machine
+    
+    ShippingPosition: number; // mm, this should be something that is between the hardstop positions
+    KeepMasteredStatusAtStartup: boolean; // if TRUE, this will maintain the mastered status/homed status of the axis after a power cycle
+}
+
+export interface AxisMotionProfileData {
+    speed: number; // this must be greater than zero
+    acceleration: number; // used for accel and decel
+    jerk: number;
+}
+
+
+
+export interface AxisSts {
+    Cfg: AxisCfg; // read-only
+    
+    actualPosition: number;
+    // actualSetpoint: number; // use the enum associated with setpoints
+    actualVelocity: number;
+    actualAcceleration: number;
+    ActualTorque: number;
+    ActualCurrent: number;
+    //ignored-ActualControllerMode: SMC_CONTROLLER_MODE;
+    
+    ActiveStreamType: number;
+    
+    AxisRefState: number; // uses SMC_AXIS_STATE;
+    
+    targetPosition: number; // used for MoveAbs or MoveRel, change value before issuing your mc cmd, result should be echoed in setPosition after corresponding MC Cmd
+    targetSetpoint: number;
+    targetVelocity: number; // used for jogging, change value before issuing your mc cmd, result should be echoed in setVelocity after corresponding MC Cmd
+    
+    targetDir: number; // used for jogging and moving, 1.0 for fwd and -1.0 for bckwd
+    // targetAccel: number;
+    targetMaxCurrent: number; // only used for homing to hardstop of swing arms
+    targetTorque: number; // not used
+    targetMotionProfileId: number;
+    targetMotionProfileData: AxisMotionProfileData; // used for moving and jogging, change value before issuing your mc cmd, result should be echoed in setVelocity/setAcceleration after corresponding MC Cmd
+    TargetControllerMode: number; // uses SMC_CONTROLLER_MODE;
+    
+    setPosition: number; // this value is updated by the drive
+    setVelocity: number; // this value is updated by the drive
+    setAccel: number; // this value is updated by the drive
+    setTorque: number; // this value is updated by the drive
+    setJerk: number; // this value is updated by the drive
+    
+    // STATUS BITS
+    isEnabled: boolean;
+    isHoming: boolean; // used to indicate that axis in the process of homing or used to indicate that axis is in the process of verifying its position
+    isHomed: boolean; // used to indicate that axis has homed to a sensor and updated its position accordingly or used to indicate that position has been verified, useful when using absolute encoders that don't require homing (overwriting of known zero position)
+    isMastered: boolean; // used to indicate that axis has been mastered, useful for axes that require position verification as their position referencing method
+    
+    mutingSwAndHwLimitsWhileHoming: boolean;
+    //ignored-DriveHwLimitsEnforcement: AxisLimitEnforcements; // this status is set after calling the set software limits
+    //ignored-DriveSwLimitsEnforcement: AxisLimitEnforcements;
+
+    // MOTION STATES - these are all mutually exclusive
+    isStandstill: boolean; // axis is not moving (within zero velocity threshold)
+    isAtPosAndStandstill: boolean; // axis is at the target position and at standstill
+    isJogging: boolean; // axis is rotating with velocity cmd
+    isMoving: boolean; // axis is moving to a position
+    isGeared: boolean; // axis is moving synchronously with another axis
+    isTorquing: boolean; // axis is in torque mode and actively applying torque
+    
+    // DRIVE RELATED
+    DriveStatusMsg: string;
+    DriveHasError: boolean;
+    DriveIsStoppingMotor: boolean; // is True when motor faults and starts stopping itself
+    DriveStoppedMotor: boolean; // True after motor finishes stopping itself. clears when you reset the motor
+    
+    SoftMotionHasError: boolean;
+    SoftMotionErrorId: number; // uses SMC_ERROR;
+    
+    ConfiguredSoftLimitTravelRange: number; // determined by the sw limits;
+    HomeOffsetFromZero: number; // units, this is a read-only value, the retain var HomeOffsetFromZero is used (this might be deprecated)
+    
+    CalculatedStoppingPosition: number;
+    TravelLimitNegative: number;
+    TravelLimitPositive: number;
+
+    //ignored-Permissives: AxisPermissiveStsData[]; // Array of NUM_PERMISSIVES length
+    RestrictedToSlow: boolean; // (TODO: replace this with NOT Permissives.FullSpeed_OK) used to speed limit the axis when it is not homed or has software and hardware limits disabled
+    
+    //ignored-RailBrakes: RailBrakeInputs;
+    Sensors: boolean[]; // Array of MAX_NUM_SENSORS length
+    
+    targetEncoderSetpoint: number;
+    
+    targetMasterAxisDevId: number;
+    targetMasterAxisRefPointer: any; // TypeScript doesn't have direct pointer equivalents
+    actualMasterAxisDevId: number;
+    actualMasterAxisRefPointer: any; // TypeScript doesn't have direct pointer equivalents
+    
+    RecordedPosition: number; // use this to save position information, useful for mastering and position verification processes
+    //ignored-Interlocks: AxisInterlocks;
+    
+    ignoringRailBrakes: boolean;
+    EtherCatComms_OK: boolean;
+    
+    // ROBOT CONTROLLER STATE
+    RcHomingState: number; // uses enumRcAxisHomingState;
+    RcControlMode: number; // uses enumRcAxisMode;
+
+    isStreaming: boolean;
+    
+    // DUAL AXIS ONLY
+    PositionDifference: number; // (Dual Axis Only) difference between the axes: axis1 - axis2
+    AxesPositionDifference_OK: boolean; // (Dual Axis Only)status stating difference in position between two axes while moving or idle is acceptable, based on cfg.GearingPositionTolerance
+    AxesPositionDifference_CORRECTABLE: boolean; // (Dual Axis Only)status stating difference in position between two axes able to be automatically corrected, based on cfg.AxesPositionToleranceForSkew
+    SkippingPositionCorrectionBeforeGearing: boolean; // (Dual Axis Only)this is usually TRUE if the axes are first being setup
+    DualAxisStopType: number; // uses DualAxisStopTypes; // (Dual Axis Only)
+}

package/src/custom-types/Devices/Device.ts

@@ -0,0 +1,168 @@
+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
+};

package/src/custom-types/Devices/DeviceTypes.ts

@@ -0,0 +1,7 @@
+export enum DeviceTypes {
+    Base = 0,
+    Axis = 1,
+    BoschAxis = 2, //need to deprecate this soon
+    DualAxis = 3,
+    Gantry = 4
+}

package/src/custom-types/Devices/index.ts

@@ -0,0 +1,2 @@
+export * from "./Device";
+export * from "./Axis";

package/src/custom-types/GlobalConstants.ts

@@ -0,0 +1,4 @@
+export interface GlobalConstants {
+  HIDE_LEFT_TWO_COLUMNS: boolean;
+  HIDE_RIGHT_COLUMN: boolean;
+}

package/src/custom-types/HMI.ts

@@ -0,0 +1,52 @@
+import { FaultCodeData } from "./Machine";
+import { BannerMode, Color, DeviceState, VisibilityState } from "..";
+
+
+export interface ComponentAnimation {
+  visibility: VisibilityState; //enum
+  needsExpertUser: boolean; //requires expert user to be active user in order to function
+  backgroundColor: Color; //enum
+  accentColor: Color; //enum
+  fontColor: Color; //enum
+  wasClicked: boolean; //this is set by the UI and reset by the PLC
+}
+
+export interface ButtonBar {
+  stopBtn: ComponentAnimation;
+  unloadBtn: ComponentAnimation;
+  loadBtn: ComponentAnimation;
+  unlockBtn: ComponentAnimation;
+  startBtn: ComponentAnimation;
+  lockBtn: ComponentAnimation;
+  resetBtn: ComponentAnimation;
+  jobChangeBtn: ComponentAnimation;
+  clearFaultsBtn: ComponentAnimation;
+  energizeBtn: ComponentAnimation;
+}
+
+export interface StatusBar {
+  jobName: string;
+  statusMsg: DeviceState;
+  status: number;
+  cncTimeLeft: number[]; // get the second element in the array
+  goodCnt: number;
+  batchQty: number;
+  dateAndTime: string; //format : 1970-01-01T00:00:00.000Z
+  bannerMode: BannerMode;
+  faultCodeData: FaultCodeData;
+}
+
+export interface RackHmiPbs {
+  editRawShelfBtn: ComponentAnimation;
+  editDoneShelfBtn: ComponentAnimation;
+  cancelBtn: ComponentAnimation;
+  saveBtn: ComponentAnimation;
+}
+
+export interface HmiData {
+  buttonBar: ButtonBar;
+  statusBar: StatusBar;
+  rackPbs: RackHmiPbs;
+  heartbeatPLC: number;
+  heartbeatHMI: number;
+}

package/src/custom-types/Machine.ts

@@ -0,0 +1,23 @@
+import { ComponentAnimation } from ".";
+
+export interface UserData {
+  activeUser: number;
+  hmiLoginBtn: ComponentAnimation;
+  hmiLogoutBtn: ComponentAnimation;
+}
+
+export interface FaultCodeData {
+  deviceId: number;
+  code: number;
+}
+
+export interface SystemFaultData {
+  list: FaultCodeData[];
+  present: boolean;
+}
+
+// export interface Machine {
+//   user: UserData;
+//   errors: SystemFaultData;
+//   warnings: SystemFaultData;
+// }

package/src/custom-types/PartData.ts

@@ -0,0 +1,11 @@
+import { PartState } from "../enums";
+export interface PartData {
+  cncPreOp: [PartState, PartState];
+  cnc: [PartState, PartState];
+  cncPostOp: [PartState, PartState];
+  doneShelf: PartState[];
+  rawShelf: PartState[];
+  robot: [PartState, PartState];
+  washer: [PartState, PartState];
+  hmiEditingAllowed: boolean;
+}

package/src/custom-types/RackData.ts

@@ -0,0 +1,21 @@
+import { RobPositionData } from "..";
+
+export interface ShelfPartPositionData {
+  index: number;
+  colNum: number;
+  posLetter: number;
+  offest: RobPositionData;
+}
+
+export interface RackShelfData {
+  nextPart: ShelfPartPositionData;
+  lastPart: ShelfPartPositionData;
+  isEmpty: boolean;
+  isFull: boolean;
+  isEditMode: boolean;
+}
+
+export interface RackData {
+  raw: RackShelfData;
+  done: RackShelfData;
+}

package/src/custom-types/RecipeData.ts

@@ -0,0 +1,7 @@
+export interface RecipeData {
+  partName: string;
+  extrusionType: number;
+  extrusionLength_mm: number;
+  ncProgramNumber: number;
+  partWeight_kg: number;
+}

package/src/custom-types/RecipeManagerFB.ts

@@ -0,0 +1,11 @@
+import { ComponentAnimation } from ".";
+
+export interface RecipeManagerPbs {
+    editBtn: ComponentAnimation;
+    changeBtn: ComponentAnimation;
+    jobSetupBtn: ComponentAnimation;
+    activateBtn: boolean;
+    startSetupBtn: boolean;
+    finishSetupBtn: boolean;
+    cancelBtn: boolean;
+}

package/src/custom-types/RobData.ts

@@ -0,0 +1,27 @@
+import { TaskData, RobPositions, TaskId } from "..";
+
+export interface RobData {
+  zone: RobZoneData;
+  pos: RobPositions;
+  dest: RobPositions;
+  cartesian: RobPositionData;
+  taskReq: TaskId; //incoming task request
+  taskData: TaskData;
+  recipeOffsets: RobPositionData[];
+}
+
+export interface RobPositionData {
+  x: number;
+  y: number;
+  z: number;
+  wdeg: number;
+  pdeg: number;
+  rdeg: number;
+}
+
+export interface RobZoneData {
+  cncHorzShuttle: boolean;
+  waypointShuttle: boolean; //Joint moves, wrist is holding parts upright and at a distance that allows robot to rotate about J1 without fear of collision, basically just moving J1
+  dcsNoGo: boolean;
+  outsideOfCnc: boolean;
+}

package/src/custom-types/TaskQueue.ts

@@ -0,0 +1,31 @@
+import { Priority, TaskId } from "..";
+
+export interface TaskQueue {
+  topPriority: Priority;
+  taskList: TaskId[];
+  taskCnt: number;
+  activeTaskIndex: number;
+}
+
+export interface TaskData {
+  id: number;
+  TaskString: string; //like a description
+  T: number; // time in seconds to complete task
+  TaskType: number; //Pick (state change ignored), Load (state change ignored), Move (state change ignored), Move with Process (state change used), Transform/Process (stage change used)
+
+  StartPositionId: number; //starting position required before this task is allowed
+  EndPositionId: number; //ending position after this task is finished
+  GateId: number; //robot-cnc door, for example
+
+  StationId: number; //used for transform processes
+  PartStatusStart: number[];
+  PartStatusEnd: number[];
+  PartId: number; //used for pick and load moves
+
+  OffsetUserFrameId: number; //90 Through 99, corresponds to our PRs 90-99 which correspdond to the user frame
+
+  GripperPositionId: number; //0 for left, 1 for right, 2 for both (used for moves in and out of CNC, and to from washer)
+  LeftGripperMustBeEmpty: boolean;
+
+  isCurrentlyAllowed: boolean; //set this with logic, do not configure
+}

package/src/custom-types/UserManagerFB.ts

@@ -0,0 +1,8 @@
+import { ComponentAnimation } from "./HMI";
+
+export interface UserManagerFB {
+  loginBtn: ComponentAnimation;
+  logoutBtn: ComponentAnimation;
+  username: string;
+  password: string;
+}

package/src/custom-types/index.ts

@@ -0,0 +1,13 @@
+export * from "./Com";
+export * from "./AppState";
+export * from "./HMI";
+export * from "./Devices/Device";
+export * from "./Machine";
+export * from "./RackData";
+export * from "./GlobalConstants";
+export * from "./RecipeData";
+export * from "./RecipeManagerFB";
+export * from "./UserManagerFB";
+export * from "./TaskQueue";
+export * from "./RobData";
+export * from "./Devices";

package/src/enums/Colors.ts

@@ -0,0 +1,79 @@
+export enum Color {
+  Transparent = -1,
+  //uses ROYGBIV FOR 1-7
+  Black = 0, //#000000,
+  Red = 1,
+  Orange = 2,
+  Yellow = 3, //#FFFF00,
+  Green = 4,
+  Blue = 5,
+  Indigo = 6,
+  Violet = 7,
+  Gray = 8, //#F2F2F2,
+  White = 9,
+  //Light Colors
+  LightBlack = 10,
+  LightRed = 11, //#FF6B6B
+  LightOrange = 12,
+  LightYellow = 13,
+  LightGreen = 14,
+  LightBlue = 15,
+  LightIndigo = 16,
+  LightViolet = 17,
+  LightGray = 18,
+  LightWhite = 19, //#7F7F7F,
+  //Dark Colors
+  DarkRed = 201, //#D20000
+  DarkYellow = 203, //#F0EA00
+  DarkGray = 208,
+
+  //Bg Colors
+  Light = 1001,
+  Dark = 1002,
+
+  //Action Push Button Background Colors
+  ActionBtn1 = 21, //#F7A143,
+  ActionBtn2 = 22, //#8FAADC,
+  ActionBtn3 = 23, //#FF0000, red
+  ActionBtn4 = 24,
+  ActionBtn5 = 25,
+  ActionBtn6 = 26,
+
+  //General status
+  Good = 31,
+  Warn = 32, //#FFFF00,
+  Error = 33, //#FF0000,
+
+  //Device states
+  Killed = 40,
+  Inactive = 41,
+  Resetting = 42,
+  Idle = 43, //#D9D9D9,
+  Running = 44, //#5CEE82,
+  Done = 45,
+  Aborting = 46,
+  Manual = 47,
+  Paused = 48,
+  Faulted = 49,
+  Stopping = 440,
+
+  //Task List Status
+  TaskDone = 50, //#C5E0B4,
+  TaskActive = 51, //#8FAADC,
+  TaskFuture = 52, //#D9D9D9, same as Idle
+
+  // Mfg-specific colors
+  FanucYellow = 60, //#FFFF00,
+
+  //Part Status
+  Empty = 100, //#373737,
+  Processing = 101, //#ED7D31,
+  Raw = 102, //#A6A6A6,
+  Deburred = 103, //rgba(0,112,192,0.4),
+  Machined = 104, //rgba(0,112,192,0.6),
+  Washed = 105, //rgba(0,112,192,0.8),
+  Dryed = 106, //rgba(0,112,192,1.0),
+  Scrapped = 109, //#FF0000, same as Error
+  Finished = 110, //#5CEE82, same as Running
+  DeburrBottomFinished = 111, //rgba(0,112,192,0.2),
+}

package/src/enums/DeviceId.ts

@@ -0,0 +1,10 @@
+export enum DeviceId {
+  SYS = 0,
+  CON = 1,
+  CNC = 2,
+  ROB = 3,
+  DBRR = 4,
+  SFTY = 5,
+  RACK = 6,
+  WASH = 7,
+}

package/src/enums/Errors.ts

@@ -0,0 +1,30 @@
+import { DeviceId } from "./DeviceId";
+
+export const ErrorsMap: {
+  [key in DeviceId]: {
+    [key: number]: string;
+  };
+} = {
+  [DeviceId.SFTY]: {
+    0: "NoError",
+    1: "EstopDumpValveCh1Off",
+    2: "EstopDumpValveCh2Off",
+    3: "EstopDumpValveCh1On",
+    4: "EstopDumpValveCh2On",
+    5: "FenceDumpValveCh1Off",
+    6: "FenceDumpValveCh2Off",
+    7: "FenceDumpValveCh1On",
+    8: "FenceDumpValveCh2On",
+  },
+  [DeviceId.CNC]: {},
+  [DeviceId.CON]: {},
+  [DeviceId.DBRR]: {},
+  [DeviceId.ROB]: {
+    0: "NoError",
+    1: "ControllerFault",
+    2: "RobotStartedWrongTask",
+  },
+  [DeviceId.SYS]: {},
+  [DeviceId.WASH]: {},
+  [DeviceId.RACK]: {},
+};