@kuriousdesign/machine-sdk 1.0.1 → 1.0.2

package/dist/custom-types/AppState.d.ts

@@ -1,7 +1,7 @@
 import { Page } from "../enums";
 import { ButtonBar, StatusBar } from "./HMI";
 import { PartData } from "./PartData";
-import { Device } from "./Devices/BaseDevice";
+import { Device } from "./Devices/Device";
 import { GlobalConstants } from "./GlobalConstants";
 import { RackData, RackHmiPbs, RecipeData, RecipeManagerPbs, SystemFaultData, TaskQueue, UserData, UserManagerFB, RobData } from ".";
 export declare enum NodeId {

package/dist/custom-types/Devices/Axis.d.ts

@@ -0,0 +1,104 @@
+export declare enum AxisDriveTypes {
+    STINGRAY = 0,
+    BOSCH_FSOE = 1
+}
+export interface AxisCfg {
+    DriveType: AxisDriveTypes;
+    DriveId: number;
+    Unit: string;
+    AtPosTol: number;
+    IgnoreSoftwareLimits: boolean;
+    IgnoreLimitSwitches: boolean;
+    Ignores: boolean[];
+    SoftwareLimitPositive: number;
+    SoftwareLimitNegative: number;
+    OperationalPositionMin: number;
+    OperationalPositionMax: number;
+    HardStopPositive: number;
+    HardStopNegative: number;
+    SensorPositions: number[];
+    AxisType: number;
+    VerificationSensorOffsetFromZero: number;
+    SearchDistance: number;
+    hasRailBrakes: boolean;
+    AutoPositionVerifyDuringReset: boolean;
+    hasDynamicPositiveLimit: boolean;
+    hasDynamicNegativeLimit: boolean;
+    HomingToHardstopDir: number;
+    MaxCurrentWhileHomingToHardstop: number;
+    MaxCurrentNormalOperation: number;
+    updateScalingIsNeeded: boolean;
+    GearingPositionTolerance: number;
+    AxesPositionToleranceForSkew: number;
+    ShippingPosition: number;
+    KeepMasteredStatusAtStartup: boolean;
+}
+export interface AxisMotionProfileData {
+    speed: number;
+    acceleration: number;
+    jerk: number;
+}
+export interface AxisSts {
+    Cfg: AxisCfg;
+    actualPosition: number;
+    actualVelocity: number;
+    actualAcceleration: number;
+    ActualTorque: number;
+    ActualCurrent: number;
+    ActiveStreamType: number;
+    AxisRefState: number;
+    targetPosition: number;
+    targetSetpoint: number;
+    targetVelocity: number;
+    targetDir: number;
+    targetMaxCurrent: number;
+    targetTorque: number;
+    targetMotionProfileId: number;
+    targetMotionProfileData: AxisMotionProfileData;
+    TargetControllerMode: number;
+    setPosition: number;
+    setVelocity: number;
+    setAccel: number;
+    setTorque: number;
+    setJerk: number;
+    isEnabled: boolean;
+    isHoming: boolean;
+    isHomed: boolean;
+    isMastered: boolean;
+    mutingSwAndHwLimitsWhileHoming: boolean;
+    isStandstill: boolean;
+    isAtPosAndStandstill: boolean;
+    isJogging: boolean;
+    isMoving: boolean;
+    isGeared: boolean;
+    isTorquing: boolean;
+    DriveStatusMsg: string;
+    DriveHasError: boolean;
+    DriveIsStoppingMotor: boolean;
+    DriveStoppedMotor: boolean;
+    SoftMotionHasError: boolean;
+    SoftMotionErrorId: number;
+    ConfiguredSoftLimitTravelRange: number;
+    HomeOffsetFromZero: number;
+    CalculatedStoppingPosition: number;
+    TravelLimitNegative: number;
+    TravelLimitPositive: number;
+    RestrictedToSlow: boolean;
+    Sensors: boolean[];
+    targetEncoderSetpoint: number;
+    targetMasterAxisDevId: number;
+    targetMasterAxisRefPointer: any;
+    actualMasterAxisDevId: number;
+    actualMasterAxisRefPointer: any;
+    RecordedPosition: number;
+    ignoringRailBrakes: boolean;
+    EtherCatComms_OK: boolean;
+    RcHomingState: number;
+    RcControlMode: number;
+    isStreaming: boolean;
+    PositionDifference: number;
+    AxesPositionDifference_OK: boolean;
+    AxesPositionDifference_CORRECTABLE: boolean;
+    SkippingPositionCorrectionBeforeGearing: boolean;
+    DualAxisStopType: number;
+}

package/dist/custom-types/Devices/Axis.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxisDriveTypes = void 0;
+var AxisDriveTypes;
+(function (AxisDriveTypes) {
+    AxisDriveTypes[AxisDriveTypes["STINGRAY"] = 0] = "STINGRAY";
+    AxisDriveTypes[AxisDriveTypes["BOSCH_FSOE"] = 1] = "BOSCH_FSOE";
+})(AxisDriveTypes || (exports.AxisDriveTypes = AxisDriveTypes = {}));

package/dist/custom-types/Devices/Device.d.ts

@@ -0,0 +1,74 @@
+import { DeviceTypes } from './DeviceTypes';
+export interface DeviceRegistration {
+    mnemonic: string;
+    id: number;
+    childIdArray: number[];
+    parentId: number;
+    deviceType: DeviceTypes;
+}
+export declare const initialDeviceRegistration: DeviceRegistration;
+export interface DeviceCfg {
+    safetyZoneId: number;
+    controllableByHmi: boolean;
+    autoReset: boolean;
+    ignore: boolean;
+}
+export declare const initialDeviceCfg: DeviceCfg;
+export interface FaultData {
+    DeviceId: number;
+    Code: number;
+    Msg: string;
+    AutoReset: boolean;
+    ResetFlag: boolean;
+    LogFlag: boolean;
+    TimeStamp: Date;
+    StepNum: number;
+    ParentStepNum: number;
+}
+export declare const initialFaultData: FaultData;
+export interface DeviceFaultData {
+    List: FaultData[];
+    Present: boolean;
+    ChildrenPresent: boolean;
+}
+export declare const initialDeviceFaultData: DeviceFaultData;
+export interface DeviceStatus {
+    state: number;
+    stepNum: number;
+    stepDescription: string;
+    colorCode: number;
+    statusMsg: string;
+    error: boolean;
+    killed: boolean;
+    inactive: boolean;
+    resetting: boolean;
+    idle: boolean;
+    running: boolean;
+    stopping: boolean;
+    paused: boolean;
+    aborting: boolean;
+    done: boolean;
+    manual: boolean;
+    idleOrError: boolean;
+    iifkm: boolean;
+    rri: boolean;
+    ipr: boolean;
+    kei: boolean;
+    runningOrStopping: boolean;
+    allChildrenIdle: boolean;
+    allChildrenKilled: boolean;
+    allChildrenInactive: boolean;
+    allChildrenIdleOrError: boolean;
+    commanderId: number;
+    recordingLogs: boolean;
+}
+export declare const initialDeviceStatus: DeviceStatus;
+export interface Device {
+    is: DeviceStatus;
+    errors: DeviceFaultData;
+    warnings: DeviceFaultData;
+    registration: DeviceRegistration;
+    cfg: DeviceCfg;
+    connectionStatus: boolean;
+}
+export declare const initialDevice: Device;

package/dist/custom-types/Devices/Device.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialDevice = exports.initialDeviceStatus = exports.initialDeviceFaultData = exports.initialFaultData = exports.initialDeviceCfg = exports.initialDeviceRegistration = void 0;
+const DeviceTypes_1 = require("./DeviceTypes");
+exports.initialDeviceRegistration = {
+    mnemonic: '',
+    id: 0,
+    childIdArray: [],
+    parentId: 0,
+    deviceType: DeviceTypes_1.DeviceTypes.Base // Assuming Unknown exists in DeviceTypes enum
+};
+exports.initialDeviceCfg = {
+    safetyZoneId: 0,
+    controllableByHmi: false,
+    autoReset: false,
+    ignore: false
+};
+exports.initialFaultData = {
+    DeviceId: 0,
+    Code: 0,
+    Msg: '',
+    AutoReset: false,
+    ResetFlag: false,
+    LogFlag: false,
+    TimeStamp: new Date(),
+    StepNum: 0,
+    ParentStepNum: 0
+};
+exports.initialDeviceFaultData = {
+    List: [],
+    Present: false,
+    ChildrenPresent: false
+};
+exports.initialDeviceStatus = {
+    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
+};
+exports.initialDevice = {
+    is: exports.initialDeviceStatus,
+    errors: exports.initialDeviceFaultData,
+    warnings: exports.initialDeviceFaultData,
+    registration: exports.initialDeviceRegistration,
+    cfg: exports.initialDeviceCfg,
+    connectionStatus: false
+};

package/dist/custom-types/Devices/deviceTypes.d.ts

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

package/dist/custom-types/Devices/deviceTypes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceTypes = void 0;
+var DeviceTypes;
+(function (DeviceTypes) {
+    DeviceTypes[DeviceTypes["Base"] = 0] = "Base";
+    DeviceTypes[DeviceTypes["Axis"] = 1] = "Axis";
+    DeviceTypes[DeviceTypes["BoschAxis"] = 2] = "BoschAxis";
+    DeviceTypes[DeviceTypes["DualAxis"] = 3] = "DualAxis";
+    DeviceTypes[DeviceTypes["Gantry"] = 4] = "Gantry";
+})(DeviceTypes || (exports.DeviceTypes = DeviceTypes = {}));

package/dist/custom-types/Devices/index.d.ts

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

package/dist/custom-types/Devices/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Device"), exports);
+__exportStar(require("./Axis"), exports);

package/dist/custom-types/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./Com";
 export * from "./AppState";
 export * from "./HMI";
-export * from "./Devices/BaseDevice";
+export * from "./Devices/Device";
 export * from "./Machine";
 export * from "./RackData";
 export * from "./GlobalConstants";
@@ -10,3 +10,4 @@ export * from "./RecipeManagerFB";
 export * from "./UserManagerFB";
 export * from "./TaskQueue";
 export * from "./RobData";
+export * from "./Devices";

package/dist/custom-types/index.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Com"), exports);
 __exportStar(require("./AppState"), exports);
 __exportStar(require("./HMI"), exports);
-__exportStar(require("./Devices/BaseDevice"), exports);
+__exportStar(require("./Devices/Device"), exports);
 __exportStar(require("./Machine"), exports);
 __exportStar(require("./RackData"), exports);
 __exportStar(require("./GlobalConstants"), exports);
@@ -26,3 +26,4 @@ __exportStar(require("./RecipeManagerFB"), exports);
 __exportStar(require("./UserManagerFB"), exports);
 __exportStar(require("./TaskQueue"), exports);
 __exportStar(require("./RobData"), exports);
+__exportStar(require("./Devices"), exports);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./custom-types";
 export * from "./enums";
 export * from "./functions";
+export * from "./plc-tags";

package/dist/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./custom-types"), exports);
 __exportStar(require("./enums"), exports);
 __exportStar(require("./functions"), exports);
+__exportStar(require("./plc-tags"), exports);

package/dist/plc-tags/index.d.ts

@@ -0,0 +1,19 @@
+export declare const PlcNamespaces: {
+    Machine: string;
+    MachineHw: string;
+    Main: string;
+};
+export declare const MachineTags: {
+    deviceStore: string;
+    registeredDevices: string;
+    axisStsArray: string;
+    HeartbeatPLC: string;
+    HeartbeatHMI: string;
+};
+export declare const DeviceTags: {
+    Cfg: string;
+    Is: string;
+    Registration: string;
+};
+export * from "./opcua";
+export * from "./mqtt";

package/dist/plc-tags/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceTags = exports.MachineTags = exports.PlcNamespaces = void 0;
+exports.PlcNamespaces = {
+    Machine: 'Machine',
+    MachineHw: 'MachineHw',
+    Main: 'Main'
+};
+exports.MachineTags = {
+    deviceStore: 'Devices',
+    //deviceTypeStore: 'DeviceTypes',
+    registeredDevices: 'RegisteredDevices',
+    axisStsArray: 'AxisStsArray',
+    HeartbeatPLC: 'HeartbeatPLC',
+    HeartbeatHMI: 'HeartbeatHMI'
+};
+exports.DeviceTags = {
+    Cfg: 'Cfg',
+    Is: 'Is',
+    Registration: 'Registration',
+};
+__exportStar(require("./opcua"), exports);
+__exportStar(require("./mqtt"), exports);

package/dist/plc-tags/mqtt.d.ts

@@ -0,0 +1,7 @@
+export interface TopicData {
+    timestamp: number;
+    payload: unknown;
+}
+export declare const MqttTopics: {
+    readonly BRIDGE_STATUS: "bridge/status";
+};

package/dist/plc-tags/mqtt.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MqttTopics = void 0;
+exports.MqttTopics = {
+    BRIDGE_STATUS: 'bridge/status',
+};

package/dist/plc-tags/opcua.d.ts

@@ -0,0 +1,2 @@
+export declare const nodeListString = "ns=4;s=|var|";
+export declare const nodeTypeString = "ns=4;s=|type|";

package/dist/plc-tags/opcua.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeTypeString = exports.nodeListString = void 0;
+exports.nodeListString = "ns=4;s=|var|";
+exports.nodeTypeString = "ns=4;s=|type|";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuriousdesign/machine-sdk",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Shared data types and helpers for machine-related repositories",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/custom-types/AppState.ts

@@ -1,7 +1,7 @@
 import { PartState, Page } from "../enums";
 import { ButtonBar, StatusBar } from "./HMI";
 import { PartData } from "./PartData";
-import { Device } from "./Devices/BaseDevice";
+import { Device } from "./Devices/Device";
 import { GlobalConstants } from "./GlobalConstants";
 import {
   RackData,

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/index.ts

@@ -1,7 +1,7 @@
 export * from "./Com";
 export * from "./AppState";
 export * from "./HMI";
-export * from "./Devices/BaseDevice";
+export * from "./Devices/Device";
 export * from "./Machine";
 export * from "./RackData";
 export * from "./GlobalConstants";
@@ -10,3 +10,4 @@ export * from "./RecipeManagerFB";
 export * from "./UserManagerFB";
 export * from "./TaskQueue";
 export * from "./RobData";
+export * from "./Devices";

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from "./custom-types";
 export * from "./enums";
 export * from "./functions";
+export * from "./plc-tags";

package/src/plc-tags/index.ts

@@ -0,0 +1,24 @@
+export const PlcNamespaces = {
+    Machine: 'Machine',
+    MachineHw: 'MachineHw',
+    Main: 'Main'
+}
+
+export const MachineTags = {
+    deviceStore: 'Devices',
+    //deviceTypeStore: 'DeviceTypes',
+    registeredDevices: 'RegisteredDevices',
+    axisStsArray: 'AxisStsArray',
+    HeartbeatPLC: 'HeartbeatPLC',
+    HeartbeatHMI: 'HeartbeatHMI'
+}
+
+export const DeviceTags = {
+    Cfg: 'Cfg',
+    Is: 'Is',
+    Registration: 'Registration',
+}
+
+
+export * from "./opcua";
+export * from "./mqtt";

package/src/plc-tags/mqtt.ts

@@ -0,0 +1,8 @@
+export interface TopicData {
+    timestamp: number;
+    payload: unknown; // Placeholder until cfg, status, data schemas provided
+}
+
+export const MqttTopics = {
+    BRIDGE_STATUS: 'bridge/status',
+} as const;

package/src/plc-tags/opcua.ts

@@ -0,0 +1,3 @@
+export const nodeListString = "ns=4;s=|var|";
+export const nodeTypeString = "ns=4;s=|type|";
+

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

@@ -1,41 +0,0 @@
-export interface DeviceCfg {
-  mnemonic: string; //short hand notation for the device, e.g. ROB for Robot
-  id: number; //calculation using ChildId and Parent Id, where Id = (100*ParentId + LocalId)
-  childId: number;
-  parentId: number;
-}
-
-export interface DeviceFaultData {
-  list: number[];
-  present: boolean; //status
-}
-
-export interface DeviceInputs {
-  instantKill_ON: boolean
-}
-
-export interface DeviceParentCmds {
-  reset: boolean;
-  stop: boolean;
-  clearFlts: boolean;
-  start: boolean;
-  abort: boolean;
-  kill: boolean;
-}
-
-export interface DeviceStatus {
-  state: number;
-  //Faulted: BOOL;
-  //HasWarnings: BOOL;
-  stepNum: number;
-  colorCode: number; //color to indicate the current status
-}
-
-export interface Device {
-  cfg: DeviceCfg;
-  is: DeviceStatus;
-  cmds: DeviceParentCmds;
-  errors: DeviceFaultData;
-  warnings: DeviceFaultData;
-  i: DeviceInputs;
-}