diff --git a/index.html b/index.html index e290c0da..f51eeebe 100644 --- a/index.html +++ b/index.html @@ -1,9 +1,9 @@ - + -

Go to the default documentation.

+

Go to the default documentation.

\ No newline at end of file diff --git a/v4.0.3/.buildinfo b/v4.0.3/.buildinfo new file mode 100644 index 00000000..9735f882 --- /dev/null +++ b/v4.0.3/.buildinfo @@ -0,0 +1,4 @@ +# Sphinx build info version 1 +# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. +config: 98960dbf1d8d39311afc995efcaacdf8 +tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/v4.0.3/.nojekyll b/v4.0.3/.nojekyll new file mode 100644 index 00000000..e69de29b diff --git a/v4.0.3/_sources/index.rst.txt b/v4.0.3/_sources/index.rst.txt new file mode 100644 index 00000000..b5fa1fca --- /dev/null +++ b/v4.0.3/_sources/index.rst.txt @@ -0,0 +1,30 @@ +lcls-twincat-motion +------------------- + +.. toctree:: + :maxdepth: 2 + :caption: lcls-twincat-motion + + lcls-twincat-motion_pragmas + lcls-twincat-motion_nc + lcls-twincat-motion_ethercat + lcls-twincat-motion_boxes + lcls-twincat-motion_links + + +.. toctree:: + :maxdepth: 2 + :caption: Library + + lcls-twincat-motion_Library_summary + lcls-twincat-motion_Library_epics + lcls-twincat-motion_Library_source + + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` \ No newline at end of file diff --git a/v4.0.3/_sources/lcls-twincat-motion_Library_epics.rst.txt b/v4.0.3/_sources/lcls-twincat-motion_Library_epics.rst.txt new file mode 100644 index 00000000..f3899846 --- /dev/null +++ b/v4.0.3/_sources/lcls-twincat-motion_Library_epics.rst.txt @@ -0,0 +1,10 @@ + +Data Types +---------- + + + +Database Records +---------------- + +No records defined. diff --git a/v4.0.3/_sources/lcls-twincat-motion_Library_source.rst.txt b/v4.0.3/_sources/lcls-twincat-motion_Library_source.rst.txt new file mode 100644 index 00000000..015ebc0d --- /dev/null +++ b/v4.0.3/_sources/lcls-twincat-motion_Library_source.rst.txt @@ -0,0 +1,17782 @@ + + +DUTs +---- + + +DUT_AxisStatus_v0_01 +^^^^^^^^^^^^^^^^^^^^ + +:: + + TYPE DUT_AxisStatus_v0_01 : + STRUCT + bEnable: BOOL; + bReset: BOOL; + bExecute: BOOL; + nCommand: UINT; + nCmdData: UINT; + fVelocity: LREAL; + fPosition: LREAL; + fAcceleration: LREAL; + fDeceleration: LREAL; + bJogFwd: BOOL; + bJogBwd: BOOL; + bLimitFwd: BOOL; + bLimitBwd: BOOL; + fOverride: LREAL := 100; + bHomeSensor: BOOL; + bEnabled: BOOL; + bError: BOOL; + nErrorId: UDINT; + fActVelocity: LREAL; + fActPosition: LREAL; + fActDiff: LREAL; + bHomed:BOOL; + bBusy:BOOL; + END_STRUCT + END_TYPE + + +Related: + * `DUT_AxisStatus_v0_01`_ + + +DUT_ErrorState +^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + TYPE DUT_ErrorState : + ( + None, + Active, + Inactive, + Acknowledged + ); + END_TYPE + + + + +DUT_MotionPneumaticActuator +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'DUT_MotionPneumaticActuator has been renamed to ST_MotionPneumaticActuator'} + TYPE DUT_MotionPneumaticActuator : ST_MotionPneumaticActuator; END_TYPE + + +Related: + * `ST_MotionPneumaticActuator`_ + + +DUT_MotionStage +^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'DUT_MotionStage has been renamed to ST_MotionStage'} + TYPE DUT_MotionStage : ST_MotionStage; END_TYPE + + +Related: + * `ST_MotionStage`_ + + +DUT_PositionState +^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'DUT_PositionState has been renamed to ST_PositionState'} + TYPE DUT_PositionState : ST_PositionState; END_TYPE + + +Related: + * `ST_PositionState`_ + + +DUT_TerminalError +^^^^^^^^^^^^^^^^^ + +:: + + TYPE DUT_TerminalError : + STRUCT + //Error system related + iTerminalID : INT; //ID of the terminal + Error_ID : ULINT := 0; //ID for the Error entry + ErrorState : DUT_ErrorState; //State of the error + + //Error related + nDateTimeOn : ULINT; //Date and time when the error occured. Raw data + sDateTimeOn : STRING(24); //Date and time when the error occured. Readable format + nDateTimeOff : ULINT; //Date and time when the error disapeared. Raw data + sDateTimeOff : STRING(24); //Date and time when the error disapeared. Readable format + bWcState : BOOL; //WcState variable of the terminal + uiInfoDataState : UINT; //InfoData.State variable of the terminal + sErrorMessage : STRING (128); //Error message corresponding to WcState and InfoData.State + ErrorType : INT; //Error types (priorities) need to be developed + END_STRUCT + END_TYPE + + +Related: + * `DUT_ErrorState`_ + + +dutEL2521_Ctrl +^^^^^^^^^^^^^^ + +:: + + TYPE dutEL2521_Ctrl : + STRUCT + ///The control word (CW) is located in the output process image, and is transmitted from the controller to the terminal. + ///CW.0 FREQ_SEL 0bin / 1bin Rapid change of the base frequency (only if the ramp function is inactive): + ///0bin = Base frequency 1 (object 8001:02) + ///1bin = Base frequency 2 (object 8001:03) + FREQ_SEL: BOOL; + ///CW.1 RAMP_DIS 1bin Operation of the ramp function is cancelled, in spite of object 8000:06 being active; if travel distance control is active, it is interrupted by this bit + RAMP_DIS: BOOL; + ///CW.2 GO_COUNTER 1bin If travel distance control is active (object 8000:0A), then a pre-set counter value is approached when the bit is set + GO_COUNTER: BOOL; + ///CW.5 CNT_CLR 1bin The contents of the counter is cleared or set (object 8000:0B) by this bit. + ///Any overflow or underflow bits that might be set are also cleared by this bit. + ///The process can be edge triggered or level triggered (object 8000:05). + CNT_CLR: BOOL; + END_STRUCT + END_TYPE + + + + +dutEL2521_Status +^^^^^^^^^^^^^^^^ + +:: + + TYPE dutEL2521_Status : + STRUCT + ///The status word (SW) is located in the input process image, and is transmitted from the terminal to the controller. + ///SW.0 SEL_ACK/END_COUNTER 1bin Confirms the change of base frequency. At activated travel distance control: target counter value reached + SEL_ACK: BOOL; + ///SW.1 RAMP_ACTIVE 1bin Ramp is currently being followed + RAMP_ACTIVE: BOOL; + ///SW.2 UNDERFLOW 1bin This bit is set if the 16-bit counter underflows (0 -> 65535). It is reset when the counter drops below two thirds of its measuring range (43690 -> 43689) or immediately an overflow occurs. + UNDERFLOW: BOOL; + ///SW.3 OVERFLOW 1bin This bit is set if the 16-bit counter overflows (65535 -> 0). It is reset when the counter exceeds one third of its measuring range (21845 -> 21846) or immediately an underflow occurs + OVERFLOW: BOOL; + ///SW.4 INPUT_T 1bin Status of INPUT_T + INPUT_T: BOOL; + ///SW.5 INPUT_Z 1bin Status of INPUT_Z + INPUT_Z: BOOL; + ///SW.6 ERROR 1bin General error bit, included with overflow/underflow + ERROR: BOOL; + END_STRUCT + END_TYPE + + + + +E_EpicsHomeCmd +^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + TYPE E_EpicsHomeCmd : + // Defines the valid options for homing in FB_MotionStage + ( + LOW_LIMIT := 1, // Low limit switch + HIGH_LIMIT := 2, // High limit switch + HOME_VIA_LOW := 3, // Home switch via low switch + HOME_VIA_HIGH := 4, // Home switch via high switch + ABSOLUTE_SET := 15, // Set here to be fHomePosition + NONE := -1 // Do not home, ever + ); + END_TYPE + + +Related: + * `FB_MotionStage`_ + + +E_EpicsInOut +^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + // Example EPICS states enum for use in all versions of the states FBs + // Remove strict attribute for easier handling + TYPE E_EpicsInOut : + ( + UNKNOWN := 0, // UNKNOWN must be in slot 0 or the FB breaks + OUT := 1, // OUT at slot 1 is a convention + IN := 2 + ) UINT; + END_TYPE + + + + +E_EpicsMotorCmd +^^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + TYPE E_EpicsMotorCmd : + // Defines valid EPICS commands for nCommand + ( + JOG := 0, + MOVE_VELOCITY := 1, + MOVE_RELATIVE := 2, + MOVE_ABSOLUTE := 3, + MOVE_MODULO := 4, + HOME := 10, + GEAR := 30 + ); + END_TYPE + + + + +E_MotionFFType +^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + TYPE E_MotionFFType : + ( + STOPPER_FAULT := 16#1000, + ZERO_RATE := 16#1001, + BPTM_TIMEOUT := 16#1002, + BPTM_ERROR := 16#1003, + MAINT_MODE := 16#1004, + NOT_A_STATE := 16#1005, + INVALID_GOAL := 16#1006, + TOO_MANY_TRIPS := 16#1007, + BP_MISMATCH := 16#1008, + INTERNAL_ERROR := 16#1009, + PNEUMATIC_MOVE := 16#1010, + MOT_GENERIC := 16#1011, + LOW_RESERVED_NC := 16#2000, + HIGH_RESERVED_NC := 16#20FF, + DEVICE_MOVE := 16#2100 + ) UINT := MOT_GENERIC; + END_TYPE + + + + +E_MotionRequest +^^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + TYPE E_MotionRequest : + // Defines behavior options for when FB_MotionRequest is run during an active move from another source + ( + WAIT := 0, + INTERRUPT := 1, + ABORT := 2 + ); + END_TYPE + + +Related: + * `FB_MotionRequest`_ + + +E_PnuematicActuatorPositionState +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + // Defines the positions for a pnuematic actuator + TYPE E_PnuematicActuatorPositionState : + ( + RETRACTED := 0, // Out limit switch is active + INSERTED := 1, // In limit switch is active + MOVING := 2, // Neither limit switches is Active + INVALID :=3 // Invalid state + ); + END_TYPE + + + + +E_StageBrakeMode +^^^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + TYPE E_StageBrakeMode : + // Defines when to send the brake disengage signal in FB_MotionStage + ( + IF_ENABLED, // Disengage brake when the motor is enabled + IF_MOVING, // Disengage brake when the motor is moving + NO_BRAKE // Do not change the brake state in FB_MotionStage + ); + END_TYPE + + +Related: + * `FB_MotionStage`_ + + +E_StageEnableMode +^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + TYPE E_StageEnableMode : + // Define conditions when FB_MotionStage automatically sets bEnable + ( + ALWAYS, // Always set bEnable to TRUE + NEVER, // Only change bEnable on errors + DURING_MOTION // Enable before motion, disable after motion + ); + END_TYPE + + +Related: + * `FB_MotionStage`_ + + +E_StatePMPSStatus +^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + TYPE E_StatePMPSStatus : + ( + // No other enum state describes it + UNKNOWN := 0, + // Moving toward a known state + TRANSITION := 1, + // Within a known state, not trying to leave + AT_STATE := 2, + // PMPS is in some way disabled, either with maint mode or arbiter disable + DISABLED := 3 + ); + END_TYPE + + + + +E_TestStates +^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + TYPE E_TestStates : + ( + Unknown := 0, + OUT := 1, + TARGET1 := 2, + TARGET2 := 3 + ) UINT; + END_TYPE + + + + +EL5042_Status +^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'EL5042_Status has been renamed to ST_EL5042_Status'} + TYPE EL5042_Status : ST_EL5042_Status; END_TYPE + + +Related: + * `ST_EL5042_Status`_ + + +ENUM_EpicsHomeCmd +^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use E_EpicsHomeCmd'} + TYPE ENUM_EpicsHomeCmd : E_EpicsHomeCmd; END_TYPE + + +Related: + * `E_EpicsHomeCmd`_ + + +ENUM_EpicsInOut +^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use E_EpicsInOut'} + TYPE ENUM_EpicsInOut : E_EpicsInOut; END_TYPE + + +Related: + * `E_EpicsInOut`_ + + +ENUM_EpicsInOut_INT +^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use ENUM_EpicsInOut'} + {attribute 'qualified_only'} + // Example EPICS states enum for use in all versions of the states FBs + // Remove strict attribute for easier handling + TYPE ENUM_EpicsInOut_INT : + ( + UNKNOWN := 0, // UNKNOWN must be in slot 0 or the FB breaks + OUT := 1, // OUT at slot 1 is a convention + IN := 2 + ) INT; + END_TYPE + + +Related: + * `ENUM_EpicsInOut`_ + + +ENUM_EpicsMotorCmd +^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use E_EpicsMotorCmd'} + TYPE ENUM_EpicsMotorCmd : E_EpicsMotorCmd; END_TYPE + + +Related: + * `E_EpicsMotorCmd`_ + + +ENUM_MotionFFType +^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use E_MotionFFType'} + TYPE ENUM_MotionFFType : E_MotionFFType; END_TYPE + + +Related: + * `E_MotionFFType`_ + + +ENUM_MotionRequest +^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use E_MotionRequest'} + TYPE ENUM_MotionRequest : E_MotionRequest; END_TYPE + + +Related: + * `E_MotionRequest`_ + + +ENUM_PnuematicActuatorPositionState +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use E_PnuematicActuatorPositionState'} + TYPE ENUM_PnuematicActuatorPositionState : E_PnuematicActuatorPositionState; END_TYPE + + +Related: + * `E_PnuematicActuatorPositionState`_ + + +ENUM_StageBrakeMode +^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use E_StageBrakeMode'} + TYPE ENUM_StageBrakeMode : E_StageBrakeMode; END_TYPE + + +Related: + * `E_StageBrakeMode`_ + + +ENUM_StageEnableMode +^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use E_StageEnableMode'} + TYPE ENUM_StageEnableMode : E_StageEnableMode; END_TYPE + + +Related: + * `E_StageEnableMode`_ + + +ENUM_StatePMPSStatus +^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use E_StatePMPSStatus'} + TYPE ENUM_StatePMPSStatus : E_StatePMPSStatus; END_TYPE + + +Related: + * `E_StatePMPSStatus`_ + + +ST_EL5042_Status +^^^^^^^^^^^^^^^^ + +:: + + TYPE ST_EL5042_Status : + STRUCT + END_STRUCT + END_TYPE + + + + +ST_ErrorSystem +^^^^^^^^^^^^^^ + +:: + + TYPE ST_ErrorSystem : + STRUCT + //Array of error data. Size = cSizeOfErrorData in the GVL + aErrorData : ARRAY [0..GVL_ErrorSystem.cSizeOfErrorData - 1] OF DUT_TerminalError; + lNextErrorID : ULINT := 1; //ErrorID for the next error entry + nNoErrors : UINT; //Number of errors in the list + nNoOverflows : INT := 0; //Number of overflows. How many error entries have been lost + END_STRUCT + END_TYPE + + +Related: + * `DUT_TerminalError`_ + * `GVL`_ + * `GVL_ErrorSystem`_ + + +ST_MotionPneumaticActuator +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + {attribute 'strict'} + TYPE ST_MotionPneumaticActuator : + // Defines the EPICS interface to actuating a pneumatic stage + STRUCT + (* Hardware *) + //Readbacks + //Limit Switch + {attribute 'pytmc' := ' + pv: PLC:bInLimitSwitch + io: i + field: ZNAM FALSE + field: ONAM TRUE + field: DESC TRUE if IN limit is reached + '} + i_bInLimitSwitch : BOOL; + {attribute 'pytmc' := ' + pv: PLC:bOutLimitSwitch + io: i + field: ZNAM FALSE + field: ONAM TRUE + field: DESC TRUE if OUT limit is reached + '} + i_bOutLimitSwitch : BOOL; + //Controls + //Digital outputs + {attribute 'pytmc' := ' + pv: bRetractDigitalOutput; + io: i; + field: ONAM FALSE + field: ZNAM TRUE + field: DESC TRUE if Retract digital output is active + '} + q_bRetract : BOOL; + {attribute 'pytmc' := ' + pv: bInsertDigitalOutput; + io: i; + field: ONAM FALSE + field: ZNAM TRUE + field: DESC TRUE if Insert digital output is active + '} + q_bInsert : BOOL; + + + //Logic and supervisory + {attribute 'pytmc' := ' + pv: bInterlockOK; + io: i; + field: ZNAM FALSE + field: ONAM TRUE + field: DESC True if the actuator has permission to move in either direction + '} + bILK_OK: BOOL; + {attribute 'pytmc' := ' + pv: bInsertEnable; + io: i; + field: ZNAM FALSE + field: ONAM TRUE + field: DESC True if the actuator had permission to be retracted + '} + bInsertOK : BOOL; + {attribute 'pytmc' := ' + pv: bRetractEnable; + io: i; + field: ZNAM FALSE + field: ONAM TRUE + field: DESC True if the actuator had permission to be inserted + '} + bRetractOK : BOOL; + + (* Commands *) + // Used from Epics to comand the actuator to move + {attribute 'pytmc' := ' + pv: CMD:IN; + io: io; + field: DESC Used by EPICS and internally to request Insert motion + '} + bInsert_SW : BOOL; + {attribute 'pytmc' := ' + pv: CMD:OUT; + io: io; + field: DESC Used by EPICS and internally to request retract motion + '} + bRetract_SW : BOOL; + + (*Returns*) + // TRUE if in the middle of a command + {attribute 'pytmc' := ' + pv: bBusy + io: i + field: ONAM FALSE + field: ZNAM TRUE + field: DESC TRUE if in the middle of a command + '} + bBusy: BOOL; + // TRUE if we've done a command and it has finished + {attribute 'pytmc' := ' + pv: bDone + io: i + field: ONAM FALSE + field: ZNAM TRUE + field: DESC TRUE if command finished successfully + '} + bDone: BOOL; + {attribute 'pytmc' := ' + pv: bReset + io: io + field: ZNAM FALSE + field: ONAM TRUE + field: DESC Used internally to reset errors + '} + bReset: BOOL; + // TRUE if we're in an error state + {attribute 'pytmc' := ' + pv: PLC:bError + io: i + field: ONAM FALSE + field: ZNAM TRUE + field: DESC TRUE if we're in an error state + '} + bError: BOOL; + + // Error code if nonzero + {attribute 'pytmc' := ' + pv: PLC:nErrorId + io: i + field: DESC Error code if nonzero + '} + nErrorId: UDINT; + // Message to identify the error state + {attribute 'pytmc' := ' + pv: PLC:sErrorMessage + io: i + field: DESC Message to identify the error state + '} + sErrorMessage: STRING; + {attribute 'pytmc' := ' + pv: nPositionState ; + type: mbbi ; + field: ZRST RETRACTED ; + field: ONST INSERTED ; + field: TWST MOVING ; + field: THST INVALID ; + io: i + field: DESC Pneumatic actuator position + '} + + eState : E_PnuematicActuatorPositionState := E_PnuematicActuatorPositionState.INVALID; + + END_STRUCT + END_TYPE + + +Related: + * `E_PnuematicActuatorPositionState`_ + + +ST_MotionStage +^^^^^^^^^^^^^^ + +:: + + TYPE ST_MotionStage : + // Defines the EPICS interface to moving a motor in TwinCAT + STRUCT + (* Hardware *) + + // PLC Axis Reference + Axis: AXIS_REF; + // NC Forward Limit Switch: TRUE if ok to move + bLimitForwardEnable AT %I*: BOOL; + // NC Backward Limit Switch: TRUE if ok to move + bLimitBackwardEnable AT %I*: BOOL; + // NO Home Switch: TRUE if at home + bHome AT %I*: BOOL; + // NC Brake Output: TRUE to release brake + bBrakeRelease AT %Q*: BOOL; + // NC STO Input: TRUE if ok to move + {attribute 'pytmc' := ' + pv: PLC:bHardwareEnable + io: i + field: ZNAM FALSE + field: ONAM TRUE + field: DESC TRUE if STO not hit + '} + bHardwareEnable AT %I*: BOOL; + + // Raw encoder IO for ULINT (Biss-C) + nRawEncoderULINT AT %I*: ULINT; + // Raw encoder IO for UINT (Relative Encoders) + nRawEncoderUINT AT %I*: UINT; + // Raw encoder IO for INT (LVDT) + nRawEncoderINT AT %I*: INT; + + (* Psuedo-hardware *) + + // Forward enable EPS summary + bAllForwardEnable: BOOL:=FALSE; + // Backward enable EPS summary + bAllBackwardEnable: BOOL:=FALSE; + // Enable EPS summary encapsulating emergency stop button and any additional motion preventive hardware + bAllEnable: BOOL:=FALSE; + // Forward virtual gantry limit switch + bGantryForwardEnable: BOOL:=FALSE; + // Backward virtual gantry limit switch + bGantryBackwardEnable: BOOL:=FALSE; + // Encoder count summary, if linked above + {attribute 'pytmc' := ' + pv: PLC:nEncoderCount + io: i + field: DESC Count from encoder hardware + '} + nEncoderCount: UDINT; + // Forward Enable EPS struct + {attribute 'pytmc' := ' + pv: PLC:stEPSF + io: i + field: DESC Forward Enable Interlocks + '} + stEPSForwardEnable: DUT_EPS; + // Backward Enable EPS struct + {attribute 'pytmc' := ' + pv: PLC:stEPSB + io: i + field: DESC Backward Enable Interlocks + '} + stEPSBackwardEnable: DUT_EPS; + // Power Enable EPS struct + {attribute 'pytmc' := ' + pv: PLC:stEPSP + io: i + field: DESC Power Interlocks + '} + stEPSPowerEnable: DUT_EPS; + + (* Settings *) + // Name to use for log messages, fast faults, etc. + sName: STRING; + // If TRUE, we want to enable the motor independently of PMPS or other safety systems. + bPowerSelf: BOOL:=FALSE; + // Determines when we automatically enable the motor + nEnableMode: E_StageEnableMode:=E_StageEnableMode.DURING_MOTION; + // Determines when we automatically disengage the brake + nBrakeMode: E_StageBrakeMode:=E_StageBrakeMode.IF_ENABLED; + // Determines our encoder homing strategy + nHomingMode: E_EpicsHomeCmd:=E_EpicsHomeCmd.NONE; + // Set true to activate gantry EPS + bGantryAxis: BOOL:=FALSE; + + // Set to gantry difference tolerance + nGantryTol: LINT:=0; + + // Encoder count at which this axis is aligned with other axis + nEncRef: ULINT:=0; + + (* Commands *) + // Used internally to request enables + bEnable: BOOL; + // Used internally to reset errors and other state + {attribute 'pytmc' := ' + pv: PLC:bReset + io: io + field: ZNAM FALSE + field: ONAM TRUE + field: DESC Used internally to reset errors + '} + bReset: BOOL; + // Used internally and by the IOC to start or stop a move + bExecute: BOOL; + // Used by the IOC to disable an axis + {attribute 'pytmc' := ' + pv: PLC:bUserEnable + io: io + field: ZNAM DISABLE + field: ONAM ENABLE + field: DESC Used to disable power entirely for an axis + '} + bUserEnable: BOOL := 1; + + (* Shortcut Commands *) + // Start a move to fPosition with fVelocity + bMoveCmd: BOOL; + // Start the homing routine + {attribute 'pytmc' := ' + pv: PLC:bHomeCmd + io: io + field: DESC Start the homing routine + '} + bHomeCmd: BOOL; + + (* Command Args *) + // Used internally and by the IOC to pick what kind of move to do + nCommand: INT; + // Used internally and by the IOC to pass additional data to some commands + nCmdData: INT; + // Used internally and by the IOC to pick a destination for the move + fPosition: LREAL; + // Used internally and by the IOC to pick a move velocity + fVelocity: LREAL; + // Used internally and by the IOC to pick a move acceleration + fAcceleration: LREAL; + // Used internally and by the IOC to pick a move deceleration + fDeceleration: LREAL; + // Used internally and by the IOC to pick a home position + {attribute 'pytmc' := ' + pv: PLC:fHomePosition + io: io + field: DESC Used internally and by the IOC to pick home position + '} + fHomePosition: LREAL; + + (* Info *) + // Unique ID assigned to each axis in the NC + nMotionAxisID: UDINT:=0; + + (* Returns *) + // TRUE if done enabling + bEnableDone: BOOL; + // TRUE if in the middle of a command + bBusy: BOOL; + // TRUE if we've done a command and it has finished + bDone: BOOL; + // TRUE if the motor has been homed, or does not need to be homed + bHomed: BOOL; + // TRUE if we have safety permission to move + bSafetyReady: BOOL; + // TRUE if we're in an error state + {attribute 'pytmc' := ' + pv: PLC:bError + io: i + field: ZNAM FALSE + field: ONAM TRUE + field: DESC TRUE if we are in an error state + update: 100Hz notify + '} + bError: BOOL; + // Error code if nonzero + {attribute 'pytmc' := ' + pv: PLC:nErrorId + io: i + field: DESC Error code if nonzero + update: 100Hz notify + '} + nErrorId: UDINT; + // Message to identify the error state + {attribute 'pytmc' := ' + pv: PLC:sErrorMessage + io: i + field: DESC Message to identify the error state + update: 100Hz notify + '} + sErrorMessage: STRING; + // Internal hook for custom error messages + sCustomErrorMessage: STRING; + // MC_ReadParameterSet Output + stAxisParameters: ST_AxisParameterSet; + // True if we've updated stAxisParameters at least once + bAxisParamsInit: BOOL; + + // Misc axis status information for the IOC + stAxisStatus: DUT_AxisStatus_v0_01; + + (* Other status information for users of the IOC *) + // Position lag difference + {attribute 'pytmc' := ' + pv: PLC:fPosDiff + io: i + field: DESC Position lag difference + '} + fPosDiff: LREAL; + END_STRUCT + END_TYPE + + +Related: + * `DUT_AxisStatus_v0_01`_ + * `E_EpicsHomeCmd`_ + * `E_StageBrakeMode`_ + * `E_StageEnableMode`_ + + +ST_PositionState +^^^^^^^^^^^^^^^^ + +:: + + TYPE ST_PositionState : + // Defines settings and current safety status for moves to specific positions for an axis + STRUCT + // Name as queried via the NAME PV in EPICS + {attribute 'pytmc' := ' + pv: NAME + io: input + field: DESC Name of this position state + '} + sName: STRING := 'Invalid'; + + // Position associated with this state + {attribute 'pytmc' := ' + pv: SETPOINT + io: io + field: DESC Axis position associated with this state + '} + fPosition: LREAL; + + {attribute 'pytmc' := ' + pv: ENCODER + io: i + field: DESC Encoder count associated with this state + '} + nEncoderCount: UDINT; + + // Maximum allowable deviation from fPosition while at the state + fDelta: LREAL; + + // Speed at which to move to this state + {attribute 'pytmc' := ' + pv: VELO + io: io + field: DESC Speed at which to move to this state + '} + fVelocity: LREAL; + + // (optional) Acceleration to use for moves to this state + fAccel: LREAL; + + // (optional) Deceleration to use for moves to this state + fDecel: LREAL; + + // Safety parameter. This must be set to TRUE by the PLC program to allow moves to this state. This is expected to change as conditions change. + {attribute 'pytmc' := ' + pv: MOVE_OK + io: i + field: ZNAM FALSE + field: ONAM TRUE + field: DESC TRUE if the move would be safe + '} + bMoveOk: BOOL; + + // Signifies to FB_PositionStateLock that this state should be immutable + bLocked: BOOL; + + // Set this to TRUE when you make your state. This defaults to FALSE so that uninitialized states can never be moved to + bValid: BOOL; + + // Set this to TRUE when you want to use the raw encoder counts to define the state + bUseRawCounts: BOOL; + + // Is set to TRUE by FB_PositionStateInternal when called + bUpdated: BOOL; + + // We give this a state name and it is used to load parameters from the pmps database. + stPMPS: ST_DbStateParams; + END_STRUCT + END_TYPE + + +Related: + * `FB_PositionStateInternal`_ + * `FB_PositionStateLock`_ + + +ST_RenishawAbsEnc +^^^^^^^^^^^^^^^^^ + +:: + + // Renishaw BiSS-C absolute encoder used with an EL5042 + TYPE ST_RenishawAbsEnc : + STRUCT + Count AT %I*: ULINT; // Connect to encoder "Position" input + Status: ST_EL5042_Status; // Status struct placeholder + Ref: ULINT; // Encoder zero position (useful for aligned position with gantries) + END_STRUCT + END_TYPE + + +Related: + * `EL5042`_ + * `ST_EL5042_Status`_ + + +ST_StateEpicsToPlc +^^^^^^^^^^^^^^^^^^ + +:: + + TYPE ST_StateEpicsToPlc : + (* + This data structure contains the standard EPICS input connection points for the state movers. + + The data in this struct flows from EPICS to the PLC. + + It includes everything except the SET PV, which cannot be included here + as it is sourced from enum values unique to the application, and the PMPS PVs, which are + gathered in their own data type, ST_StatePMPSEpicsToPlc. That actually means that this only + holds the RESET PV, for now. + + nSetValue here is actively used by state blocks even though it is not exposed + directly to EPICS. You should avoid manually modifying it or else + you may interfere with normal operations of the state function blocks. + + For including your own ENUM input, you should pytmc pragma the PV name to end in "SET", + and match the prefix of this FB's "RESET" PV. Then, you can include your enum + as the eEnumSet IN_OUT var and let the EPICS IOC handle it. + *) + STRUCT + // For internal use only. This holds new goal positions as an integer, else it is 0 if there is no new state move request. It is written to from the user's input enum. + nSetValue: UINT; + + // Set this to TRUE to acknowledge and clear an error. + {attribute 'pytmc' := ' + pv: RESET + io: io + field: ZNAM False + field: ONAM True + '} + bReset: BOOL; + END_STRUCT + END_TYPE + + +Related: + * `ST_StatePMPSEpicsToPlc`_ + + +ST_StatePlcToEpics +^^^^^^^^^^^^^^^^^^ + +:: + + TYPE ST_StatePlcToEpics : + (* + This data structure contains the standard EPICS connection points for the state movers. + + The data in this struct flows from the PLC to EPICS. + + It includes everything except the GET PV, which cannot be included here + as it is sourced from enum values unique to the application, and the PMPS PVs, which are + gathered in their own data type, ST_StatePMPSPlcToEpics. + + nGetValue here is actively used by state blocks even though it is not exposed directly + to EPICS. It is safe to read this value, but you should avoid modifying it, which may + interfere with normal operations of the state function blocks. + + For including your own ENUM input, you should pytmc pragma the PV name to end in "GET", + and match the prefix of this FB's "DONE" PV. Then, you can include your enum + as the eEnumGet IN_OUT var and let the EPICS IOC handle it. + *) + STRUCT + // For internal use only. This holds the current position index as an integer, else it is 0 if we are changing states or not at any particular state. + nGetValue: UINT; + // This will be TRUE when we are in an active state move and FALSE otherwise. + {attribute 'pytmc' := ' + pv: BUSY + io: i + field: ZNAM False + field: ONAM True + '} + bBusy: BOOL; + // This will be TRUE after a move completes and FALSE otherwise. + {attribute 'pytmc' := ' + pv: DONE + io: i + field: ZNAM False + field: ONAM True + '} + bDone: BOOL; + // This will be TRUE if the most recent move had an error and FALSE otherwise. + {attribute 'pytmc' := ' + pv: ERR + io: i + field: ZNAM False + field: ONAM True + '} + bError: BOOL; + // This will be set to an NC error code during an error if one exists or left at 0 otherwise. + {attribute 'pytmc' := ' + pv: ERRID + io: i + '} + nErrorID: UDINT; + // This will be set to an appropriate error message during an error if one exists or left as an empty string otherwise. + {attribute 'pytmc' := ' + pv: ERRMSG + io: i + '} + sErrorMsg: STRING; + END_STRUCT + END_TYPE + + +Related: + * `ST_StatePMPSPlcToEpics`_ + + +ST_StatePMPSEpicsToPlc +^^^^^^^^^^^^^^^^^^^^^^ + +:: + + TYPE ST_StatePMPSEpicsToPlc : + (* + This data structure contains the standard PMPS EPICS connection points for the state movers. + + The data in this struct flows from EPICS to the PLC. + *) + STRUCT + // User setting: TRUE to enable the arbiter, FALSE to disable it. + {attribute 'pytmc' := ' + pv: PMPS:ARB:ENABLE + io: io + '} + bArbiterEnabled: BOOL := TRUE; + // User setting: TRUE to enable maintenance mode (Fast fault, free motion), FALSE to disable it. + {attribute 'pytmc' := ' + pv: PMPS:MAINT + io: io + '} + bMaintMode: BOOL; + END_STRUCT + END_TYPE + + + + +ST_StatePMPSPlcToEpics +^^^^^^^^^^^^^^^^^^^^^^ + +:: + + TYPE ST_StatePMPSPlcToEpics : + (* + This data structure contains the standard PMPS EPICS connection points for the state movers. + + The data in this struct flows from the PLC to EPICS. + *) + STRUCT + // The database entry for the transition state. This should always be present. + {attribute 'pytmc' := ' + pv: PMPS:TRANS + io: i + '} + stTransitionDb: ST_DbStateParams; + END_STRUCT + END_TYPE + + + + +GVLs +---- + + +Global_Version +^^^^^^^^^^^^^^ + +:: + + {attribute 'TcGenerated'} + // This function has been automatically generated from the project information. + VAR_GLOBAL CONSTANT + {attribute 'const_non_replaced'} + {attribute 'linkalways'} + stLibVersion_lcls_twincat_motion : ST_LibVersion := (iMajor := 4, iMinor := 0, iBuild := 3, iRevision := 0, sVersion := '4.0.3'); + END_VAR + + + + +GVL +^^^ + +:: + + VAR_GLOBAL + nHomingError:UDINT:=16#14D00; + END_VAR + + + + +GVL_ErrorSystem +^^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + VAR_GLOBAL CONSTANT + cSizeOfErrorData : UINT := 128; + + END_VAR + + + + +MOTION_GVL +^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + VAR_GLOBAL + // Global file reader instance, used in fbStandardPMPSDB + fbPmpsFileReader: FB_JsonFileToJsonDoc; + {attribute 'pytmc' := ' + pv: @(PREFIX)DB + io: io + '} + // Global DB handler, Must be called in PLC project to use the PMPS DB for a motion project + fbStandardPMPSDB: FB_Standard_PMPSDB; + // Debug, records the highest number of motors used in an ND states block in the PLC. Can be used to limit MotionConstants.MAX_STATE_MOTORS to save on memory usage and PV count. + nMaxStateMotorCount: UINT; + // Debug, records the highest state count in the PLC. Can be used to limit GeneralConstants.MAX_STATES to save on memory usage and PV count. + nMaxStates: UINT; + END_VAR + + +Related: + * `FB_Standard_PMPSDB`_ + * `MotionConstants`_ + + +MotionConstants +^^^^^^^^^^^^^^^ + +:: + + {attribute 'qualified_only'} + (* + Global Configurable Motion Constants + + These are reconfigurable at the project level. + When reconfigured they are set prior to compilation and cannot be changed at runtime. + *) + VAR_GLOBAL CONSTANT + (* + Arbitary cap on multidimensional states to simplify statements for the compiler. + This is reconfigurable at the project level and should be set to the highest number of motors used in a states block. + If you are not sure how many motors are used per state block, check MOTION_GVL.nMaxStateMotorCount + *) + MAX_STATE_MOTORS: UINT := 3; + END_VAR + + +Related: + * `MOTION_GVL`_ + + +POUs +---- + + +CheckBounds +^^^^^^^^^^^ + +:: + + // Implicitly generated code : DO NOT EDIT + FUNCTION CheckBounds : DINT + VAR_INPUT + index, lower, upper: DINT; + END_VAR + // Implicitly generated code : Only an Implementation suggestion + {noflow} + IF index < lower THEN + CheckBounds := lower; + ELSIF index > upper THEN + CheckBounds := upper; + ELSE + CheckBounds := index; + END_IF + {flow} + + END_FUNCTION + + + + +CheckDivDInt +^^^^^^^^^^^^ + +:: + + // Implicitly generated code : DO NOT EDIT + FUNCTION CheckDivDInt : DINT + VAR_INPUT + divisor:DINT; + END_VAR + // Implicitly generated code : Only an Implementation suggestion + {noflow} + IF divisor = 0 THEN + CheckDivDInt:=1; + ELSE + CheckDivDInt:=divisor; + END_IF; + {flow} + + END_FUNCTION + + + + +CheckDivLInt +^^^^^^^^^^^^ + +:: + + // Implicitly generated code : DO NOT EDIT + FUNCTION CheckDivLInt : LINT + VAR_INPUT + divisor:LINT; + END_VAR + // Implicitly generated code : Only an Implementation suggestion + {noflow} + IF divisor = 0 THEN + CheckDivLInt:=1; + ELSE + CheckDivLInt:=divisor; + END_IF; + {flow} + + END_FUNCTION + + + + +CheckDivLReal +^^^^^^^^^^^^^ + +:: + + // Implicitly generated code : DO NOT EDIT + FUNCTION CheckDivLReal : LREAL + VAR_INPUT + divisor:LREAL; + END_VAR + // Implicitly generated code : Only an Implementation suggestion + {noflow} + IF divisor = 0 THEN + CheckDivLReal:=1; + ELSE + CheckDivLReal:=divisor; + END_IF; + {flow} + + END_FUNCTION + + + + +CheckDivReal +^^^^^^^^^^^^ + +:: + + // Implicitly generated code : DO NOT EDIT + FUNCTION CheckDivReal : REAL + VAR_INPUT + divisor:REAL; + END_VAR + // Implicitly generated code : Only an Implementation suggestion + {noflow} + IF divisor = 0 THEN + CheckDivReal:=1; + ELSE + CheckDivReal:=divisor; + END_IF; + {flow} + + END_FUNCTION + + + + +EK1200 +^^^^^^ + +:: + + FUNCTION_BLOCK EK1200 + VAR_INPUT + En: BOOL; + END_VAR + VAR_OUTPUT + EnO: BOOL; + END_VAR + EnO:=En; + + END_FUNCTION_BLOCK + + + + +EL1008 +^^^^^^ + +:: + + ///EL1008 | 8-channel digital input terminal 24 V DC, 3 ms + FUNCTION_BLOCK EL1008 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + bDi_1: BOOL; + bDi_2: BOOL; + bDi_3: BOOL; + bDi_4: BOOL; + bDi_5: BOOL; + bDi_6: BOOL; + bDi_7: BOOL; + bDi_8: BOOL; + bError: BOOL; + END_VAR + + VAR + Channel_1_Input AT %I*: BOOL; + Channel_2_Input AT %I*: BOOL; + Channel_3_Input AT %I*: BOOL; + Channel_4_Input AT %I*: BOOL; + Channel_5_Input AT %I*: BOOL; + Channel_6_Input AT %I*: BOOL; + Channel_7_Input AT %I*: BOOL; + Channel_8_Input AT %I*: BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL1008_Error : FB_TerminalError; + END_VAR + EnO:=En; + + //Error FB instance + EL1008_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError=FALSE THEN + bDi_1:=Channel_1_Input; + bDi_2:=Channel_2_Input; + bDi_3:=Channel_3_Input; + bDi_4:=Channel_4_Input; + bDi_5:=Channel_5_Input; + bDi_6:=Channel_6_Input; + bDi_7:=Channel_7_Input; + bDi_8:=Channel_8_Input; + ELSE + bDi_1:=FALSE; + bDi_2:=FALSE; + bDi_3:=FALSE; + bDi_4:=FALSE; + bDi_5:=FALSE; + bDi_6:=FALSE; + bDi_7:=FALSE; + bDi_8:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL1018 +^^^^^^ + +:: + + ///EL1018 | 8-channel digital input terminal 24 V DC, 10 µs + FUNCTION_BLOCK EL1018 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + bDi_1: BOOL; + bDi_2: BOOL; + bDi_3: BOOL; + bDi_4: BOOL; + bDi_5: BOOL; + bDi_6: BOOL; + bDi_7: BOOL; + bDi_8: BOOL; + bError : BOOL; + END_VAR + + VAR + Channel_1_Input AT %I*: BOOL; + Channel_2_Input AT %I*: BOOL; + Channel_3_Input AT %I*: BOOL; + Channel_4_Input AT %I*: BOOL; + Channel_5_Input AT %I*: BOOL; + Channel_6_Input AT %I*: BOOL; + Channel_7_Input AT %I*: BOOL; + Channel_8_Input AT %I*: BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL1018_Error : FB_TerminalError; + END_VAR + EnO:=En; + + //Error FB instance + EL1018_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError=FALSE THEN + bDi_1:=Channel_1_Input; + bDi_2:=Channel_2_Input; + bDi_3:=Channel_3_Input; + bDi_4:=Channel_4_Input; + bDi_5:=Channel_5_Input; + bDi_6:=Channel_6_Input; + bDi_7:=Channel_7_Input; + bDi_8:=Channel_8_Input; + ELSE + bDi_1:=FALSE; + bDi_2:=FALSE; + bDi_3:=FALSE; + bDi_4:=FALSE; + bDi_5:=FALSE; + bDi_6:=FALSE; + bDi_7:=FALSE; + bDi_8:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL1808 +^^^^^^ + +:: + + ///EL1808 | HD EtherCAT Terminals, 8-channel digital input 24 V DC, 3 ms, 2-wire connection + FUNCTION_BLOCK EL1808 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + bDi_1: BOOL; + bDi_2: BOOL; + bDi_3: BOOL; + bDi_4: BOOL; + bDi_5: BOOL; + bDi_6: BOOL; + bDi_7: BOOL; + bDi_8: BOOL; + bError: BOOL; + END_VAR + + VAR + Channel_1_Input AT %I*: BOOL; + Channel_2_Input AT %I*: BOOL; + Channel_3_Input AT %I*: BOOL; + Channel_4_Input AT %I*: BOOL; + Channel_5_Input AT %I*: BOOL; + Channel_6_Input AT %I*: BOOL; + Channel_7_Input AT %I*: BOOL; + Channel_8_Input AT %I*: BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL1808_Error : FB_TerminalError; + END_VAR + EnO:=En; + + //Error FB instance + EL1808_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError=FALSE THEN + bDi_1:=Channel_1_Input; + bDi_2:=Channel_2_Input; + bDi_3:=Channel_3_Input; + bDi_4:=Channel_4_Input; + bDi_5:=Channel_5_Input; + bDi_6:=Channel_6_Input; + bDi_7:=Channel_7_Input; + bDi_8:=Channel_8_Input; + ELSE + bDi_1:=FALSE; + bDi_2:=FALSE; + bDi_3:=FALSE; + bDi_4:=FALSE; + bDi_5:=FALSE; + bDi_6:=FALSE; + bDi_7:=FALSE; + bDi_8:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL1809 +^^^^^^ + +:: + + ///EL1809 | HD EtherCAT Terminals, 16-channel digital input 24 V DC, 3 ms + FUNCTION_BLOCK EL1809 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + bDi_1: BOOL; + bDi_2: BOOL; + bDi_3: BOOL; + bDi_4: BOOL; + bDi_5: BOOL; + bDi_6: BOOL; + bDi_7: BOOL; + bDi_8: BOOL; + bDi_9: BOOL; + bDi_10: BOOL; + bDi_11: BOOL; + bDi_12: BOOL; + bDi_13: BOOL; + bDi_14: BOOL; + bDi_15: BOOL; + bDi_16: BOOL; + bError: BOOL; + END_VAR + + VAR + Channel_1_Input AT %I*: BOOL; + Channel_2_Input AT %I*: BOOL; + Channel_3_Input AT %I*: BOOL; + Channel_4_Input AT %I*: BOOL; + Channel_5_Input AT %I*: BOOL; + Channel_6_Input AT %I*: BOOL; + Channel_7_Input AT %I*: BOOL; + Channel_8_Input AT %I*: BOOL; + Channel_9_Input AT %I*: BOOL; + Channel_10_Input AT %I*: BOOL; + Channel_11_Input AT %I*: BOOL; + Channel_12_Input AT %I*: BOOL; + Channel_13_Input AT %I*: BOOL; + Channel_14_Input AT %I*: BOOL; + Channel_15_Input AT %I*: BOOL; + Channel_16_Input AT %I*: BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL1809_Error : FB_TerminalError; + END_VAR + EnO:=En; + + //Error FB instance + EL1809_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError=FALSE THEN + bDi_1:=Channel_1_Input; + bDi_2:=Channel_2_Input; + bDi_3:=Channel_3_Input; + bDi_4:=Channel_4_Input; + bDi_5:=Channel_5_Input; + bDi_6:=Channel_6_Input; + bDi_7:=Channel_7_Input; + bDi_8:=Channel_8_Input; + bDi_9:=Channel_9_Input; + bDi_10:=Channel_10_Input; + bDi_11:=Channel_11_Input; + bDi_12:=Channel_12_Input; + bDi_13:=Channel_13_Input; + bDi_14:=Channel_14_Input; + bDi_15:=Channel_15_Input; + bDi_16:=Channel_16_Input; + ELSE + bDi_1:=FALSE; + bDi_2:=FALSE; + bDi_3:=FALSE; + bDi_4:=FALSE; + bDi_5:=FALSE; + bDi_6:=FALSE; + bDi_7:=FALSE; + bDi_8:=FALSE; + bDi_9:=FALSE; + bDi_10:=FALSE; + bDi_11:=FALSE; + bDi_12:=FALSE; + bDi_13:=FALSE; + bDi_14:=FALSE; + bDi_15:=FALSE; + bDi_16:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL1819 +^^^^^^ + +:: + + ///EL1819 | HD EtherCAT Terminals, 16-channel digital input 24 V DC, 10 µs + FUNCTION_BLOCK EL1819 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + bDi_1: BOOL; + bDi_2: BOOL; + bDi_3: BOOL; + bDi_4: BOOL; + bDi_5: BOOL; + bDi_6: BOOL; + bDi_7: BOOL; + bDi_8: BOOL; + bDi_9: BOOL; + bDi_10: BOOL; + bDi_11: BOOL; + bDi_12: BOOL; + bDi_13: BOOL; + bDi_14: BOOL; + bDi_15: BOOL; + bDi_16: BOOL; + bError: BOOL; + END_VAR + + VAR + Channel_1_Input AT %I*: BOOL; + Channel_2_Input AT %I*: BOOL; + Channel_3_Input AT %I*: BOOL; + Channel_4_Input AT %I*: BOOL; + Channel_5_Input AT %I*: BOOL; + Channel_6_Input AT %I*: BOOL; + Channel_7_Input AT %I*: BOOL; + Channel_8_Input AT %I*: BOOL; + Channel_9_Input AT %I*: BOOL; + Channel_10_Input AT %I*: BOOL; + Channel_11_Input AT %I*: BOOL; + Channel_12_Input AT %I*: BOOL; + Channel_13_Input AT %I*: BOOL; + Channel_14_Input AT %I*: BOOL; + Channel_15_Input AT %I*: BOOL; + Channel_16_Input AT %I*: BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL1819_Error : FB_TerminalError; + END_VAR + EnO:=En; + + //Error FB instance + EL1819_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError=FALSE THEN + bDi_1:=Channel_1_Input; + bDi_2:=Channel_2_Input; + bDi_3:=Channel_3_Input; + bDi_4:=Channel_4_Input; + bDi_5:=Channel_5_Input; + bDi_6:=Channel_6_Input; + bDi_7:=Channel_7_Input; + bDi_8:=Channel_8_Input; + bDi_9:=Channel_9_Input; + bDi_10:=Channel_10_Input; + bDi_11:=Channel_11_Input; + bDi_12:=Channel_12_Input; + bDi_13:=Channel_13_Input; + bDi_14:=Channel_14_Input; + bDi_15:=Channel_15_Input; + bDi_16:=Channel_16_Input; + ELSE + bDi_1:=FALSE; + bDi_2:=FALSE; + bDi_3:=FALSE; + bDi_4:=FALSE; + bDi_5:=FALSE; + bDi_6:=FALSE; + bDi_7:=FALSE; + bDi_8:=FALSE; + bDi_9:=FALSE; + bDi_10:=FALSE; + bDi_11:=FALSE; + bDi_12:=FALSE; + bDi_13:=FALSE; + bDi_14:=FALSE; + bDi_15:=FALSE; + bDi_16:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL2014 +^^^^^^ + +:: + + FUNCTION_BLOCK EL2014 + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + bDo_1: BOOL; + bDo_2: BOOL; + bDo_3: BOOL; + bDo_4: BOOL; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO : BOOL; + bError : BOOL; + END_VAR + + VAR + Channel_1_Output AT %Q*: BOOL; + Channel_2_Output AT %Q*: BOOL; + Channel_3_Output AT %Q*: BOOL; + Channel_4_Output AT %Q*: BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL2014_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Channel diagnostic variables and device diag variables + *) + + EnO:=En; + + EL2014_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError=FALSE THEN + Channel_1_Output:=bDo_1; + Channel_2_Output:=bDo_2; + Channel_3_Output:=bDo_3; + Channel_4_Output:=bDo_4; + ELSE + Channel_1_Output:=FALSE; + Channel_2_Output:=FALSE; + Channel_3_Output:=FALSE; + Channel_4_Output:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL2252 +^^^^^^ + +:: + + ///EL2252 | XFC, 2-channel digital output terminal with time stamp, tri-state + FUNCTION_BLOCK EL2252 + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + bDo_1: BOOL; + bDo_2: BOOL; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO : BOOL; + bError : BOOL; + END_VAR + + VAR + Channel_1_Output AT %Q*: BOOL; + Channel_2_Output AT %Q*: BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL2252_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Add the DC sync variables + *) + + EL2252_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError=FALSE THEN + Channel_1_Output:=bDo_1; + Channel_2_Output:=bDo_2; + ELSE + Channel_1_Output:=FALSE; + Channel_2_Output:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL2808 +^^^^^^ + +:: + + FUNCTION_BLOCK EL2808 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + bDo_1: BOOL; + bDo_2: BOOL; + bDo_3: BOOL; + bDo_4: BOOL; + bDo_5: BOOL; + bDo_6: BOOL; + bDo_7: BOOL; + bDo_8: BOOL; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO : BOOL; + bError : BOOL; + END_VAR + + VAR + Channel_1_Output AT %Q*: BOOL; + Channel_2_Output AT %Q*: BOOL; + Channel_3_Output AT %Q*: BOOL; + Channel_4_Output AT %Q*: BOOL; + Channel_5_Output AT %Q*: BOOL; + Channel_6_Output AT %Q*: BOOL; + Channel_7_Output AT %Q*: BOOL; + Channel_8_Output AT %Q*: BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL2808_Error : FB_TerminalError; + END_VAR + EnO:=En; + + EL2808_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError=FALSE THEN + Channel_1_Output:=bDo_1; + Channel_2_Output:=bDo_2; + Channel_3_Output:=bDo_3; + Channel_4_Output:=bDo_4; + Channel_5_Output:=bDo_5; + Channel_6_Output:=bDo_6; + Channel_7_Output:=bDo_7; + Channel_8_Output:=bDo_8; + ELSE + Channel_1_Output:=FALSE; + Channel_2_Output:=FALSE; + Channel_3_Output:=FALSE; + Channel_4_Output:=FALSE; + Channel_5_Output:=FALSE; + Channel_6_Output:=FALSE; + Channel_7_Output:=FALSE; + Channel_8_Output:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL2819 +^^^^^^ + +:: + + FUNCTION_BLOCK EL2819 + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + bDo_1: BOOL; + bDo_2: BOOL; + bDo_3: BOOL; + bDo_4: BOOL; + bDo_5: BOOL; + bDo_6: BOOL; + bDo_7: BOOL; + bDo_8: BOOL; + bDo_9: BOOL; + bDo_10: BOOL; + bDo_11: BOOL; + bDo_12: BOOL; + bDo_13: BOOL; + bDo_14: BOOL; + bDo_15: BOOL; + bDo_16: BOOL; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO : BOOL; + bError : BOOL; + END_VAR + + VAR + Channel_1_Output AT %Q*: BOOL; + Channel_2_Output AT %Q*: BOOL; + Channel_3_Output AT %Q*: BOOL; + Channel_4_Output AT %Q*: BOOL; + Channel_5_Output AT %Q*: BOOL; + Channel_6_Output AT %Q*: BOOL; + Channel_7_Output AT %Q*: BOOL; + Channel_8_Output AT %Q*: BOOL; + Channel_9_Output AT %Q*: BOOL; + Channel_10_Output AT %Q*: BOOL; + Channel_11_Output AT %Q*: BOOL; + Channel_12_Output AT %Q*: BOOL; + Channel_13_Output AT %Q*: BOOL; + Channel_14_Output AT %Q*: BOOL; + Channel_15_Output AT %Q*: BOOL; + Channel_16_Output AT %Q*: BOOL; + + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL2819_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Channel diagnostic variables and device diag variables + *) + + EnO:=En; + + EL2819_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError=FALSE THEN + Channel_1_Output:=bDo_1; + Channel_2_Output:=bDo_2; + Channel_3_Output:=bDo_3; + Channel_4_Output:=bDo_4; + Channel_5_Output:=bDo_5; + Channel_6_Output:=bDo_6; + Channel_7_Output:=bDo_7; + Channel_8_Output:=bDo_8; + Channel_9_Output:=bDo_9; + Channel_10_Output:=bDo_10; + Channel_11_Output:=bDo_11; + Channel_12_Output:=bDo_12; + Channel_13_Output:=bDo_13; + Channel_14_Output:=bDo_14; + Channel_15_Output:=bDo_15; + Channel_16_Output:=bDo_16; + ELSE + Channel_1_Output:=FALSE; + Channel_2_Output:=FALSE; + Channel_3_Output:=FALSE; + Channel_4_Output:=FALSE; + Channel_5_Output:=FALSE; + Channel_6_Output:=FALSE; + Channel_7_Output:=FALSE; + Channel_8_Output:=FALSE; + Channel_9_Output:=FALSE; + Channel_10_Output:=FALSE; + Channel_11_Output:=FALSE; + Channel_12_Output:=FALSE; + Channel_13_Output:=FALSE; + Channel_14_Output:=FALSE; + Channel_15_Output:=FALSE; + Channel_16_Output:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL3174_0002 +^^^^^^^^^^^ + +:: + + //EL3174-0002 | 4-channel analog input, -10/0...+10V, -20/0/+4...20mA, 16 bit, differential + FUNCTION_BLOCK EL3174_0002 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + iAi_Ch1_Value : INT; + iAi_Ch2_Value : INT; + iAi_Ch3_Value : INT; + iAi_Ch4_Value : INT; + bError: BOOL; + END_VAR + + VAR + //Channels + AI_Std_Ch_1_Status AT %I* : WORD; + AI_Std_Ch_1_Value AT %I* : INT; + AI_Std_Ch_2_Status AT %I* : WORD; + AI_Std_Ch_2_Value AT %I* : INT; + AI_Std_Ch_3_Status AT %I* : WORD; + AI_Std_Ch_3_Value AT %I* : INT; + AI_Std_Ch_4_Status AT %I* : WORD; + AI_Std_Ch_4_Value AT %I* : INT; + + //Terminal status + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL3174_0002_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Status words of the channels + *) + + EnO := En; + + //Error FB instance + EL3174_0002_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError = FALSE THEN + iAi_Ch1_Value := AI_Std_Ch_1_Value; + iAi_Ch2_Value := AI_Std_Ch_2_Value; + iAi_Ch3_Value := AI_Std_Ch_3_Value; + iAi_Ch4_Value := AI_Std_Ch_4_Value; + ELSE + iAi_Ch1_Value := 0; + iAi_Ch2_Value := 0; + iAi_Ch3_Value := 0; + iAi_Ch4_Value := 0; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL3214 +^^^^^^ + +:: + + //EL3214 | 4-channel analog input terminal, PT100 (RTD) + FUNCTION_BLOCK EL3214 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + iAi_Ch1_Value : INT; + iAi_Ch2_Value : INT; + iAi_Ch3_Value : INT; + iAi_Ch4_Value : INT; + bError: BOOL; + END_VAR + + VAR + //Channels + AI_RTD_Ch_1_Status AT %I* : WORD; + AI_RTD_Ch_1_Value AT %I* : INT; + AI_RTD_Ch_2_Status AT %I* : WORD; + AI_RTD_Ch_2_Value AT %I* : INT; + AI_RTD_Ch_3_Status AT %I* : WORD; + AI_RTD_Ch_3_Value AT %I* : INT; + AI_RTD_Ch_4_Status AT %I* : WORD; + AI_RTD_Ch_4_Value AT %I* : INT; + + //Terminal status + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL3214_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Status words of the channels + *) + + EnO := En; + + //Error FB instance + EL3214_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF En THEN + IF bError = FALSE THEN + iAi_Ch1_Value := AI_RTD_Ch_1_Value; + iAi_Ch2_Value := AI_RTD_Ch_2_Value; + iAi_Ch3_Value := AI_RTD_Ch_3_Value; + iAi_Ch4_Value := AI_RTD_Ch_4_Value; + ELSE + iAi_Ch1_Value := 0; + iAi_Ch2_Value := 0; + iAi_Ch3_Value := 0; + iAi_Ch4_Value := 0; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL3255 +^^^^^^ + +:: + + //EL3255 | 5-channel potentiometer measurement with sensor supply + FUNCTION_BLOCK EL3255 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO : BOOL; + Ch1_Value : INT; + Ch2_Value : INT; + Ch3_Value : INT; + Ch4_Value : INT; + Ch5_Value : INT; + bError : BOOL; + END_VAR + + VAR + AI_Std_Ch1_Value AT %I* : INT; + AI_Std_Ch2_Value AT %I* : INT; + AI_Std_Ch3_Value AT %I* : INT; + AI_Std_Ch4_Value AT %I* : INT; + AI_Std_Ch5_Value AT %I* : INT; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL3255_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Channel Status words + *) + + EnO:=En; + + //Error FB instance + EL3255_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF EN THEN + IF NOT bError THEN + Ch1_Value := AI_Std_Ch1_Value; + Ch2_Value := AI_Std_Ch2_Value; + Ch3_Value := AI_Std_Ch3_Value; + Ch4_Value := AI_Std_Ch4_Value; + Ch5_Value := AI_Std_Ch5_Value; + ELSE + Ch1_Value := 0; + Ch2_Value := 0; + Ch3_Value := 0; + Ch4_Value := 0; + Ch5_Value := 0; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL5002 +^^^^^^ + +:: + + //EL5002 | 2-chennel SSI absolute encoder terminal + FUNCTION_BLOCK EL5002 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + Ch1_Counter_Value : UDINT; + Ch2_Counter_Value : UDINT; + bError: BOOL; + END_VAR + + VAR + udi_Ch1_Cnt_Value AT %I* : UDINT; + udi_Ch2_Cnt_Value AT %I* : UDINT; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL5002_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Channel Status words + *) + + EnO:=En; + + //Error FB instance + EL5002_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF EN THEN + IF NOT bError THEN + Ch1_Counter_Value := udi_Ch1_Cnt_Value; + Ch2_Counter_Value := udi_Ch2_Cnt_Value; + ELSE + Ch1_Counter_Value := 0; + Ch2_Counter_Value := 0; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL5021 +^^^^^^ + +:: + + //EL5021 | 1-channel Sin/Cos encoder + FUNCTION_BLOCK EL5021 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + Counter_Value : UDINT; + Latch_Value : UDINT; + bError: BOOL; + END_VAR + + VAR + udiCounter_Value AT %I* : UDINT; + udiLatch_Value AT %I* : UDINT; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL5021_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Channel Status words, control words + *) + + EnO:=En; + + //Error FB instance + EL5021_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF EN THEN + IF NOT bError THEN + Counter_Value := udiCounter_Value; + Latch_Value := udiLatch_Value; + ELSE + Counter_Value := 0; + Latch_Value := 0; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL5042 +^^^^^^ + +:: + + //EL5042 | 2-channel BiSS-C absolute encoder terminal + FUNCTION_BLOCK EL5042 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + Ch1_Position : ULINT; + Ch2_Position : ULINT; + bError: BOOL; + END_VAR + + VAR + FB_Inputs_ch1_Position AT %I* : ULINT; + FB_Inputs_ch2_Position AT %I* : ULINT; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL5042_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Channel Status words + *) + + EnO:=En; + + //Error FB instance + EL5042_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF EN THEN + IF NOT bError THEN + Ch1_Position := FB_Inputs_ch1_Position; + Ch2_Position := FB_Inputs_ch2_Position; + ELSE + Ch1_Position := 0; + Ch2_Position := 0; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL5101 +^^^^^^ + +:: + + // EL5101 | 1-channel incremental encoder terminal, 5V, RS422 + FUNCTION_BLOCK EL5101 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + Counter_Value : UINT; + Latch_Value : UINT; + bError: BOOL; + END_VAR + + VAR + uiCounter_Value AT %I* : UINT; + uiLatch_Value AT %I* : UINT; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL5101_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Channel Status word, control words + *) + + EnO:=En; + + //Error FB instance + EL5101_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + IF EN THEN + IF NOT bError THEN + Counter_Value := uiCounter_Value; + Latch_Value := uiLatch_Value; + ELSE + Counter_Value := 0; + Latch_Value := 0; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL7211_v1_00 +^^^^^^^^^^^^ + +:: + + ///EL7211 | Servo motor termional 5 A + FUNCTION_BLOCK EL7211_v1_00 + VAR_INPUT + En: BOOL; + END_VAR + VAR_OUTPUT + EnO: BOOL; + + bError: BOOL; + END_VAR + VAR + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + END_VAR + EnO:=En; + + IF En AND (WcState_WcState OR InfoData_State<>16#8) THEN + bError:=TRUE; + ELSE + bError:=FALSE; + END_IF + + END_FUNCTION_BLOCK + + + + +EL9410 +^^^^^^ + +:: + + //EL9410 | E-Bus power supplier and refresher, diagnostics + FUNCTION_BLOCK EL9410 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + bError: BOOL; + END_VAR + + VAR + bStatus_Us_UV AT %I* : BOOL; + bStatus_Up_UV AT %I* : BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL9410_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Status bits + *) + + EnO:=En; + + //Error FB instance + EL9410_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL9505 +^^^^^^ + +:: + + //EL9505 | Power supply terminal 5V + FUNCTION_BLOCK EL9505 + + VAR_INPUT + En: BOOL; + iTerminal_ID : INT; + ErrorSystem : POINTER TO ST_ErrorSystem; + END_VAR + + VAR_OUTPUT + EnO: BOOL; + bError: BOOL; + END_VAR + + VAR + bStatus_Uo_Power_OK AT %I* : BOOL; + bStatus_Uo_Overload AT %I* : BOOL; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + //FB-s + EL9505_Error : FB_TerminalError; + END_VAR + (* + * TODO: + * Status bits + *) + EnO:=En; + + //Error FB instance + EL9505_Error( + En := TRUE, + iTerminal_ID := iTerminal_ID, + bWcState := WcState_WcState, + uiInfoData_State := InfoData_State, + pErrorSystem := ErrorSystem, + bError => bError, + ); + + END_FUNCTION_BLOCK + + +Related: + * `FB_TerminalError`_ + * `ST_ErrorSystem`_ + + +EL9576_v1_00 +^^^^^^^^^^^^ + +:: + + ///EL9576 | Brake terminal (vap and resistor) + FUNCTION_BLOCK EL9576_v1_00 + VAR_INPUT + En: BOOL; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bError: BOOL; + OverTemperature: BOOL; + I2TError : BOOL; + I2TWarning : BOOL; + OverVoltage : BOOL; + UnderVoltage : BOOL; + ChopperOn : BOOL; + DCLinkVoltage : LREAL; + DutyCycle : LREAL; + ResistorCurrent : LREAL; + + END_VAR + VAR + BCTOverTemperature AT %I*: BOOL; + BCTI2TError AT %I*: BOOL; + BCTI2TWarning AT %I*: BOOL; + BCTOverVoltage AT %I*: BOOL; + BCTUnderVoltage AT %I*: BOOL; + BCTChopperOn AT %I*: BOOL; + BCTDCLinkVoltage AT %I*: UDINT; + BCTDutyCycle AT %I*: USINT; + BCTResistorCurrent AT %I*: UDINT; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + + END_VAR + EnO:=En; + + IF En AND (WcState_WcState OR InfoData_State<>16#8 OR BCTI2TError OR BCTI2TWarning OR BCTOverTemperature OR BCTOverVoltage OR BCTUnderVoltage) THEN + bError:=TRUE; + ELSE + bError:=FALSE; + END_IF + + OverTemperature:=BCTOverTemperature; + I2TError:=BCTI2TError; + I2TWarning:=BCTI2TWarning; + OverVoltage:=BCTOverVoltage; + UnderVoltage:=bctUnderVoltage; + ChopperOn:=bctChopperOn; + DCLinkVoltage:=UDINT_TO_LREAL(bctDCLinkVoltage); + DutyCycle:=USINT_TO_LREAL(BCTDutyCycle); + ResistorCurrent:=UDINT_TO_LREAL(BCTResistorCurrent); + + END_FUNCTION_BLOCK + + + + +F_AtPositionState +^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION F_AtPositionState : BOOL + (* + Check if the motor is within the state bounds + This will only run properly if FB_PositionStateInternal has been called on the position state to initialize it. + *) + VAR_INPUT + stMotionStage: ST_MotionStage; + stPositionState: ST_PositionState; + END_VAR + // If state is defined, we are within the delta, and we are either not moving or our destination is within the delta, we are at the state + F_AtPositionState := stPositionState.bValid AND stPositionState.bUpdated + AND F_PosWithinDelta(stMotionStage.stAxisStatus.fActPosition, stPositionState) + AND ((NOT stMotionStage.bExecute) OR F_PosWithinDelta(stMotionStage.fPosition, stPositionState)); + + END_FUNCTION + + +Related: + * `FB_PositionStateInternal`_ + * `F_PosWithinDelta`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +F_MotionErrorCodeLookup +^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION F_MotionErrorCodeLookup : STRING + VAR_INPUT + nErrorId: UDINT; + END_VAR + VAR + msg: STRING; + END_VAR + CASE nErrorId OF + // Common NC errors + 16#4221: msg:='Requested set velocity is not allowed'; + 16#4222: msg:='Requested set position is not allowed'; + 16#4223: msg:='No enable for controller and/or feed'; + 16#4225: msg:='Drive not ready during axis start'; + 16#4260: msg:='Drive disabled'; + 16#42A0: msg:='Coupled axis error'; + 16#4357: msg:='Negative limit hit'; + 16#4358: msg:='Positive limit hit'; + 16#4395: msg:='Set velocity not allowed'; + 16#4550: msg:='Stall: position lag monitoring error'; + 16#4650: msg:='Drive hardware not ready to operate'; + 16#4655: msg:='Invalid IO data'; + 16#4467: msg:='Encoder error: invalid actual position data'; + 16#4B07: msg:='Timeout axis function block after 6 seconds'; + 16#4FFF: msg:='Unknown NC error (not in manual)'; + + // Custom error definitions + 16#7900: msg:='Aborted move request with active move in progress'; + 16#7901: msg:='Position state unsafe'; + 16#7902: msg:='Position state invalid'; + 16#FFFF: msg:='Fake testing error'; + + // Fallbacks + 0: msg:=''; + ELSE + msg:='Contact PCDS to add new message'; + END_CASE + F_MotionErrorCodeLookup := msg; + + END_FUNCTION + + + + +F_PosOverLowerBound +^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION F_PosOverLowerBound : BOOL + VAR_INPUT + fPosition: LREAL; + stPositionState: ST_PositionState; + END_VAR + F_PosOverLowerBound := fPosition > (stPositionState.fPosition - ABS(stPositionState.fDelta)); + + END_FUNCTION + + +Related: + * `ST_PositionState`_ + + +F_PosUnderUpperBound +^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION F_PosUnderUpperBound : BOOL + VAR_INPUT + fPosition: LREAL; + stPositionState: ST_PositionState; + END_VAR + F_PosUnderUpperBound := fPosition < (stPositionState.fPosition + ABS(stPositionState.fDelta)); + + END_FUNCTION + + +Related: + * `ST_PositionState`_ + + +F_PosWithinDelta +^^^^^^^^^^^^^^^^ + +:: + + FUNCTION F_PosWithinDelta : BOOL + VAR_INPUT + fPosition: LREAL; + stPositionState: ST_PositionState; + END_VAR + F_PosWithinDelta := F_PosOverLowerBound(fPosition, stPositionState) AND + F_PosUnderUpperBound(fPosition, stPositionState); + + END_FUNCTION + + +Related: + * `F_PosOverLowerBound`_ + * `F_PosUnderUpperBound`_ + * `ST_PositionState`_ + + +FB_AtPositionState_Test +^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_AtPositionState_Test EXTENDS TcUnit.FB_TestSuite + (* + Test the following related helper functions: + - F_PosOverLowerBound + - F_PosUnderUpperBound + - F_PosWithinDelta + - F_AtPositionState + *) + VAR + // For the multi-cycle tests + stMotionStage: ST_MotionStage; + fbMotionStage: FB_MotionStage; + fbTestMove: FB_TestHelperSetAndMove; + stPositionStateInactive: ST_PositionState; + stPositionStateInvalid: ST_PositionState; + stPositionStateGood: ST_PositionState; + tonInactive: TON; + fbInternalGood: FB_PositionStateInternal; + fbInternalInvalid: FB_PositionStateInternal; + nTestCounter: UINT; + bOneTestDone: BOOL; + END_VAR + // Single cycle tests + TestPosOverLowerBoundYes(); + TestPosOverLowerBoundNo(); + TestPosUnderUpperBoundYes(); + TestPosUnderUpperBoundNo(); + TestPosWithinDeltaTooLow(); + TestPosWithinDeltaTooHigh(); + TestPosWithinDeltaJustRight(); + + // Multi cycle tests + fbMotionStage(stMotionStage:=stMotionStage); + stPositionStateInactive.sName := 'Inactive'; + stPositionStateInactive.fPosition := 30.0; + stPositionStateInactive.fDelta := 1.0; + stPositionStateInactive.bValid := TRUE; + tonInactive( + IN:=TRUE, + PT:=T#1s, + ); + TestAtPositionStateWithoutInternal(); + + stPositionStateInvalid.sName := 'Invalid'; + stPositionStateInvalid.fPosition := 40.0; + stPositionStateInvalid.fDelta := 1.0; + stPositionStateInvalid.bValid := FALSE; + fbInternalInvalid( + stMotionStage:=stMotionStage, + stPositionState:=stPositionStateInvalid, + ); + TestAtPositionStateInvalid(); + + stPositionStateGood.sName := 'Good'; + stPositionStateGood.fPosition := 50.0; + stPositionStateGood.fDelta := 1.0; + stPositionStateGood.bValid := TRUE; + fbInternalGood( + stMotionStage:=stMotionStage, + stPositionState:=stPositionStateGood, + ); + TestAtPositionStateTooLow(); + TestAtPositionStateTooHigh(); + TestAtPositionStateJustRight(); + TestAtPositionStateTweak(); + TestAtPositionStateLeave(); + + IF bOneTestDone THEN + bOneTestDone := FALSE; + nTestCounter := nTestCounter + 1; + fbTestMove( + stMotionStage:=stMotionStage, + bExecute:=FALSE, + ); + END_IF + + END_FUNCTION_BLOCK + + METHOD PRIVATE TestAtPositionStateInvalid + (* + If a position state is invalid, it is never the right state. + *) + VAR + + END_VAR + TEST('TestAtPositionStateInvalid'); + IF nTestCounter <> 1 THEN + RETURN; + END_IF + + fbTestMove( + stMotionStage:=stMotionstage, + bExecute:=TRUE, + fStartPosition:=stPositionStateInvalid.fPosition, + fGoalPosition:=stPositionStateInvalid.fPosition, + ); + IF fbTestMove.tElapsed > T#1s OR (stPositionStateInvalid.bUpdated AND fbTestMove.bSetDone) THEN + AssertFalse( + Condition:=F_AtPositionState( + stMotionStage:=stMotionStage, + stPositionState:=stPositionStateInvalid, + ), + Message:='Invalid state was marked OK', + ); + AssertFalse( + Condition:=fbTestMove.tElapsed > T#1s, + Message:='Timeout in multi cycle test', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD PRIVATE TestAtPositionStateJustRight + VAR + fLocalGoal: LREAL; + END_VAR + TEST('TestAtPositionStateJustRight'); + IF nTestCounter <> 4 THEN + RETURN; + END_IF + + fLocalGoal := stPositionStateGood.fPosition + 0.2*stPositionStateGood.fDelta; + fbTestMove( + stMotionStage:=stMotionstage, + bExecute:=TRUE, + fStartPosition:=fLocalGoal, + fGoalPosition:=fLocalGoal, + ); + IF fbTestMove.tElapsed > T#1s OR (stPositionStateGood.bUpdated AND fbTestMove.bSetDone) THEN + AssertTrue( + Condition:=F_AtPositionState( + stMotionStage:=stMotionStage, + stPositionState:=stPositionStateGood, + ), + Message:='Within delta counted as outside range', + ); + AssertFalse( + Condition:=fbTestMove.tElapsed > T#1s, + Message:='Timeout in multi cycle test', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD PRIVATE TestAtPositionStateLeave + (* + A move away from a state should be not at the state, even before we've left + *) + VAR + END_VAR + TEST('TestAtPositionStateLeave'); + IF nTestCounter <> 6 THEN + RETURN; + END_IF + + fbTestMove( + stMotionStage:=stMotionStage, + bExecute:=TRUE, + fStartPosition:=stPositionStateGood.fPosition, + fGoalPosition:=stPositionStateGood.fPosition + 100 * stPositionStateGood.fDelta, + fVelocity:=0.001, + bHWEnable:=TRUE, + ); + + IF fbTestMove.tElapsed > T#5s OR (stPositionStateGood.bUpdated AND fbTestMove.bMotionStarted) THEN + AssertTrue( + Condition:=fbTestMove.fActPosition < stPositionStateGood.fPosition + stPositionStateGood.fDelta, + Message:='We must be at the state location still to properly run this test.', + ); + AssertFalse( + Condition:=F_AtPositionState( + stMotionStage:=stMotionStage, + stPositionState:=stPositionStateGood, + ), + Message:='Leaving state is not at state once the move starts', + ); + AssertFalse( + Condition:=fbTestMove.tElapsed > T#5s, + Message:='Timeout in multi cycle test', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD PRIVATE TestAtPositionStateTooHigh + VAR + fLocalGoal: LREAL; + END_VAR + TEST('TestAtPositionStateTooHigh'); + IF nTestCounter <> 3 THEN + RETURN; + END_IF + + fLocalGoal := stPositionStateGood.fPosition + 2*stPositionStateGood.fDelta; + fbTestMove( + stMotionStage:=stMotionstage, + bExecute:=TRUE, + fStartPosition:=fLocalGoal, + fGoalPosition:=fLocalGoal, + ); + IF fbTestMove.tElapsed > T#1s OR (stPositionStateGood.bUpdated AND fbTestMove.bSetDone) THEN + AssertFalse( + Condition:=F_AtPositionState( + stMotionStage:=stMotionStage, + stPositionState:=stPositionStateGood, + ), + Message:='Above delta counted as in range', + ); + AssertFalse( + Condition:=fbTestMove.tElapsed > T#1s, + Message:='Timeout in multi cycle test', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD PRIVATE TestAtPositionStateTooLow + VAR + fLocalGoal: LREAL; + END_VAR + TEST('TestAtPositionStateTooLow'); + IF nTestCounter <> 2 THEN + RETURN; + END_IF + + fLocalGoal := stPositionStateGood.fPosition - 2*stPositionStateGood.fDelta; + fbTestMove( + stMotionStage:=stMotionstage, + bExecute:=TRUE, + fStartPosition:=fLocalGoal, + fGoalPosition:=fLocalGoal, + ); + IF fbTestMove.tElapsed > T#1s OR (stPositionStateGood.bUpdated AND fbTestMove.bSetDone) THEN + AssertFalse( + Condition:=F_AtPositionState( + stMotionStage:=stMotionStage, + stPositionState:=stPositionStateGood, + ), + Message:='Below delta counted as in range', + ); + AssertFalse( + Condition:=fbTestMove.tElapsed > T#1s, + Message:='Timeout in multi cycle test', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD PRIVATE TestAtPositionStateTweak + (* + A small tweak move within the delta of a position state should be OK + *) + VAR + + END_VAR + TEST('TestAtPositionStateTweak'); + IF nTestCounter <> 5 THEN + RETURN; + END_IF + + fbTestMove( + stMotionStage:=stMotionStage, + bExecute:=TRUE, + fStartPosition:=stPositionStateGood.fPosition, + fGoalPosition:=stPositionStateGood.fPosition + 0.9 * stPositionStateGood.fDelta, + fVelocity:=0.001, + bHWEnable:=TRUE, + ); + + IF fbTestMove.tElapsed > T#5s OR (stPositionStateGood.bUpdated AND fbTestMove.bMotionStarted) THEN + AssertTrue( + Condition:=F_AtPositionState( + stMotionStage:=stMotionStage, + stPositionState:=stPositionStateGood, + ), + Message:='Small tweak in range should count as at state', + ); + AssertFalse( + Condition:=fbTestMove.tElapsed > T#5s, + Message:='Timeout in multi cycle test', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD PRIVATE TestAtPositionStateWithoutInternal + (* + If a position state is never updated by the internal FB, it is never the right state. + *) + VAR + + END_VAR + TEST('TestAtPositionStateWithoutInternal'); + IF nTestCounter <> 0 THEN + RETURN; + END_IF + + fbTestMove( + stMotionStage:=stMotionstage, + bExecute:=TRUE, + fStartPosition:=stPositionStateInactive.fPosition, + fGoalPosition:=stPositionStateInactive.fPosition, + ); + IF fbTestMove.tElapsed > T#1s OR (stPositionStateInvalid.bUpdated AND fbTestMove.bSetDone) THEN + // Check for a different state to be bUpdated for timing purposes, this one never gets bUpdated + AssertFalse( + Condition:=F_AtPositionState( + stMotionStage:=stMotionStage, + stPositionState:=stPositionStateInactive, + ), + Message:='This is the control group, internal was not run so this should not work', + ); + AssertFalse( + Condition:=fbTestMove.tElapsed > T#1s, + Message:='Timeout in multi cycle test', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD PRIVATE TestPosOverLowerBoundNo + VAR + stPositionState: ST_PositionState; + END_VAR + TEST('TestPosOverLowerBoundNo'); + stPositionState.fPosition := 10; + stPositionState.fDelta := 1; + + AssertFalse( + Condition:=F_PosOverLowerBound( + fPosition:=8.5, + stPositionState:=stPositionState, + ), + Message:='Decided 8.5 > 9.0', + ); + TEST_FINISHED(); + END_METHOD + + METHOD PRIVATE TestPosOverLowerBoundYes + VAR + stPositionState: ST_PositionState; + END_VAR + TEST('TestPosOverLowerBoundYes'); + stPositionState.fPosition := 10; + stPositionState.fDelta := 1; + + AssertTrue( + Condition:=F_PosOverLowerBound( + fPosition:=9.1, + stPositionState:=stPositionState, + ), + Message:='Decided 9.0 > 9.1', + ); + TEST_FINISHED(); + END_METHOD + + METHOD PRIVATE TestPosUnderUpperBoundNo + VAR + stPositionState: ST_PositionState; + END_VAR + TEST('TestPosUnderUpperBoundNo'); + stPositionState.fPosition := 10; + stPositionState.fDelta := 1; + + AssertFalse( + Condition:=F_PosUnderUpperBound( + fPosition:=12.0, + stPositionState:=stPositionState, + ), + Message:='Decided 11.0 > 12.0', + ); + TEST_FINISHED(); + END_METHOD + + METHOD PRIVATE TestPosUnderUpperBoundYes + VAR + stPositionState: ST_PositionState; + END_VAR + TEST('TestPosUnderUpperBoundYes'); + stPositionState.fPosition := 10; + stPositionState.fDelta := 1; + + AssertTrue( + Condition:=F_PosUnderUpperBound( + fPosition:=10.9, + stPositionState:=stPositionState, + ), + Message:='Decided 10.9 > 11.0', + ); + TEST_FINISHED(); + END_METHOD + + METHOD PRIVATE TestPosWithinDeltaJustRight + VAR + stPositionState: ST_PositionState; + END_VAR + TEST('TestPosWithinDeltaJustRight'); + stPositionState.fPosition := 20; + stPositionState.fDelta := 1; + + AssertTrue( + Condition:=F_PosWithinDelta( + fPosition:=20.2, + stPositionState:=stPositionState, + ), + Message:='Decided 20.2 not within 19 to 21 bounds', + ); + TEST_FINISHED(); + END_METHOD + + METHOD PRIVATE TestPosWithinDeltaTooHigh + VAR + stPositionState: ST_PositionState; + END_VAR + TEST('TestPosWithinDeltaTooHigh'); + stPositionState.fPosition := 20; + stPositionState.fDelta := 1; + + AssertFalse( + Condition:=F_PosWithinDelta( + fPosition:=25.0, + stPositionState:=stPositionState, + ), + Message:='Decided 21.0 > 25.0', + ); + TEST_FINISHED(); + END_METHOD + + METHOD PRIVATE TestPosWithinDeltaTooLow + VAR + stPositionState: ST_PositionState; + END_VAR + TEST('TestPosWithinDeltaTooLow'); + stPositionState.fPosition := 20; + stPositionState.fDelta := 1; + + AssertFalse( + Condition:=F_PosWithinDelta( + fPosition:=12.0, + stPositionState:=stPositionState, + ), + Message:='Decided 12.0 > 19.0', + ); + TEST_FINISHED(); + END_METHOD + + +Related: + * `FB_MotionStage`_ + * `FB_PositionStateInternal`_ + * `FB_TestHelperSetAndMove`_ + * `F_AtPositionState`_ + * `F_PosOverLowerBound`_ + * `F_PosUnderUpperBound`_ + * `F_PosWithinDelta`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_CalculateFrequency_3702_v0_01 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_CalculateFrequency_3702_v0_01 + VAR CONSTANT + ///200 samples/period + cBufferSize: INT := 1000; + END_VAR + VAR_INPUT + En: BOOL; + bCalculate: BOOL; + aBufferValue: ARRAY[0..(cBuffersize - 1)] OF INT; + aBufferDcTime: ARRAY[0..(cBuffersize - 1)] OF UDINT; + ///If curve has a DC offset + nDCOffset: INT := 0; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bError: BOOL; + fActFrequency: LREAL; + END_VAR + VAR + nIndex: INT; + nFirstZeroCrossing: INT; + nLastZeroCrossing: INT; + rTimeFirst: REAL := 0; + rTimeLast: REAL := 0; + rTimeRes: REAL := 0; + nCrossings: INT := 0; + END_VAR + VAR_TEMP + rRange: REAL := 0; + rTimeSpan: REAL := 0; + END_VAR + EnO:=En; + bError:=FALSE; + nCrossings:=0; + IF En AND bCalculate THEN + //Serach for crossings of nDCOffset + FOR nIndex:=1 TO cBuffersize-1 DO + IF((aBufferValue[nIndex]>nDCOffset AND aBufferValue[nIndex-1]<=nDCOffset) OR (aBufferValue[nIndex]=nDCOffset)) THEN + IF(nCrossings=0) THEN + nFirstZeroCrossing:=nIndex; + END_IF + nLastZeroCrossing:=nIndex; + nCrossings:=nCrossings+1; + END_IF + END_FOR + + IF nFirstZeroCrossing < nLastZeroCrossing AND nCrossings>2 THEN + //interpolate zero crossings for higher accuracy + rTimeRes:=UDINT_TO_REAL(aBufferDcTime[1]-aBufferDcTime[0]); //Buffer must contain more than 2 values + rRange:=INT_TO_REAL(ABS(aBufferValue[nFirstZeroCrossing-1]-aBufferValue[nFirstZeroCrossing])); + rTimeFirst:=UDINT_TO_REAL( aBufferDcTime[nFirstZeroCrossing-1])+ABS(INT_TO_REAL(aBufferValue[nFirstZeroCrossing-1])/rRange*rTimeRes); + rRange:=INT_TO_REAL(ABS(aBufferValue[nLastZeroCrossing-1]-aBufferValue[nLastZeroCrossing])); + rTimeLast:=UDINT_TO_REAL( aBufferDcTime[nLastZeroCrossing-1])+ABS(INT_TO_REAL(aBufferValue[nLastZeroCrossing-1])/rRange*rTimeRes); + + //Time span first to last (considering that max one time counter overflow have occured in the total time range of the time buffer) + IF rTimeFirst Average frequency over buffer. + ELSE + fActFrequency:=0; + END_IF + END_IF + + END_FUNCTION_BLOCK + + + + +FB_CauseNCError +^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_CauseNCError + (* + Simulate an NC error. + This will look like a real NC error for everyone, including TwinCAT itself. + *) + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_INPUT + bExecute: BOOL; + nErrorCode: UDINT; + END_VAR + VAR_OUTPUT + bBusy: BOOL; + bDone: BOOL; + END_VAR + VAR + rtExec: R_TRIG; + adsWrite: ADSWRITE; + mcReadDriveAddress: MC_ReadDriveAddress; + END_VAR + rtExec(CLK:=bExecute); + IF NOT bExecute THEN + bDone := FALSE; + END_IF + IF rtExec.Q THEN + bBusy := TRUE; + END_IF + IF bBusy AND NOT mcReadDriveAddress.Done THEN + mcReadDriveAddress( + Axis:=Axis, + Execute:=TRUE, + DriveAddress=>Axis.DriveAddress); + END_IF + IF bBusy AND mcReadDriveAddress.Done THEN + bBusy := TRUE; + adsWrite( + PORT:=501, + IDXGRP:=16#4200 + Axis.DriveAddress.NcDriveId, + IDXOFFS:=16#0019, + LEN:=SIZEOF(nErrorCode), + SRCADDR:=ADR(nErrorCode), + WRITE:=TRUE, + BUSY=>bBusy); + IF NOT bBusy THEN + bDone := TRUE; + adsWrite(WRITE:=FALSE); + END_IF + END_IF + + END_FUNCTION_BLOCK + + + + +FB_DriveVirtual +^^^^^^^^^^^^^^^ + +:: + + ///######################################################### + ///Function block to run a virtual drive with Nc + /// Library: + /// Tc2_MC2.lib + /// + /// Global Variables: + /// + /// Data types: + /// + /// External functions: + /// + ///########################################################### + FUNCTION_BLOCK FB_DriveVirtual + VAR + sVersion: STRING:='1.0.3'; + END_VAR + VAR_INPUT + En: BOOL; + bEnable: BOOL; + bReset: BOOL; + bExecute: BOOL; + ///// nCommandLocal... + ///// 0 = Jog + ///// 1 = MoveVelocity + ///// 2 = MoveRelative + ///// 3 = MoveAbsolut + ///// 4 = MoveModulo + ///// 10 = Homing + ///// 20 = SuperInp >>>ToBe + ///// 30 = Gear + nCommand: UINT; + nCmdData: UINT; + fVelocity: LREAL; + fPosition: LREAL; + fAcceleration: LREAL; + fDeceleration: LREAL; + bJogFwd: BOOL; + bJogBwd: BOOL; + bLimitFwd: BOOL; + bLimitBwd: BOOL; + fOverride: LREAL := 100; + bHomeSensor: BOOL; + fHomePosition:LREAL; + nHomeRevOffset: UINT; + MasterAxis: AXIS_REF; + bPowerSelf: BOOL; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bEnabled: BOOL; + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + bHomed: BOOL; + nErrorId: UDINT; + nMotionAxisID:UDINT:=0; //Axis id in Motion (NC) + Status: ST_AxisStatus; + fActVelocity: LREAL; + fActPosition: LREAL; + fActDiff: LREAL; + sErrorMessage:STRING; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR + nCommandLocal: UINT; + nCmdDataLocal: UINT; + bFirstScan: BOOL := TRUE; + fbReset: MC_Reset; + fbPower: MC_Power; + fbHalt: MC_Halt; + fbJog: MC_Jog; + fbMoveVelocity: MC_MoveVelocity; + fbMoveRelative: MC_MoveRelative; + fbMoveAbsolute: MC_MoveAbsolute; + fbMoveModulo: MC_MoveModulo; + fbHomeVirtual:FB_HomeVirtual; + fbGearInDyn: MC_GearInDyn; + fbGearOut: MC_GearOut; + fbExecuteRiseEdge: R_TRIG; + stAxisStatus: DUT_AxisStatus_v0_01; + END_VAR + EnO:=En; + + // Transfer nCommand and nCmdData to local copies at rising edge of bExecute (avoid issues if nCommand or nCmdData are changed during a command) + fbExecuteRiseEdge(CLK:=bExecute); + IF fbExecuteRiseEdge.Q THEN + nCmdDataLocal:=nCmdData; + nCommandLocal:=nCommand; + END_IF + + bHomed:=fbHomeVirtual.bHomed; //Add in DUT_AxisStatus later + bDone:=FALSE; + + (*Reset*) + fbReset( + Execute:=bReset AND Axis.Status.Error, + Axis:=Axis, + Done=> , + Busy=> , + Error=> , + ErrorID=> ); + + (*Power*) + IF bPowerSelf THEN + fbPower( + Axis:=Axis, + Enable:=bEnable, + Enable_Positive:=bEnable AND bLimitFwd, + Enable_Negative:=bEnable AND bLimitBwd, + Override:=fOverride, + BufferMode:= , + Status=> , + Busy=> , + Active=> , + Error=> , + ErrorID=> ); + END_IF + + (*Halt*) + fbHalt( + Execute:=NOT bExecute AND (((fbMoveVelocity.Busy OR fbPower.Busy) AND (nCommandLocal=1)) OR (fbMoveRelative.Busy AND (nCommandLocal=2)) OR (fbMoveAbsolute.Busy AND (nCommandLocal=3)) OR (fbMoveModulo.Busy AND (nCommandLocal=4)) OR (fbHomeVirtual.bBusy AND (nCommandLocal=10))), + Deceleration:=fDeceleration, + Jerk:=0, + BufferMode:= , + Options:= , + Axis:=Axis , + Done=> , + Busy=> , + Active=> , + CommandAborted=> , + Error=> , + ErrorID=> ); + + (*Jog (Command = 0)*) + fbJog( + JogForward:=bJogFwd AND (nCommandLocal=0) , + JogBackwards:=bJogBwd AND (nCommandLocal=0) , + Mode:=UINT_TO_INT(nCmdDataLocal), + Position:= , + Velocity:=fVelocity, + Acceleration:=fAcceleration, + Deceleration:=fDeceleration, + Jerk:=0, + Axis:=Axis, + Done=> , + Busy=> , + Active=> , + CommandAborted=> , + Error=> , + ErrorID=> ); + + (*MoveVelocity (Command = 1)*) + fbMoveVelocity( + Execute:=bExecute AND (nCommandLocal=1), + Velocity:=ABS(fVelocity), + Acceleration:=fAcceleration, + Deceleration:=fDeceleration, + Jerk:=0, + Direction:=SEL(fVelocity<0, MC_Positive_Direction, MC_Negative_Direction), + BufferMode:= , + Options:= , + Axis:=Axis, + InVelocity=> , + Busy=> , + Active=> , + CommandAborted=> , + Error=> , + ErrorID=> ); + + (*MoveRelative (Command = 2)*) + fbMoveRelative( + Execute:=bExecute AND (nCommandLocal=2), + Distance:=fPosition, + Velocity:=ABS(fVelocity), + Acceleration:=fAcceleration, + Deceleration:=fDeceleration, + Jerk:=0, + BufferMode:= , + Options:= , + Axis:=Axis, + Done=> , + Busy=> , + Active=> , + CommandAborted=> , + Error=> , + ErrorID=> ); + + IF nCommandLocal=2 THEN + bDone:=fbMoveRelative.Done; + END_IF + + (*MoveAbsolute (Command = 3)*) + fbMoveAbsolute( + Execute:=bExecute AND (nCommandLocal=3), + Position:=fPosition, + Velocity:=ABS(fVelocity), + Acceleration:=fAcceleration, + Deceleration:=fDeceleration, + Jerk:=0, + BufferMode:= , + Options:= , + Axis:=Axis, + Done=> , + Busy=> , + Active=> , + CommandAborted=> , + Error=> , + ErrorID=> ); + + IF nCommandLocal=3 THEN + bDone:=fbMoveAbsolute.Done; + END_IF + + (*MoveModulo (Command = 4)*) + fbMoveModulo( + Execute:=bExecute AND (nCommandLocal=4), + Position:=fPosition, + Velocity:=ABS(fVelocity), + Acceleration:=fAcceleration, + Deceleration:=fDeceleration, + Jerk:=0, + Direction:=UINT_TO_INT(nCmdDataLocal), + BufferMode:= , + Options:= , + Axis:=Axis, + Done=> , + Busy=> , + Active=> , + CommandAborted=> , + Error=> , + ErrorID=> ); + + IF nCommandLocal=4 THEN + bDone:=fbMoveModulo.Done; + END_IF + + (*Home (Command = 10)*) + fbHomeVirtual( + bExecute:= nCommandLocal=10 AND bExecute, + fHomePosition:=fHomePosition, + bHomeSensor:=bHomeSensor, + bLimitBwd:=bLimitBwd, + bLimitFwd:=bLimitFwd, + nCmdData:=nCmdDataLocal, + bReset:=bReset, + nHomeRevOffset:=nHomeRevOffset, + Axis:=Axis + ); + + IF nCommandLocal=10 THEN + bDone:=fbHomeVirtual.bDone; + END_IF + + (*Gear (Command = 30)*) + fbGearInDyn( + Enable:=bExecute AND (nCommandLocal=30), + GearRatio:=SEL(nCmdDataLocal>0, 1,fVelocity), + Acceleration:=fAcceleration, + Deceleration:=fDeceleration, + Jerk:=0.0, + BufferMode:= , + Options:= , + Master:=MasterAxis, + Slave:=Axis, + InGear=> , + Busy=> , + Active=> , + CommandAborted=> , + Error=> , + ErrorID=> ); + + fbGearOut( + Execute:=NOT bExecute AND Axis.Status.NotMoving AND (nCommandLocal=30), + Slave:=Axis, + Error=>, + Done=>, + ErrorID=>); + + + IF nCommandLocal=30 THEN + bDone:=Axis.Status.Coupled; + END_IF + + (*Busy*) + bBusy:=Axis.Status.HasJob OR Axis.Status.HomingBusy OR fbHomeVirtual.bBusy; + + (*Enabled*) + bEnabled:=fbPower.Status; + + (*Error from functions and Nc*) + IF fbPower.Error AND fbPower.Active THEN + bError:=fbPower.Enable; + nErrorId:=fbPower.ErrorID; + ELSIF fbHalt.Error AND fbHalt.Active THEN + bError:=fbHalt.Execute; + nErrorId:=fbHalt.ErrorID; + ELSIF fbJog.Error AND nCommandLocal=0 (*fbJog.Active*) THEN + bError:=fbJog.JogForward OR fbJog.JogBackwards; + nErrorId:=fbJog.ErrorID; + ELSIF fbMoveVelocity.Error AND nCommandLocal=1(*fbMoveVelocity.Active*) THEN + bError:=fbMoveVelocity.Execute; + nErrorId:=fbMoveVelocity.ErrorID; + ELSIF fbMoveRelative.Error AND nCommandLocal=2 (*fbMoveRelative.Active*) THEN + bError:=fbMoveRelative.Execute; + nErrorId:=fbMoveRelative.ErrorID; + ELSIF fbMoveAbsolute.Error AND nCommandLocal=3 (*fbMoveAbsolute.Active*) THEN + bError:=fbMoveAbsolute.Execute; + nErrorId:=fbMoveAbsolute.ErrorID; + ELSIF fbMoveModulo.Error AND nCommandLocal=4 (*fbMoveModulo.Active*) THEN + bError:=fbMoveModulo.Execute; + nErrorId:=fbMoveModulo.ErrorID; + ELSIF fbHomeVirtual.bError AND nCommandLocal=10 (*fbHome.Active*) THEN + bError:=fbHomeVirtual.bError; + nErrorId:=fbHomeVirtual.nErrorID; + ELSIF fbGearInDyn.Error AND nCommandLocal=30 (*fbGearInDyn.Active*) THEN + bError:=fbGearInDyn.Enable; + nErrorId:=fbGearInDyn.ErrorID; + ELSIF fbGearOut.Error AND nCommandLocal=30 AND Axis.Status.Coupled THEN + bError:=fbGearOut.Execute; + nErrorId:=fbGearOut.ErrorID; + ELSIF Axis.Status.Error THEN + bError:=TRUE; + nErrorId:=Axis.Status.ErrorID; + ELSIF fbHomeVirtual.bError THEN + bError:=TRUE; + nErrorId:=fbHomeVirtual.nErrorId; + ELSE + bError:=FALSE; + nErrorId:=0; + END_IF; + + (*Converese nErrorID to string*) + sErrorMessage:=WORD_TO_HEXSTR(in:=TO_WORD(nErrorID) , iPrecision:= 4, bLoCase:=0 ); + + (*Status from Nc*) + Status:=Axis.Status; + + (*Axis id in motion "motor"*) + nMotionAxisID:=axis.NcToPlc.AxisId; + + (*Actual Velocity*) + fActVelocity:=Axis.NcToPlc.ActVelo; + + (*Actual Position*) + IF Axis.Status.OpMode.Modulo THEN + fActPosition:=Axis.NcToPlc.ModuloActPos; + ELSE + fActPosition:=Axis.NcToPlc.ActPos; + END_IF + + (*Actual Position*) + fActDiff:=Axis.NcToPlc.PosDiff; + + + //Status struct for EPICS communication + stAxisStatus.bEnable:=bEnable; + stAxisStatus.bEnabled:=bEnabled; + stAxisStatus.bError:=bError; + stAxisStatus.bExecute:=bExecute; + stAxisStatus.bHomeSensor:=bHomeSensor; + stAxisStatus.bJogBwd:=bJogBwd; + stAxisStatus.bJogFwd:=bJogFwd; + stAxisStatus.bLimitBwd:=bLimitBwd; + stAxisStatus.bLimitFwd:=bLimitFwd; + stAxisStatus.bReset:=bReset; + stAxisStatus.fAcceleration:=fAcceleration; + stAxisStatus.fActDiff:=fActDiff; + stAxisStatus.fActPosition:=fActPosition; + stAxisStatus.fActVelocity:=fActVelocity; + stAxisStatus.fDeceleration:=fDeceleration; + stAxisStatus.fOverride:=fOverride; + stAxisStatus.fPosition:=fPosition; + stAxisStatus.fVelocity:=fVelocity; + stAxisStatus.nCmdData:=nCmdData; //Or nCmdDataLocal + stAxisStatus.nCommand:=nCommand; //Or nCommandLocal + stAxisStatus.nErrorId:=nErrorId; + stAxisStatus.bBusy:=bBusy; + stAxisStatus.bHomed:=bHomed; + + IF bFirstScan THEN + bFirstScan:=FALSE; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `DUT_AxisStatus_v0_01`_ + * `FB_HomeVirtual`_ + + +FB_EL1252ASM_v1_00 +^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_EL1252ASM_v1_00 + VAR_INPUT + En: BOOL; + END_VAR + VAR_OUTPUT + EnO: BOOL; + Di_1: BOOL; + Di_2: BOOL; + Di_1_LatchTimePos: ULINT; + Di_2_LatchTimePos: ULINT; + Di_1_LatchTimeNeg: ULINT; + Di_2_LatchTimeNeg: ULINT; + ///Below bits can be used but then they must be enabled in the COE of the card. Nicklas suggested to not use these (since something wss written that you then only were allowed to read the latch time onece (some kkind of auto reset??)) + ///Di_1_LatchNeg:BOOL; + /// Di_1_LatchPos:BOOL; + /// Di_2_LatchNeg:BOOL; + /// Di_2_LatchPos:BOOL; + Error: BOOL; + END_VAR + VAR + Channel_1_Input AT %I*: BOOL; + Channel_2_Input AT %I*: BOOL; + ///Latch_Status1 AT %I*: USINT; + /// Latch_Status2 AT %I*: USINT; + Latch_LatchPos1 AT %I*: ULINT; + Latch_LatchNeg1 AT %I*: ULINT; + Latch_LatchPos2 AT %I*: ULINT; + Latch_LatchNeg2 AT %I*: ULINT; + WcState_WcState AT %I*: BOOL; + InfoData_State AT %I*: UINT; + END_VAR + EnO:=En; + + IF En AND (WcState_WcState OR InfoData_State<>16#8) THEN //InfoData_State==0 => in OP mode + Error:=TRUE; + ELSE + Error:=FALSE; + END_IF + + IF En THEN + IF Error=FALSE THEN + Di_1:=Channel_1_Input; + Di_2:=Channel_2_Input; + (* Di_1_LatchPos:=Latch_Status1.0; + Di_1_LatchNeg:=Latch_Status1.1; + Di_2_LatchPos:=Latch_Status2.0; + Di_2_LatchNeg:=Latch_Status2.1;*) + Di_1_LatchTimePos:=Latch_LatchPos1; + Di_2_LatchTimePos:=Latch_LatchPos2; + Di_1_LatchTimeNeg:=Latch_LatchNeg1; + Di_2_LatchTimeNeg:=Latch_LatchNeg2; + + ELSE + Di_1:=FALSE; + Di_2:=FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + + + +FB_EncErrorFFO +^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_EncErrorFFO + (* + Example usage of FB_NCErrorFFO that only counts encoder errors as faults. + *) + VAR_IN_OUT + // Motion stage to monitor + stMotionStage: ST_MotionStage; + // FFO to trip + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + // Reset the fault + bReset: BOOL; + // Auto reset the fault + bAutoReset: BOOL; + END_VAR + VAR_OUTPUT + // Quick way for nearby code to check if this block has tripped the FFO. + bTripped: BOOL; + END_VAR + VAR + fbNCErrorFFO: FB_NCErrorFFO := ( + nLowErrorId := 16#4400, + nHighErrorId := 16#44FF, + sDesc := 'Encoder error'); + END_VAR + fbNCErrorFFO( + stMotionStage := stMotionStage, + fbFFHWO := fbFFHWO, + bReset := bReset, + bAutoReset := bAutoReset, + bTripped => bTripped); + + END_FUNCTION_BLOCK + + +Related: + * `FB_NCErrorFFO`_ + * `ST_MotionStage`_ + + +FB_EncoderValue +^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_EncoderValue + (* + Process the encoder value for ST_MotionStage + + A few different problems this is trying to solve: + 1. Different encoders show as different types in the IO, + but we want a consistent type for checks and for PVs + 2. Some inverted encoders display as very high numbers + as they count down from max int instead of up from 0 + 3. Some encoders have raw signed values, others unsigned. + + To this end, we figure out which encoder is linked and process + the value appropriately. + *) + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + IF stMotionStage.nRawEncoderULINT <> 0 THEN + IF stMotionStage.nRawEncoderULINT < 4294967296 THEN + stMotionStage.nEncoderCount := ULINT_TO_UDINT(stMotionStage.nRawEncoderULINT); + ELSE + stMotionStage.nEncoderCount := ULINT_TO_UDINT(18446744073709551615 - stMotionStage.nRawEncoderULINT); + END_IF + ELSIF stMotionStage.nRawEncoderUINT <> 0 THEN + stMotionStage.nEncoderCount := UINT_TO_UDINT(stMotionStage.nRawEncoderUINT); + ELSIF stMotionStage.nRawEncoderINT <> 0 THEN + stMotionStage.nEncoderCount := INT_TO_UDINT(stMotionStage.nRawEncoderINT); + ELSE + stMotionStage.nEncoderCount := 0; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `ST_MotionStage`_ + + +FB_EncSaveRestore +^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_EncSaveRestore + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + VAR_INPUT + bEnable: BOOL; + END_VAR + VAR_OUTPUT + END_VAR + VAR + fbSetPos: MC_SetPosition; + timer: TON; + bInit: BOOL; + bLoad: BOOL; + nLatchError: UDINT; + bEncError: BOOL; + tRetryDelay: TIME := T#1s; + nMaxRetries: UINT := 10; + nCurrTries: UINT := 0; + bWaitRetry: BOOL; + tonRetry: TON; + END_VAR + VAR PERSISTENT + bSaved: BOOL; + fPosition: LREAL; + END_VAR + IF bEnable THEN + // Trigger a load if anything was saved at all + IF NOT bInit THEN + bInit := TRUE; + bLoad S= bSaved; + fbSetPos.Options.ClearPositionLag := TRUE; + END_IF + + // Set our position if bLoad is true + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=bLoad, + Position:=fPosition); + + // Only load once, at startup + bLoad R= fbSetPos.Done OR fbSetPos.Error; + + IF fbSetPos.Error THEN + // Keep the error latched, it can disappear if Execute is set to FALSE + nLatchError := fbSetPos.ErrorID; + nCurrTries := nCurrTries + 1; + IF nCurrTries >= nMaxRetries THEN + // Alert the user that something has gone wrong + stMotionStage.bError := TRUE; + stMotionStage.nErrorId := nLatchError; + stMotionStage.sCustomErrorMessage := 'Error loading previously saved position.'; + ELSE + // Reset the FB for the next retry + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=FALSE, + Position:=fPosition); + // Try again + bWaitRetry := TRUE; + END_IF + END_IF + + tonRetry( + IN := bWaitRetry, + PT := tRetryDelay); + + bLoad S= tonRetry.Q; + bWaitRetry R= tonRetry.Q; + + // Check ST_MotionStage for an encoder error (range 0x44nn) + bEncError := stMotionStage.bError AND stMotionStage.nErrorId >= 16#4400 AND stMotionStage.nErrorId <= 16#44FF; + + // Do not save if we're currently loading or if there is an encoder error + IF NOT bLoad AND NOT bEncError AND NOT bWaitRetry THEN + fPosition := stMotionStage.stAxisStatus.fActPosition; + // This persistent variable lets us check if anything was saved + // It will be TRUE at startup if we have saved values + bSaved := TRUE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `ST_MotionStage`_ + + +FB_EpicsInOut +^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use FB_PositionState1D_InOut instead'} + FUNCTION_BLOCK FB_EpicsInOut + // Example usage of FB_PositionStateManager for a simple IN/OUT axis. See NOTE: comments. + // Also usable as a drop-in for these cases (no need to roll your own in/out) + VAR_IN_OUT + // Motor to apply states to + stMotionStage: ST_MotionStage; + // Information about the OUT position + stOut: ST_PositionState; // NOTE: Do not pragma these, let it happen in the manager. + // Information about the IN parameter + stIn: ST_PositionState; + END_VAR + VAR_INPUT + // If TRUE, the motor will be moved when enumSet is changed + bEnable: BOOL; + // When changed, sets the destination and starts a move + {attribute 'pytmc' := ' + pv: SET + io: io + '} + enumSet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumSet + END_VAR + VAR_OUTPUT + // If TRUE, we are in an error state + bError: BOOL; // NOTE: do not pragma these, already has pragma in manager + // Error code + nErrorId: UDINT; + // Message associated with bError = TRUE + sErrorMessage: STRING; + // If TRUE, we are currently moving between states + bBusy: BOOL; + // If TRUE, we asked for a move between states, it completed successfully, and there is no ongoing move + bDone: BOOL; + // The current state readback + {attribute 'pytmc' := ' + pv: GET + io: i + '} + enumGet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumGet + END_VAR + VAR + bInit: BOOL; + arrStates: ARRAY[1..15] OF ST_PositionState; + + {attribute 'pytmc' := ' + pv: + io: io + '} + fbStateManager: FB_PositionStateManager; // NOTE: Please copy this pragma exactly to pick up the standard PVs + END_VAR + // Fist cycle setup + IF NOT bInit THEN + stOut.sName := 'OUT'; + stIn.sName := 'IN'; + bInit := TRUE; + END_IF + + // Stuff first two values of the 15 element array for the manager + arrStates[1] := stOut; + arrStates[2] := stIn; + + // Call the function block every cycle + fbStateManager( + stMotionStage := stMotionStage, + arrStates := arrStates, + setState := enumSet, + bEnable := bEnable, + bError => bError, + nErrorId => nErrorId, + sErrorMessage => sErrorMessage, + bBusy => bBusy, + bDone => bDone, + getState => enumGet); // Cannot do this assignment if enumGet has attribute strict + + END_FUNCTION_BLOCK + + +Related: + * `ENUM_EpicsInOut_INT`_ + * `FB_PositionState1D_InOut`_ + * `FB_PositionStateManager`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_ErrorList +^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_ErrorList + + VAR_INPUT + En : BOOL; //Enable input + bReset : BOOL; //Delete all Error entry + lErrorID : ULINT; //ErrorID to be acknoledged + bACK : BOOL; //Acknoledge the given error and delete it from the list + END_VAR + + VAR_OUTPUT + EnO : BOOL; //Enable output + nNoError: UINT; //Number of Errors + nNoOverflow : INT; //Number of Overflows + pErrorSystem : POINTER TO ST_ErrorSystem; //Pointer to ErrorSystem + END_VAR + + VAR + nFreePos : UINT; //Number of free position in the list + nListCnt1 : UINT; //work variable + ErrorSystem : ST_ErrorSystem; //Data structure of the Error list + END_VAR + (* + * ================================================================================ + * DESCRIPTION + * ================================================================================ + * This Function Block implements the core structure of the Error/Warning Handling + * system. It realizes the datastructure containing every Error Entry, collect + * statistics about the usage and manage the Error Entries. + * Note: The system is under development, most of the functionalities are not + * implemented or existing functionalities may change with time. + * ================================================================================ + *) + EnO := En; + + //Ponter to ErrorSystem + pErrorSystem := ADR(ErrorSystem); + + //Number of overflows + nNoOverflow := ErrorSystem.nNoOverflows; + + IF bReset THEN + MEMSET ( ADR(ErrorSystem.aErrorData[0]), 0, GVL_ErrorSystem.cSizeOfErrorData * SIZEOF(DUT_TerminalError)); + ErrorSystem.lNextErrorID := 1; + END_IF + + //Number of errors in the system + nNoError := 0; + FOR nListCnt1 := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO + IF ErrorSystem.aErrorData[nListCnt1].Error_ID <> 0 THEN + nNoError := nNoError+1; + END_IF + END_FOR + ErrorSystem.nNoErrors := nNoError; + + //Number of free position in the list + nFreePos := GVL_ErrorSystem.cSizeOfErrorData - nNoError; + + //Acknoledge specified Error entry + IF bACK THEN + FOR nListCnt1 := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO + IF ErrorSystem.aErrorData[nListCnt1].Error_ID = lErrorID THEN + ErrorSystem.aErrorData[nListCnt1].ErrorState := DUT_ErrorState.Acknowledged; + END_IF + END_FOR + END_IF + + //Deleting acknoledged errors + FOR nListCnt1 := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO + IF ErrorSystem.aErrorData[nListCnt1].ErrorState = DUT_ErrorState.Acknowledged THEN + MEMMOVE (ADR(ErrorSystem.aErrorData[nListCnt1]), ADR(ErrorSystem.aErrorData[nListCnt1+1]), (GVL_ErrorSystem.cSizeOfErrorData - 1 - nListCnt1) * SIZEOF(DUT_TerminalError)); + MEMSET(ADR(ErrorSystem.aErrorData[GVL_ErrorSystem.cSizeOfErrorData - 1]), 0, SIZEOF(DUT_TerminalError)); + END_IF + END_FOR + + END_FUNCTION_BLOCK + + +Related: + * `DUT_ErrorState`_ + * `DUT_TerminalError`_ + * `GVL_ErrorSystem`_ + * `ST_ErrorSystem`_ + + +FB_GantryAutoCoupling +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_GantryAutoCoupling + VAR_INPUT + nGantryTol : LINT; + END_VAR + VAR_OUTPUT + bGantryAlreadyCoupled : BOOL; + END_VAR + VAR_IN_OUT + Master : ST_MotionStage; + MasterEnc : ST_RenishawAbsEnc; + Slave : ST_MotionStage; + SlaveEnc : ST_RenishawAbsEnc; + bExecuteCouple : BOOL; + bExecuteDecouple : BOOL; + END_VAR + VAR + gantry_diff_limit : FB_GantryDiffVirtualLimitSwitch; + couple : MC_GEARIN; + decouple : MC_GEAROUT; + bInitComplete : BOOL; + fbSetEnables : FB_SetEnables; + END_VAR + // Designate Master and SLave Axes + Master.bGantryAxis := TRUE; + Slave.bGantryAxis := TRUE; + + Master.nGantryTol := nGantryTol; + Slave.nGantryTol := Master.nGantryTol; + + // Activate Gantry Virtual Limit Switch + gantry_diff_limit(Penc:=MasterEnc, SEnc:=SlaveEnc, GantDiffTol:=Master.nGantryTol, + PLimFwd=>Master.bGantryForwardEnable, PLimBwd=>Master.bGantryBackwardEnable, + SLimFwd=>Slave.bGantryForwardEnable, SLimBwd=>Slave.bGantryBackwardEnable); + + // Coupling Status Bit + bGantryAlreadyCoupled := Master.Axis.NcToPlc.CoupleState=1 AND Slave.Axis.NcToPlc.CoupleState=3; + + fbSetEnables(stMotionStage:=Master); + fbSetEnables(stMotionStage:=Slave); + + IF bGantryAlreadyCoupled THEN + Master.bGantryForwardEnable := Master.bGantryForwardEnable AND Slave.bAllForwardEnable; + Slave.bGantryForwardEnable := Master.bAllForwardEnable AND Slave.bGantryForwardEnable; + + Master.bGantryBackwardEnable := Master.bGantryBackwardEnable AND Slave.bAllBackwardEnable; + Slave.bGantryBackwardEnable := Master.bAllBackwardEnable AND Slave.bGantryBackwardEnable; + END_IF + + + // Coupling states + // Auto-coupling at init and auto-reset of coupling boolean + bExecuteCouple S= NOT bInitComplete; + + bExecuteCouple R= couple.Busy OR bGantryAlreadyCoupled; + couple(Master:=Master.Axis, Slave:=Slave.Axis, Execute:=bExecuteCouple); + + bInitComplete S= bGantryAlreadyCoupled; + + // Decoupling with auto-reset of coupling boolean + bExecuteDecouple R= decouple.Busy OR NOT bGantryAlreadyCoupled; + decouple(Slave:=Slave.Axis, Execute:=bExecuteDecouple); + + END_FUNCTION_BLOCK + + +Related: + * `FB_GantryDiffVirtualLimitSwitch`_ + * `FB_SetEnables`_ + * `ST_MotionStage`_ + * `ST_RenishawAbsEnc`_ + + +FB_GantryDiffVirtualLimitSwitch +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_GantryDiffVirtualLimitSwitch + VAR_INPUT + PEnc: ST_RenishawAbsEnc; // Primary axis encoder (usually the upstream one) + SEnc: ST_RenishawAbsEnc; // Secondary axis encoder (couples to the primary) + + GantDiffTol: LINT; // Gantry differenace tolerance in encoder counts + END_VAR + VAR_OUTPUT + PLimFwd: BOOL; // Primary axis forward direction enable + PLimBwd: BOOL; // Primary axis reverse direction enable + SLimFwd: BOOL; // Secondary axis forward direction enable + SLimBwd: BOOL; // Secondary axis reverse direction enable + END_VAR + VAR + GantryDiff: LINT; + END_VAR + (* Gantry Difference Virtual Limit Switch + A. Wallace 2017-2-15 + + Determines which direction is disabled due to it increasing the gantry difference. + Refer to the ESD for actual conventions. + + A positive gantry error refers to a CCW clocked assembly: + eg. for X + X1 upstream, X2 downstream. Primary axis is always upstream. + Gantry difference > 0 when + X2>X1 + Therefore + X2 positive direction disabled + X1 negative direction disabled + + Call before FB_MotionStage fb calls for the gantry axes. + *) + + GantryDiff := ( ULINT_TO_LINT(PEnc.Count) - ULINT_TO_LINT(PEnc.Ref) ) - ( ULINT_TO_LINT(SEnc.Count) - ULINT_TO_LINT(SEnc.Ref) ); + + IF ABS(GantryDiff) > GantDiffTol THEN + IF GantryDiff < 0 THEN + PLimBwd := FALSE; + SLimFwd := FALSE; + ELSE + PLimBwd := TRUE; + SLimFwd := TRUE; + END_IF + IF GantryDiff > 0 THEN + PLimFwd := FALSE; + SLimBwd := FALSE; + ELSE + PLimFwd := TRUE; + SLimBwd := TRUE; + END_IF + ELSE + //If there is no fault, all directions are enabled + PLimFwd := TRUE; + PLimBwd := TRUE; + SLimFwd := TRUE; + SLimBwd := TRUE; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_MotionStage`_ + * `ST_RenishawAbsEnc`_ + + +FB_HomeDirect +^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_HomeDirect + VAR_INPUT + En: BOOL; + bReset: BOOL; + bExecute: BOOL; + fHomePosition:LREAL; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bBusy: BOOL; + bDone: BOOL; + bHomed:BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR + fbHome: MC_Home; + END_VAR + En:=EnO; + IF bReset THEN + bError:=FALSE; + nErrorId:=0; + END_IF + + fbHome( + Execute:=bExecute, + Position:=fHomePosition, + HomingMode:=MC_Direct, + bCalibrationCam:=FALSE, + Axis:=Axis + ); + + bBusy:=fbHome.Busy; + bDone:=fbHome.Done; + bHomed:=Axis.Status.Homed; + + bError:=fbHome.Error; + + IF fbHome.Error THEN + nErrorId:=fbHome.ErrorID; + END_IF + + END_FUNCTION_BLOCK + + + + +FB_HomeFinish +^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_HomeFinish + VAR_INPUT + En: BOOL; + bReset: BOOL; + bExecute: BOOL; + nCmdData: UINT; + bSofLimEnableLow: BOOL:=TRUE; + bSofLimEnableHigh: BOOL:=TRUE; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR + fbHomewriteSoftLimEnable:FB_HomeWriteSoftLimEnable; + fbExecuteRiseEdge: R_TRIG; + bExecuteWriteNC:BOOL:=FALSE; + nState:INT:=0; + END_VAR + En:=EnO; + IF bReset THEN + bError:=FALSE; + nErrorId:=0; + END_IF + + IF NOT bExecute THEN + bExecuteWriteNC:=FALSE; + fbHomewriteSoftLimEnable.bSofLimEnableLow:=bSofLimEnableLow; + fbHomewriteSoftLimEnable.bSofLimEnableHigh:=bSofLimEnableHigh; + nState:=0; + END_IF + + fbExecuteRiseEdge(CLK:=bExecute); + IF fbExecuteRiseEdge.Q THEN + bExecuteWriteNC:=TRUE; + fbHomewriteSoftLimEnable.bSofLimEnableLow:=bSofLimEnableLow; + fbHomewriteSoftLimEnable.bSofLimEnableHigh:=bSofLimEnableHigh; + END_IF + + // Write to NC (disable soft limits) + fbHomewriteSoftLimEnable( + En:=En, + bExecute:=bExecuteWriteNC AND bExecute, + Axis:=Axis, + bReset:=bReset, + ); + + bBusy:=fbHomewriteSoftLimEnable.bBusy; + bDone:=fbHomewriteSoftLimEnable.bDone; + + bError:=fbHomewriteSoftLimEnable.bError; + IF fbHomewriteSoftLimEnable.bError THEN + nErrorId:=fbHomewriteSoftLimEnable.nErrorId; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_HomeWriteSoftLimEnable`_ + + +FB_HomePrepare +^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_HomePrepare + VAR_INPUT + En: BOOL; + bReset: BOOL; + bExecute: BOOL; + nCmdData: UINT; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + bSofLimEnableLowOriginal: BOOL:=TRUE; + bSofLimEnableHighOriginal: BOOL:=TRUE; + fVelocityToCam: LREAL:=0; + fVelocityFromCam: LREAL:=0; + END_VAR + VAR + fbHomeReadSoftLimEnable:FB_HomeReadSoftLimEnable; + fbHomeDisableSoftLimEnable:FB_HomeWriteSoftLimEnable; + fbHomeReadNCVelocities: FB_HomeReadNcVelocities; + fbHomeResetCalibrationFlag:MC_Home; //Only used for reset of calibration flag + fbExecuteRiseEdge: R_TRIG; + bExecuteReadNC:BOOL:=FALSE; + bExecuteWriteNC:BOOL:=FALSE; + nState:INT:=0; + END_VAR + En:=EnO; + IF bReset THEN + bError:=FALSE; + nErrorId:=0; + END_IF + + IF NOT bExecute THEN + bExecuteReadNC:=FALSE; + bExecuteWriteNC:=FALSE; + nState:=0; + END_IF + + fbExecuteRiseEdge(CLK:=bExecute); + IF fbExecuteRiseEdge.Q THEN + bExecuteReadNC:=TRUE; + END_IF + + // Read from NC + fbHomeReadNCVelocities( + En:=En, + bExecute:=bExecuteReadNC, // Actualy not needed for sequence 15 (set position only, no movement)) + bReset:=bReset, + Axis:=Axis, + ); + + fbHomeReadSoftLimEnable( + En:=En, + bExecute:=bExecuteReadNC AND bExecute, + Axis:=Axis, + bReset:=bReset, + ); + + // Reset calibration flag + fbHomeResetCalibrationFlag( + Execute:=bExecuteReadNC, + HomingMode:=MC_ResetCalibration, + Axis:=Axis + ); + + bSofLimEnableLowOriginal:=fbHomeReadSoftLimEnable.bSofLimEnableLow; + bSofLimEnableHighOriginal:=fbHomeReadSoftLimEnable.bSofLimEnableHigh; + + fVelocityToCam:=fbHomeReadNCVelocities.fVelocityToCam; + fVelocityFromCam:=fbHomeReadNCVelocities.fVelocityFromCam; + + IF bExecuteReadNC AND bExecute AND fbHomeReadSoftLimEnable.bDone THEN + fbHomeDisableSoftLimEnable.bSofLimEnableHigh:=FALSE; + fbHomeDisableSoftLimEnable.bSofLimEnableLow:=FALSE; + bExecuteWriteNC:=TRUE; //Always write (only needed if enabled actually) + END_IF + + // Write to NC (disable soft limits) + fbHomeDisableSoftLimEnable( + En:=En, + bExecute:=bExecuteWriteNC AND bExecute, + Axis:=Axis, + bReset:=bReset, + ); + + bBusy:=fbHomeReadSoftLimEnable.bBusy OR fbHomeDisableSoftLimEnable.bBusy OR fbHomeReadNCVelocities.bBusy OR fbHomeResetCalibrationFlag.Busy; + bDone:=fbHomeReadSoftLimEnable.bDone AND fbHomeDisableSoftLimEnable.bDone AND fbHomeReadNCVelocities.bDone AND fbHomeResetCalibrationFlag.Done AND bExecute; + + bError:=fbHomeReadSoftLimEnable.bError OR fbHomeDisableSoftLimEnable.bError OR fbHomeReadNCVelocities.bError OR fbHomeResetCalibrationFlag.Error; + IF fbHomeReadSoftLimEnable.bError THEN + nErrorId:=fbHomeReadSoftLimEnable.nErrorId; + ELSIF fbHomeDisableSoftLimEnable.bError THEN + nErrorId:=fbHomeDisableSoftLimEnable.nErrorId; + ELSIF fbHomeResetCalibrationFlag.Error THEN + nErrorId:=fbHomeResetCalibrationFlag.ErrorId; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_HomeReadNcVelocities`_ + * `FB_HomeReadSoftLimEnable`_ + * `FB_HomeWriteSoftLimEnable`_ + + +FB_HomeReadNcVelocities +^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_HomeReadNcVelocities + VAR_INPUT + En: BOOL; + bReset: BOOL; + bExecute: BOOL; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + fVelocityToCam: LREAL; + fVelocityFromCam: LREAL; + END_VAR + VAR + fbReadVelocityToCam:FB_ReadFloatParameter; + fbReadVelocityFromCam:FB_ReadFloatParameter; + END_VAR + En:=EnO; + IF bReset THEN + bError:=FALSE; + nErrorId:=0; + END_IF + + fbReadVelocityToCam( + bExecute:=bExecute, + nDeviceGroup:= 16#4000, + nIndexOffset:= 16#6, + Axis:= Axis); + + fbReadVelocityFromCam( + bExecute:=bExecute, + nDeviceGroup:= 16#4000, + nIndexOffset:= 16#7, + Axis:= Axis); + + fVelocityToCam:=fbReadVelocityToCam.nData; + fVelocityFromCam:=fbReadVelocityFromCam.nData; + + bBusy:=fbReadVelocityFromCam.bBusy OR fbReadVelocityToCam.bBusy; + bDone:=fbReadVelocityFromCam.bDone AND fbReadVelocityToCam.bDone AND bExecute; + + bError:=fbReadVelocityToCam.bError OR fbReadVelocityFromCam.bError; + IF fbReadVelocityToCam.bError THEN + nErrorId:=fbReadVelocityToCam.nErrorId; + ELSIF fbReadVelocityFromCam.bError THEN + nErrorId:=fbReadVelocityFromCam.nErrorId; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_ReadFloatParameter`_ + + +FB_HomeReadSoftLimEnable +^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_HomeReadSoftLimEnable + VAR_INPUT + En: BOOL; + bReset: BOOL; + bExecute: BOOL; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + bSofLimEnableLow: BOOL:=TRUE; + bSofLimEnableHigh: BOOL:=TRUE; + END_VAR + VAR + fbReadSoftLimEnableLow:FB_ReadParameterInNc_v1_00; + fbReadSoftLimEnableHigh:FB_ReadParameterInNc_v1_00; + END_VAR + En:=EnO; + IF bReset THEN + bError:=FALSE; + nErrorId:=0; + END_IF + + fbReadSoftLimEnableLow( + bExecute:=bExecute, + nDeviceGroup:= 16#5000, + nIndexOffset:= 16#B, + Axis:= Axis); + + fbReadSoftLimEnableHigh( + bExecute:=bExecute, + nDeviceGroup:= 16#5000, + nIndexOffset:= 16#C, + Axis:= Axis); + + bSofLimEnableLow:=DWORD_TO_BOOL(fbReadSoftLimEnableLow.nData); + bSofLimEnableHigh:=DWORD_TO_BOOL(fbReadSoftLimEnableHigh.nData); + + bBusy:=fbReadSoftLimEnableLow.bBusy OR fbReadSoftLimEnableHigh.bBusy; + bDone:=fbReadSoftLimEnableLow.bDone AND fbReadSoftLimEnableHigh.bDone AND bExecute; + + bError:=fbReadSoftLimEnableLow.bError OR fbReadSoftLimEnableHigh.bError; + IF fbReadSoftLimEnableLow.bError THEN + nErrorId:=fbReadSoftLimEnableLow.nErrorId; + ELSIF fbReadSoftLimEnableHigh.bError THEN + nErrorId:=fbReadSoftLimEnableHigh.nErrorId; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_ReadParameterInNc_v1_00`_ + + +FB_HomeToSwitch +^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_HomeToSwitch + VAR_INPUT + En: BOOL; + bReset: BOOL; + bExecute: BOOL; + bCamSensor:BOOL; + nSearchDirTwoardsCam: MC_Direction; + nSearchDirOffCam: MC_Direction; + fHomePosition:LREAL; + fVelocityToCamNC: LREAL; //Velcoity when searching for cam + fVelocityFromCamNC: LREAL; // Velocity after found cam (searching for next signal transition) + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bBusy: BOOL; + bDone: BOOL; + bHomed:BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR + fbHome: MC_Home; + fbWriteHomeDirCamToNC:FB_WriteParameterInNc_v1_00; + fbWriteHomeDirSyncToNC:FB_WriteParameterInNc_v1_00; + fbWriteHomeModeToNC:FB_WriteParameterInNc_v1_00; + fbWriteHomeVelocitiesToNC: FB_HomeWriteNcVelocities; + bConfigNCDone:BOOL:=FALSE; + fbRTrigg: R_TRIG; + END_VAR + En:=EnO; + IF bReset THEN + bConfigNCDone:=FALSE; + bError:=FALSE; + nErrorId:=0; + END_IF + + //Start preparation of NC if rising edge on bExecute + fbRTrigg(CLK:=bExecute); + IF fbRTrigg.Q THEN + bConfigNCDone:=FALSE; + END_IF + + + fbWriteHomeDirCamToNC( + bExecute:=bExecute AND NOT bConfigNCDone, + nDeviceGroup:=16#5000, + nIndexOffset:=16#101, //Direction for Calibration Cam Search + nData:=BOOL_TO_DWORD(nSearchDirTwoardsCam=MC_Negative_Direction),//BOOL_TO_DWORD(NOT bSearchDirTwoardsCam), + Axis:=Axis + ); + + fbWriteHomeDirSyncToNC( + bExecute:= bExecute AND NOT bConfigNCDone, + nDeviceGroup:=16#5000 , + nIndexOffset:=16#102 , //Direction for Sync Impuls Search + nData:=BOOL_TO_DWORD(nSearchDirOffCam=MC_Negative_Direction),//BOOL_TO_DWORD(NOT bSearchDirOffCam), + Axis:= Axis + ); + + fbWriteHomeModeToNC( + bExecute:=bExecute AND NOT bConfigNCDone, + nDeviceGroup:=16#5000, + nIndexOffset:=16#107, //Reference Mode + nData:=1, + Axis:=axis); + + fbWriteHomeVelocitiesToNC( + En:=En, + bExecute:=bExecute AND NOT bConfigNCDone, + bReset:=bReset, + fVelocityFromCam:=fVelocityFromCamNC, + fVelocityToCam:=fVelocityToCamNC, + Axis:=Axis); + + fbHome.bCalibrationCam:=bCamSensor; + + fbHome( + Execute:=bExecute AND bConfigNCDone(* AND NOT bError*), + Position:=fHomePosition, + HomingMode:=0, + Axis:=Axis + ); + bBusy:=(fbHome.Busy OR (NOT bConfigNCDone AND bExecute)); + bDone:=fbHome.Done AND bConfigNCDone; + bHomed:=Axis.Status.Homed; + + IF (NOT bConfigNCDone) AND fbWriteHomeDirCamToNC.bDone AND fbWriteHomeDirSyncToNC.bDone AND fbWriteHomeModeToNC.bDone AND fbWriteHomeVelocitiesToNC.bDone THEN + bConfigNCDone:=TRUE; + END_IF + + //For some reason MC_HOME gives an Error for one cycle of NC-Task 1 SVB (10ms default..) so filter with bExecute + bError:=(fbHome.Error AND bExecute) OR fbWriteHomeDirCamToNC.bError OR fbWriteHomeDirSyncToNC.bError OR fbWriteHomeModeToNC.bError OR fbWriteHomeVelocitiesToNC.bError; + + IF (fbHome.Error AND bExecute) THEN + nErrorId:=fbHome.ErrorID; + ELSIF fbWriteHomeDirCamToNC.bError THEN + nErrorId:=fbWriteHomeDirCamToNC.nErrorId; + ELSIF fbWriteHomeDirSyncToNC.bError THEN + nErrorId:=fbWriteHomeDirSyncToNC.nErrorId; + ELSIF fbWriteHomeModeToNC.bError THEN + nErrorId:=fbWriteHomeModeToNC.nErrorId; + ELSIF fbWriteHomeVelocitiesToNC.bError THEN + nErrorId:=fbWriteHomeVelocitiesToNC.nErrorId; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_HomeWriteNcVelocities`_ + * `FB_WriteParameterInNc_v1_00`_ + + +FB_HomeVirtual +^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_HomeVirtual + VAR_INPUT + En: BOOL; + bReset: BOOL; + bExecute: BOOL; + nCmdData: UINT; + bLimitFwd: BOOL; + bLimitBwd: BOOL; + bHomeSensor: BOOL; + fHomePosition:LREAL; + nHomeRevOffset: UINT; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bBusy: BOOL; + bDone: BOOL; + bHomed:BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR + fbHomeToSwitch: FB_HomeToSwitch; + fbHomeDirect: FB_HomeDirect; //Only used for direct homing (set of position) + fbMoveVelocity:MC_MoveVelocity; + fbHomePrepare:FB_HomePrepare; + fbHomeFinish:FB_HomeFinish; + fbExecuteRiseEdge: R_TRIG; + nHomingState:INT:=0; + bExecuteHomeToSwitch:BOOL:=FALSE; + bExecuteMoveVelocity:BOOL:=FALSE; + bExecutePrepare: BOOL:=FALSE; + bExecuteFinish: BOOL:=FALSE; + bExecuteHomeDirect: BOOL; + nCmdDataLocal: UINT; //Ensure that nCmdData is not changed during sequence + bSequenceReady:BOOL:=TRUE; + bRestoreNCDataNeeded: BOOL:=FALSE; + END_VAR + EnO:=En; + + IF bReset THEN + bError:=FALSE; + nErrorId:=0; + END_IF + + // Reset when bExecute is low + IF NOT bExecute THEN + nHomingState:=0; + bSequenceReady:=TRUE; + bExecuteHomeToSwitch:=FALSE; + bExecuteHomeDirect:=FALSE; + bExecuteMoveVelocity:=FALSE; + bExecutePrepare:=FALSE; + bExecuteFinish:=FALSE; + END_IF + + //Reset at rinsing edge of bExecute + fbExecuteRiseEdge(CLK:=bExecute); + IF fbExecuteRiseEdge.Q THEN + nCmdDataLocal:=nCmdData; //Ensure that nCmdData is not changed during sequence (nCmdData will only be read at a rising edge of bExecute) + bSequenceReady:=FALSE; + bExecutePrepare:=TRUE; + bRestoreNCDataNeeded:=FALSE; + //Check if valid nCmdDataLocal + CASE nCmdDataLocal OF + 1: + 2: + 3: + 4: + 15: + ELSE //nCmdData not valid + bError:=TRUE; + nErrorId:=16#4FFF; + END_CASE + END_IF + + //############# Prepare for homing (Read from NC and reset homed flag) + fbHomePrepare( + En:=En, + bExecute:=bExecutePrepare AND NOT bError, // Not needed for sequence 15 (set position only, no movement)) + bReset:=bReset, + Axis:=Axis, + ); + + //############# Homing Sequences: + CASE nCmdDataLocal OF + + 1: // Home to low limit switch + CASE nHomingState OF + 0: + bHomed:=Axis.Status.Homed; + // Wait for read of velocities from NC and reset of calibration flag + IF fbHomePrepare.bDone AND bExecute AND NOT bSequenceReady THEN + bRestoreNCDataNeeded:=TRUE; + IF bLimitBwd THEN + nHomingState:=1; + ELSE + nHomingState:=2; //Standing on limit switch go direct to state 2 + END_IF + END_IF + 1: // wait for reach low limit then trigger fbHomeToSwitch + bHomed:=FALSE; + bSequenceReady:=FALSE; + fbMoveVelocity.Velocity:=ABS(fbHomePrepare.fVelocityToCam); + fbMoveVelocity.Direction:=MC_Negative_Direction; + bExecuteMoveVelocity:=bExecute; // Execute MC_MoveVelocity + IF NOT bLimitBwd AND NOT fbMoveVelocity.Busy AND Axis.Status.NotMoving THEN //MC_MoveVelocity.Busy goes down when ramp down initiates (not ends). + nHomingState:=2; + END_IF + 2: // Wait for fbHomeToSwitch + bHomed:=FALSE; + bSequenceReady:=FALSE; + bExecuteMoveVelocity:=FALSE; + bExecuteHomeToSwitch:=TRUE; + fbHomeToSwitch.nSearchDirTwoardsCam:=MC_Positive_Direction; + fbHomeToSwitch.nSearchDirOffCam:=MC_Positive_Direction; + fbHomeToSwitch.fVelocityToCamNC:=fbHomePrepare.fVelocityToCam; // High speed + fbHomeToSwitch.fVelocityFromCamNC:=fbHomePrepare.fVelocityFromCam; // Low speed + fbHomeToSwitch.bCamSensor:=NOT bLimitBwd; + IF fbHomeToSwitch.bDone THEN + nHomingState:=3; + bExecuteFinish:=TRUE; + fbHomeFinish.bSofLimEnableHigh:=fbHomePrepare.bSofLimEnableHighOriginal; + fbHomeFinish.bSofLimEnableLow:=fbHomePrepare.bSofLimEnableLowOriginal; + END_IF; + 3: // restore softlimit enable + bHomed:=FALSE; + bSequenceReady:=FALSE; + IF fbHomeFinish.bDone THEN + bRestoreNCDataNeeded:=FALSE; + bSequenceReady:=TRUE; + nHomingState:=0; + bHomed:=Axis.Status.Homed; + END_IF; + END_CASE; + + 2: // Home to high limit switch + CASE nHomingState OF + 0: + bHomed:=Axis.Status.Homed; + // Wait for read of velocities from NC and reset of calibration flag + IF fbHomePrepare.bDone AND bExecute AND NOT bSequenceReady THEN + bRestoreNCDataNeeded:=TRUE; + IF bLimitFwd THEN + nHomingState:=1; + ELSE + nHomingState:=2; //Standing on limit switch go direct to state 2 + END_IF + END_IF + 1: // wait for reach low limit then trigger fbHomeToSwitch + bHomed:=FALSE; + bSequenceReady:=FALSE; + fbMoveVelocity.Velocity:=ABS(fbHomePrepare.fVelocityToCam); + fbMoveVelocity.Direction:=MC_Positive_Direction; + bExecuteMoveVelocity:=bExecute; // Execute MC_MoveVelocity + IF NOT bLimitFwd AND NOT fbMoveVelocity.Busy AND Axis.Status.NotMoving THEN //MC_MoveVelocity.Busy goes down when ramp down initiates (not ends). + nHomingState:=2; + END_IF + 2: // Wait for fbHomeToSwitch + bHomed:=FALSE; + bSequenceReady:=FALSE; + bExecuteMoveVelocity:=FALSE; + bExecuteHomeToSwitch:=TRUE; + fbHomeToSwitch.nSearchDirTwoardsCam:=MC_Negative_Direction; + fbHomeToSwitch.nSearchDirOffCam:=MC_Negative_Direction; + fbHomeToSwitch.fVelocityToCamNC:=fbHomePrepare.fVelocityToCam; // High speed + fbHomeToSwitch.fVelocityFromCamNC:=fbHomePrepare.fVelocityFromCam; // Low speed + fbHomeToSwitch.bCamSensor:=NOT bLimitFwd; + IF fbHomeToSwitch.bDone THEN + nHomingState:=3; + bExecuteFinish:=TRUE; + fbHomeFinish.bSofLimEnableHigh:=fbHomePrepare.bSofLimEnableHighOriginal; + fbHomeFinish.bSofLimEnableLow:=fbHomePrepare.bSofLimEnableLowOriginal; + END_IF; + 3: // restore softlimit enable + bHomed:=FALSE; + bSequenceReady:=FALSE; + IF fbHomeFinish.bDone THEN + bRestoreNCDataNeeded:=FALSE; + bSequenceReady:=TRUE; + nHomingState:=0; + bHomed:=Axis.Status.Homed; + END_IF; + END_CASE; + + 3: // Home on bHomeSensor via bLimitBwd + CASE nHomingState OF + 0: + bHomed:=Axis.Status.Homed; + // Wait for read of velocities from NC and reset of calibration flag + IF fbHomePrepare.bDone AND bExecute AND NOT bSequenceReady THEN + bRestoreNCDataNeeded:=TRUE; + IF bLimitBwd THEN + nHomingState:=1; + ELSE + nHomingState:=2; //Standing on limit switch go direct to state 2 + END_IF + END_IF + 1: // wait for reach low limit then trigger fbHomeToSwitch + bHomed:=FALSE; + bSequenceReady:=FALSE; + fbMoveVelocity.Velocity:=ABS(fbHomePrepare.fVelocityToCam); + fbMoveVelocity.Direction:=MC_Negative_Direction; + bExecuteMoveVelocity:=bExecute; // Execute MC_MoveVelocity + IF NOT bLimitBwd AND NOT fbMoveVelocity.Busy AND Axis.Status.NotMoving THEN //MC_MoveVelocity.Busy goes down when ramp down initiates (not ends). + nHomingState:=2; + END_IF + 2: // Wait for fbHomeToSwitch + bHomed:=FALSE; + bSequenceReady:=FALSE; + bExecuteMoveVelocity:=FALSE; + bExecuteHomeToSwitch:=TRUE; + fbHomeToSwitch.nSearchDirTwoardsCam:=MC_Positive_Direction; + fbHomeToSwitch.nSearchDirOffCam:=MC_Positive_Direction; + fbHomeToSwitch.fVelocityToCamNC:=fbHomePrepare.fVelocityToCam; // High speed + fbHomeToSwitch.fVelocityFromCamNC:=fbHomePrepare.fVelocityFromCam; // Low speed + fbHomeToSwitch.bCamSensor:=bHomeSensor; + IF fbHomeToSwitch.bDone THEN + nHomingState:=3; + bExecuteFinish:=TRUE; + fbHomeFinish.bSofLimEnableHigh:=fbHomePrepare.bSofLimEnableHighOriginal; + fbHomeFinish.bSofLimEnableLow:=fbHomePrepare.bSofLimEnableLowOriginal; + END_IF; + 3: // restore softlimit enable + bHomed:=FALSE; + bSequenceReady:=FALSE; + IF fbHomeFinish.bDone THEN + bRestoreNCDataNeeded:=FALSE; + bSequenceReady:=TRUE; + nHomingState:=0; + bHomed:=Axis.Status.Homed; + END_IF; + END_CASE; + 4: // Home on bHomeSensor via bLimitFwd + CASE nHomingState OF + 0: + bHomed:=Axis.Status.Homed; + // Wait for read of velocities from NC and reset of calibration flag + IF fbHomePrepare.bDone AND bExecute AND NOT bSequenceReady THEN + bRestoreNCDataNeeded:=TRUE; + IF bLimitFwd THEN + nHomingState:=1; + ELSE + nHomingState:=2; //Standing on limit switch go direct to state 2 + END_IF + END_IF + 1: // wait for reach low limit then trigger fbHomeToSwitch + bHomed:=FALSE; + bSequenceReady:=FALSE; + fbMoveVelocity.Velocity:=ABS(fbHomePrepare.fVelocityToCam); + fbMoveVelocity.Direction:=MC_Positive_Direction; + bExecuteMoveVelocity:=bExecute; // Execute MC_MoveVelocity + IF NOT bLimitFwd AND NOT fbMoveVelocity.Busy AND Axis.Status.NotMoving THEN //MC_MoveVelocity.Busy goes down when ramp down initiates (not ends). + nHomingState:=2; + END_IF + 2: // Wait for fbHomeToSwitch + bHomed:=FALSE; + bSequenceReady:=FALSE; + bExecuteMoveVelocity:=FALSE; + bExecuteHomeToSwitch:=TRUE; + fbHomeToSwitch.nSearchDirTwoardsCam:=MC_Negative_Direction; + fbHomeToSwitch.nSearchDirOffCam:=MC_Negative_Direction; + fbHomeToSwitch.fVelocityToCamNC:=fbHomePrepare.fVelocityToCam; // High speed + fbHomeToSwitch.fVelocityFromCamNC:=fbHomePrepare.fVelocityFromCam; // Low speed + fbHomeToSwitch.bCamSensor:=bHomeSensor; + IF fbHomeToSwitch.bDone THEN + nHomingState:=3; + bExecuteFinish:=TRUE; + fbHomeFinish.bSofLimEnableHigh:=fbHomePrepare.bSofLimEnableHighOriginal; + fbHomeFinish.bSofLimEnableLow:=fbHomePrepare.bSofLimEnableLowOriginal; + END_IF; + 3: // Restore softlimit enable + bHomed:=FALSE; + bSequenceReady:=FALSE; + IF fbHomeFinish.bDone THEN + bRestoreNCDataNeeded:=FALSE; + bSequenceReady:=TRUE; + nHomingState:=0; + bHomed:=Axis.Status.Homed; + END_IF; + END_CASE; + + 15: //Set current position (simplest homing sequence) + bExecuteHomeDirect:=bExecute; + bHomed:=Axis.Status.Homed; + IF fbHomeDirect.bDone THEN //Homing ready + bExecuteHomeDirect:=FALSE; + bSequenceReady:=TRUE; + END_IF + + ELSE + fbHomeToSwitch.bCamSensor:=FALSE; + bHomed:=Axis.Status.Homed; + END_CASE; + + // Main homing block + fbHomeToSwitch( + bExecute:=bExecuteHomeToSwitch AND bExecute AND NOT bError AND NOT bExecuteHomeDirect AND NOT bExecuteMoveVelocity, + bReset:=bReset, + fHomePosition:=fHomePosition, + Axis:=Axis + ); + + // Approach limit switch (error if MC_Home is used) + fbMoveVelocity( + Execute:= bExecuteMoveVelocity AND bExecute AND NOT bError AND NOT bExecuteHomeToSwitch AND NOT bExecuteHomeDirect, + Axis:=Axis + ); + + // No sequence, just set position value (nCmdDataLocal=15). Can not run if fbHomeToSwitch is executed + fbHomeDirect( + bExecute:=bExecuteHomeDirect AND bExecute AND NOT bError AND NOT bExecuteHomeToSwitch AND NOT bExecuteMoveVelocity, + bReset:=bReset, + fHomePosition:=fHomePosition, + Axis:=Axis + ); + + + //############# Finish homing + + IF NOT bexecute AND bRestoreNCDataNeeded THEN //If homing is aborted restore is needed + bExecuteFinish:=TRUE; + IF fbHomeFinish.bDone THEN + bExecuteFinish:=FALSE; + bRestoreNCDataNeeded:=FALSE; + END_IF + END_IF + + fbHomeFinish( + En:=En, + bExecute:=bExecuteFinish, + bReset:=bReset, + Axis:=Axis, + ); + + // Error handling + IF NOT bError THEN + IF fbHomeToSwitch.bError THEN + bError:=fbHomeToSwitch.bError; + nErrorId:=fbHomeToSwitch.nErrorId; + ELSIF fbHomeDirect.bError THEN + bError:=fbHomeDirect.bError; + nErrorId:=fbHomeDirect.nErrorId; + ELSIF fbMoveVelocity.Error THEN + bError:=fbMoveVelocity.Error; + nErrorId:=fbMoveVelocity.ErrorId; + END_IF; + END_IF + + // Done and busy bit + bDone:=bSequenceReady AND bExecute; + bBusy:=NOT bSequenceReady; + + RETURN; + + END_FUNCTION_BLOCK + + +Related: + * `FB_HomeDirect`_ + * `FB_HomeFinish`_ + * `FB_HomePrepare`_ + * `FB_HomeToSwitch`_ + + +FB_HomeWriteNcVelocities +^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_HomeWriteNcVelocities + VAR_INPUT + En: BOOL; + bReset: BOOL; + bExecute: BOOL; + fVelocityToCam: LREAL; + fVelocityFromCam: LREAL; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR + fbExecuteRiseEdge: R_TRIG; + fbWriteVelocityToCam:FB_WriteFloatParameter; + fbWriteVelocityFromCam:FB_WriteFloatParameter; + END_VAR + En:=EnO; + IF bReset THEN + bError:=FALSE; + nErrorId:=0; + END_IF + + fbExecuteRiseEdge(CLK:=bExecute); + + fbWriteVelocityToCam( + bExecute:=bExecute, + nDeviceGroup:= 16#4000, + nIndexOffset:= 16#6, + nData:=fVelocityToCam, + Axis:= Axis); + + fbWriteVelocityFromCam( + bExecute:=bExecute, + nDeviceGroup:= 16#4000, + nIndexOffset:= 16#7, + nData:=fVelocityFromCam, + Axis:= Axis); + + bBusy:=fbWriteVelocityFromCam.bBusy OR fbWriteVelocityToCam.bBusy; + bDone:=fbWriteVelocityFromCam.bDone AND fbWriteVelocityToCam.bDone AND bExecute; + + bError:=fbWriteVelocityToCam.bError OR fbWriteVelocityFromCam.bError; + IF fbWriteVelocityToCam.bError THEN + nErrorId:=fbWriteVelocityToCam.nErrorId; + ELSIF fbWriteVelocityFromCam.bError THEN + nErrorId:=fbWriteVelocityFromCam.nErrorId; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_WriteFloatParameter`_ + + +FB_HomeWriteSoftLimEnable +^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_HomeWriteSoftLimEnable + VAR_INPUT + En: BOOL; + bReset: BOOL; + bExecute: BOOL; + bSofLimEnableLow: BOOL:=TRUE; + bSofLimEnableHigh: BOOL:=TRUE; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR + fbExecuteRiseEdge: R_TRIG; + fbWriteSoftLimEnableLow:FB_WriteParameterInNc_v1_00; + fbWriteSoftLimEnableHigh:FB_WriteParameterInNc_v1_00; + END_VAR + En:=EnO; + IF bReset THEN + bError:=FALSE; + nErrorId:=0; + END_IF + + fbExecuteRiseEdge(CLK:=bExecute); + + fbWriteSoftLimEnableLow( + bExecute:=bExecute, + nDeviceGroup:= 16#5000, + nIndexOffset:= 16#B, + nData:=BOOL_TO_DWORD(bSofLimEnableLow), + Axis:= Axis); + + fbWriteSoftLimEnableHigh( + bExecute:=bExecute, + nDeviceGroup:= 16#5000, + nIndexOffset:= 16#C, + nData:=BOOL_TO_DWORD(bSofLimEnableHigh), + Axis:= Axis); + + bBusy:=fbWriteSoftLimEnableLow.bBusy OR fbWriteSoftLimEnableHigh.bBusy; + bDone:=fbWriteSoftLimEnableLow.bDone AND fbWriteSoftLimEnableHigh.bDone AND bExecute; + + bError:=fbWriteSoftLimEnableHigh.bError OR fbWriteSoftLimEnableLow.bError; + IF fbWriteSoftLimEnableHigh.bError THEN + nErrorId:=fbWriteSoftLimEnableHigh.nErrorId; + ELSIF fbWriteSoftLimEnableLow.bError THEN + nErrorId:=fbWriteSoftLimEnableLow.nErrorId; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_WriteParameterInNc_v1_00`_ + + +FB_LogMotionError +^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_LogMotionError + (* + If the motion struct has an error, log it. + + The log condition is: + - When bError goes TRUE (catch transition from no error to error) + - When the error message changes while bError is TRUE (catch transition from error a to error b) + + Includes the motor name and the NC error id in the json blob + *) + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + VAR_INPUT + bEnable: BOOL; + END_VAR + VAR + fbLogMessage: FB_LogMessage; + rtNewError: R_TRIG; + bChangedError: BOOL; + sPrevErr: STRING; + fbJson: FB_JsonSaxWriter; + END_VAR + rtNewError(CLK:=stMotionStage.bError); + bChangedError := stMotionStage.sErrorMessage <> '' AND stMotionStage.sErrorMessage <> sPrevErr; + sPrevErr := stMotionStage.sErrorMessage; + + IF bEnable AND (rtNewError.Q OR bChangedError) THEN + fbJson.StartObject(); + fbJson.AddKey('schema'); + fbJson.AddString('ST_MotionStage.bError'); + fbJson.AddKey('dut_name'); + fbJson.AddString(stMotionStage.sName); + fbJson.AddKey('axis_name'); + fbJson.AddString(stMotionStage.stAxisParameters.sAxisName); + fbJson.AddKey('axis_id'); + fbJson.AddUdint(stMotionStage.stAxisParameters.AxisId); + fbJson.AddKey('err_id'); + fbJson.AddUdint(stMotionStage.nErrorId); + fbJson.AddKey('position'); + fbJson.AddLreal(stMotionStage.stAxisStatus.fActPosition); + fbJson.AddKey('position_lag'); + fbJson.AddLreal(stMotionStage.stAxisStatus.fActDiff); + fbJson.EndObject(); + fbLogMessage.sJson := fbJson.GetDocument(); + fbLogMessage( + sMsg := stMotionStage.sErrorMessage, + eSevr := TcEventSeverity.Error, + eSubsystem := E_Subsystem.MOTION, + ); + fbJson.ResetDocument(); + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `ST_MotionStage`_ + + +FB_MicroStepCountTest +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MicroStepCountTest + VAR_INPUT + bExecute: BOOL; + fStepSize: LREAL; + nSteps: UINT; + fMicroStep: LREAL; + fVelocity: LREAL; + tSettleTime: TIME; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR_OUTPUT + nStepsCounted: UINT; + nTheorySteps: UINT; + fPercent: LREAL; + fEstMicroSize: LREAL; + END_VAR + VAR + fbMoveRel: MC_MoveRelative; + fbSettleTimer: TON; + bDoMove: BOOL; + nStepCounter: UINT; + + arrPosBuffer: ARRAY [0..99] OF LREAL; + fAvgPos: LREAL; + nArrIndex: UINT; + nLoopIndex: UINT; + + fStartPos: LREAL; + fPrevPos: LREAL; + fStepChange: LREAL; + + fStepSum: LREAL; + END_VAR + // Motion FB + fbMoveRel(Axis:=Axis, + Execute:=bDoMove, + Distance:=fStepSize, + Velocity:=fVelocity); + + // Settle time + fbSettleTimer(IN:=fbMoveRel.Done, + PT:=tSettleTime); + + // Re-enable the move for next cycle + bDoMove := bExecute AND nStepCounter < nSteps; + + // Calculate rolling average + arrPosBuffer[nArrIndex] := Axis.NcToPlc.ActPos; + fAvgPos := 0; + FOR nLoopIndex := 0 TO 99 DO + fAvgPos := fAvgPos + arrPosBuffer[nLoopIndex]; + END_FOR; + fAvgPos := fAvgPos / 100; + nArrIndex := (nArrIndex + 1) MOD 100; + + // Initialize starting variables + IF NOT bExecute THEN + fStartPos := fAvgPos; + fPrevPos := fAvgPos; + END_IF + + // Check results + IF fbSettleTimer.Q THEN + fStepChange := fAvgPos - fPrevPos; + // Invert fStepChange if we were doing negative steps + IF fStepSize < 0 THEN + fStepChange := fStepChange * -1; + END_IF + IF fStepChange > fMicroStep * 0.5 THEN + nStepsCounted := nStepsCounted + 1; + fStepSum := fStepSum + fStepChange; + fEstMicroSize := fStepSum / nStepsCounted; + END_IF + nTheorySteps := DINT_TO_UINT(TRUNC(ABS((fStartPos - fAvgPos) / fMicroStep))); + IF nTheorySteps > 0 THEN + fPercent := 100 * nStepsCounted / nTheorySteps; + END_IF + fPrevPos := fAvgPos; + nStepCounter := nStepCounter + 1; + // Reset the move block + bDoMove := FALSE; + END_IF + + END_FUNCTION_BLOCK + + + + +FB_MiscStatesErrorFFO +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MiscStatesErrorFFO + (* + A catch-all for miscellaneous state FFOs that are not better organized elsewhere. + Contains the following fast faults: + - ffBeamParamsOK: trip the beam if the beam parameters are not safe enough for our current (known) state + - ffZeroRate: trip the beam if we've asked for zero rate (as a shortcut) + - ffUnknown: trip the beam if we're at an unknown state and our transition id is not asserted. + - ffDebounce: trip the beam (no autoreset) if ffBeamParamsOK fast faults fault on and off multiple times too quickly. + This solves an issue where ffBeamParamsOK might solve its own problem and creating a blinking fast fault issue. + + The inputs are mostly outputs of non-pmps function blocks and heavily-reused info like state details. + *) + VAR_IN_OUT + // The arbiter to request beam states from + fbArbiter: FB_Arbiter; + // The fast fault output to fault to + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + // A name to link to these fast faults + sDeviceName: STRING; + // Current requested beam details: either a known state or the transition beam + stCurrentBeamReq: ST_BeamParams; + // TRUE if we're at a known state (doesn't matter which) + bKnownState: BOOL; + // Lookup ID of the transition beam + nTransitionID: DWORD; + END_VAR + VAR_OUTPUT + END_VAR + VAR CONSTANT + // Number of consecutive trips before we debounce + nMaxTrips: UINT := 5; + // Decrease trip count by 1 after this much time has passed + tTripReset: TIME := T#1s; + END_VAR + VAR + // If the beam parameters are wrong, it is a fault! This encompasses all unknown arbiter-related errors. + ffBeamParamsOk: FB_FastFault; + // If we asked for zero rate (NC or SC) then we can cut the beam early. This is somewhat redundant. + ffZeroRate: FB_FastFault; + // Trip the beam for unknown state + ffUnknown: FB_FastFault; + // Trip the beam (no autoreset) if ffBeamParamsOK faults/resets multiple times too quickly. + ffDebounce: FB_FastFault; + + // Number of consecutive trips so far + nTripCount: UINT; + // Increase by 1 whenever there is a fault (rising edge) + ftTripCount: F_TRIG; + // Decrease trip count by 1 each timeout + tonTripCount: TON; + // TRUE on only the first cycle + bFirstCycle: BOOL := TRUE; + END_VAR + ffBeamParamsOk( + i_xOK:=F_SafeBPCompare(PMPS_GVL.stCurrentBeamParameters, stCurrentBeamReq), + i_xAutoReset:=TRUE, + i_DevName:=sDeviceName, + i_Desc:='Beam parameter mismatch', + i_TypeCode:=E_MotionFFType.BP_MISMATCH, + io_fbFFHWO:=fbFFHWO); + + CASE PMPS_GVL.stCurrentBeamParameters.nMachineMode OF + // NC mode + 1: ffZeroRate.i_xOK := stCurrentBeamReq.nRate > 0; + // SC mode + 2: ffZeroRate.i_xOK := stCurrentBeamReq.nBCRange > 0; + ELSE + // Ambiguous or new mode + ffZeroRate.i_xOK := stCurrentBeamReq.nRate > 0 AND stCurrentBeamReq.nBCRange > 0; + END_CASE + + ffZeroRate( + i_xAutoReset := TRUE, + i_DevName := sDeviceName, + i_Desc := 'Device requesting zero rate', + i_TypeCode := E_MotionFFType.ZERO_RATE, + io_fbFFHWO := fbFFHWO, + ); + + ffUnknown( + i_xOK := bknownState OR fbArbiter.CheckRequestInPool(nReqID:=nTransitionID), + i_xAutoReset := TRUE, + i_DevName := sDeviceName, + i_Desc := 'Unknown position between moves', + i_TypeCode := E_MotionFFType.NOT_A_STATE, + io_fbFFHWO := fbFFHWO, + ); + + ftTripCount(CLK:=ffBeamParamsOk.i_xOK); + + IF ftTripCount.Q THEN + nTripCount := nTripCount + 1; + END_IF + + tonTripCount( + IN:=NOT tonTripCount.Q, + PT:=tTripReset, + ); + IF tonTripCount.Q AND nTripCount > 0 THEN + nTripCount := nTripCount - 1; + END_IF + + // This is required for non-autoresetting FBs to come up in a beam permitted state + ffDebounce.i_xReset S= bFirstCycle; + ffDebounce( + i_xOK := nTripCount < 5, + i_xAutoReset := FALSE, + i_DevName := sDeviceName, + i_Desc := 'Tripped beam parameter mismatch off/on too many times, hold off', + i_TypeCode := E_MotionFFType.TOO_MANY_TRIPS, + io_fbFFHWO := fbFFHWO, + ); + ffDebounce.i_xReset R= bFirstCycle; + bFirstCycle := FALSE; + + END_FUNCTION_BLOCK + + +Related: + * `E_MotionFFType`_ + + +FB_MiscStatesErrorFFO_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MiscStatesErrorFFO_Test EXTENDS TcUnit.FB_TestSuite + (* + Unit tests for FB_MiscStatesErrorFFO + *) + VAR + END_VAR + TestBeamParamsNotOk(); + TestZeroRate(); + TestUnknownState(); + TestTransitionState(); + TestDebounce(); + + END_FUNCTION_BLOCK + + METHOD TestBeamParamsNotOk + VAR_INST + fbMiscFFO: FB_MiscStatesErrorFFO; + fbArbiter: FB_Arbiter(1); + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + + stBeamReq: ST_BeamParams; + END_VAR + TEST('TestBeamParamsNotOk'); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Started with a fault', + ); + + // Trigger only a beam parameter mismatch + // Do not trip zero rate, unknown state, or debounce + PMPS_GVL.stCurrentBeamParameters := PMPS_GVL.cstFullBeam; + stBeamReq := PMPS_GVL.cstFullBeam; + stBeamReq.nTran := 0.5; + fbMiscFFO( + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stCurrentBeamReq:=stBeamReq, + bKnownState:=TRUE, + nTransitionID:=1, + ); + + fbFFHWO.EvaluateOutput(); + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Did not fault with bad attenuator state', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TestDebounce + VAR_INST + fbMiscFFO: FB_MiscStatesErrorFFO; + fbArbiter: FB_Arbiter(5); + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + VAR + nIter: DINT; + END_VAR + TEST('TestDebounce'); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Started with a fault prior to first FB run-through', + ); + // Ask for full beam: there should be no faults of any kind + fbMiscFFO( + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stCurrentBeamReq:=PMPS_GVL.cstFullBeam, + bKnownState:=TRUE, + nTransitionID:=5, + ); + fbFFHWO.EvaluateOutput(); + + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Started with a fault prior to trip checks', + ); + + // Trip and untrip the beam fast fault once, show no fault + TripUntrip( + fbMiscFFO:=fbMiscFFO, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Control group failed: one trip/untrip should not be enough to debounce', + ); + // Trip and untrip the beam fast fault like 10 times, show fault + FOR nIter := 1 TO 10 DO + TripUntrip( + fbMiscFFO:=fbMiscFFO, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + ); + END_FOR + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Debouncer failed to debounce', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TestTransitionState + VAR_INST + fbMiscFFO: FB_MiscStatesErrorFFO; + fbArbiter: FB_Arbiter(4); + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestTransitionState'); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Started with a fault', + ); + + // Trigger no faults, we're at an unknown state but it's a transition state + // Do not trip bad beam, zero rate, or debounce + fbArbiter.AddRequest( + nReqID:=4, + stReqBP:=PMPS_GVL.cstFullBeam, + sDevName:='UnitTest', + ); + PMPS_GVL.stCurrentBeamParameters := PMPS_GVL.cstFullBeam; + fbMiscFFO( + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stCurrentBeamReq:=PMPS_GVL.cstFullBeam, + bKnownState:=FALSE, + nTransitionID:=4, + ); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Faulted in unknown states even though we were moving normally', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TestUnknownState + VAR_INST + fbMiscFFO: FB_MiscStatesErrorFFO; + fbArbiter: FB_Arbiter(3); + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestUnknownState'); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Started with a fault', + ); + + // Trigger only an unknown states + // Do not trip bad beam, zero rate, or debounce + PMPS_GVL.stCurrentBeamParameters := PMPS_GVL.cstFullBeam; + fbMiscFFO( + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stCurrentBeamReq:=PMPS_GVL.cstFullBeam, + bKnownState:=FALSE, + nTransitionID:=3, + ); + + fbFFHWO.EvaluateOutput(); + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Did not fault with unknown state', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TestZeroRate + VAR_INST + fbMiscFFO: FB_MiscStatesErrorFFO; + fbArbiter: FB_Arbiter(2); + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + + stNoBeam: ST_BeamParams; + END_VAR + TEST('TestBeamZeroRate'); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Started with a fault', + ); + + // Trigger only a zero rate + // Do not trip beam parameter mismatch, unknown state, or debounce + PMPS_GVL.stCurrentBeamParameters := stNoBeam; + fbMiscFFO( + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stCurrentBeamReq:=PMPS_GVL.cst0RateBeam, + bKnownState:=TRUE, + nTransitionID:=2 + ); + + fbFFHWO.EvaluateOutput(); + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Did not fault with zero rate', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TripUntrip + VAR_IN_OUT + fbMiscFFO: FB_MiscStatesErrorFFO; + fbArbiter: FB_Arbiter; + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR + stBeamReq: ST_BeamParams; + END_VAR + // Use anything other than 0 rate, which is its own check + stBeamReq := PMPS_GVL.cstFullBeam; + stBeamReq.nTran := 0.5; + // Trip: too much beam! + PMPS_GVL.stCurrentBeamParameters := PMPS_GVL.cstFullBeam; + fbMiscFFO( + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stCurrentBeamReq:=stBeamReq, + bKnownState:=TRUE, + nTransitionID:=5, + ); + fbFFHWO.EvaluateOutput(); + + // Untrip: correct beam! + PMPS_GVL.stCurrentBeamParameters := stBeamReq; + fbMiscFFO( + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stCurrentBeamReq:=stBeamReq, + bKnownState:=TRUE, + nTransitionID:=5, + ); + fbFFHWO.EvaluateOutput(); + END_METHOD + + +Related: + * `FB_MiscStatesErrorFFO`_ + + +FB_MotionBPTM +^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionBPTM + (* + This function block handles the beam parameter transition manager for a group of motors moving together to a destination with shared beam state. + stGoalParams and stTransParams are required arguments and must not share IDs with other state parameters in the PLC. + + This is a building block not intended for use outside of lcls-twincat-motion. + *) + VAR_IN_OUT + // Array of motors that will move for this beam transition + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + // The arbiter to request beam states from + fbArbiter: FB_Arbiter; + // The fast fault output to fault to + fbFFHWO: FB_HardwareFFOutput; + // The parameters we want to transition to + stGoalParams: ST_DbStateParams; + // The parameters we want to use during the transition + stTransParams: ST_DbStateParams; + END_VAR + VAR_INPUT + // The number of motors we're actually using + nActiveMotorCount: UINT; + // Set to TRUE to use the BPTM, FALSE to stop using the BPTM. + bEnable: BOOL; + // TRUE if we're at the physical state that matches the goal parameters + bAtState: BOOL; + // A device name to use in the GUI + sDeviceName: STRING; + // How long to wait for parameters before timing out + tArbiterTimeout: TIME := T#1s; + // Whether to fault and move on timeout (TRUE) or to wait (FALSE) + bMoveOnArbiterTimeout: BOOL := TRUE; + // Set to TRUE when it is safe to reset the BPTM timeout fast fault, to reset it early. + bResetBPTMTimeout: BOOL; + END_VAR + VAR_OUTPUT + // This becomes TRUE when the motors are allowed to move to their destinations. + bTransitionAuthorized: BOOL; + // This becomes TRUE once the full beam transition is done. + bDone: BOOL; + // TRUE if we're using a bad motor count + bMotorCountError: BOOL; + END_VAR + VAR + bptm: BeamParameterTransitionManager; + bDoneMoving: BOOL; + nPrevID: UDINT; + nIndex: DINT; + + bInternalAuth: BOOL; + bDoneResetQueued: BOOL; + + tonArbiter: TON; + bArbiterTimeout: BOOL; + ffBPTMTimeoutAndMove: FB_FastFault; + ffBPTMError: FB_FastFault; + END_VAR + CheckCount(); + IF NOT bMotorCountError THEN + SetDoneMoving(); + IF bEnable THEN + RunBPTM(); + HandleTimeout(); + END_IF + END_IF + + END_FUNCTION_BLOCK + + ACTION CheckCount: + // Make sure the motor count is valid (positive, nonzero, less or equal to the max) + bMotorCountError S= nActiveMotorCount <= 0; + bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS; + END_ACTION + + ACTION HandleTimeout: + // Measure the time that the bptm is busy + tonArbiter( + IN:=bptm.bBusy, + PT:=tArbiterTimeout, + Q=>bArbiterTimeout, + ); + bTransitionAuthorized := bInternalAuth OR (bArbiterTimeout AND bMoveOnArbiterTimeout); + + // Trip the beam for BPTM timeouts if we want to move + // Only reset at safe beam OR at no bptm errors (some other FF should catch additional issues) + ffBPTMTimeoutAndMove.i_xOK := NOT (bArbiterTimeout AND bMoveOnArbiterTimeout); + ffBPTMTimeoutAndMove.i_xReset S= bResetBPTMTimeout OR (bptm.bDone AND NOT bptm.bError); + ffBPTMTimeoutAndMove( + i_DevName := sDeviceName, + i_Desc := 'BPTM Timeout', + i_TypeCode := E_MotionFFType.BPTM_TIMEOUT, + io_fbFFHWO := fbFFHWO, + ); + END_ACTION + + ACTION RunBPTM: + bptm( + fbArbiter:=fbArbiter, + i_sDeviceName:=sDeviceName, + i_TransitionAssertionID:=stTransParams.nRequestAssertionID, + i_stTransitionAssertion:=stTransParams.stBeamParams, + i_nRequestedAssertionID:=stGoalParams.nRequestAssertionID, + i_stRequestedAssertion:=stGoalParams.stBeamParams, + i_xDoneMoving:=bDoneMoving AND bAtState, + stCurrentBeamParameters:=PMPS_GVL.stCurrentBeamParameters, + q_xTransitionAuthorized=>bInternalAuth, + bDone=>bDone, + ); + + // Trip the beam for BPTM Errors + ffBPTMError.i_xOK := NOT bptm.bError; + ffBPTMError.i_xReset S= bptm.bDone AND NOT bptm.bError; + ffBPTMError( + i_DevName := sDeviceName, + i_Desc := 'BPTM error, state transition failed', + i_TypeCode := E_MotionFFType.BPTM_ERROR, + io_fbFFHWO := fbFFHWO, + ); + END_ACTION + + ACTION SetDoneMoving: + // Set bDoneMoving if all the motors are done + bDoneMoving := TRUE; + FOR nIndex := 1 TO nActiveMotorCount DO + bDoneMoving := bDoneMoving AND NOT astMotionStage[nIndex].bBusy AND NOT astMotionStage[nIndex].bExecute; + END_FOR + // Reset bDoneMoving if the goal has changed to reset bptm's motor done for an in-place transition + // This allows us to change to a new beam state without requiring a motor state change + // BPTM only checks for this "done" transition after the transition has been authorized, so we may need to wait + bDoneResetQueued S= nPrevID <> stGoalParams.nRequestAssertionID; + bDoneMoving R= bDoneResetQueued AND bptm.q_xTransitionAuthorized; + bDoneResetQueued R= bptm.q_xTransitionAuthorized; + nPrevID := stGoalParams.nRequestAssertionID; + END_ACTION + + +Related: + * `E_MotionFFType`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + + +FB_MotionBPTM_Test +^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionBPTM_Test EXTENDS TcUnit.FB_TestSuite + (* + Test the functionality of the motion bptm, + Which is just a bptm wrapped up with a set of n motors. + We're basically just making sure that we push the done button at the appropriate time. + Direct tests of BPTM itself are reserved for the pmps library. + + The BPTM takes care of these executions across multiple cycles, + so these tests must implement timeouts. + *) + VAR + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + stGoal1: ST_DbStateParams; + stGoal2: ST_DbStateParams; + stTrans: ST_DbStateParams; + stNoBeam: ST_BeamParams; + END_VAR + stGoal1.stBeamParams := PMPS_GVL.cstFullBeam; + stGoal1.nRequestAssertionID := 1; + stGoal1.sPmpsState := 'stGoal1'; + stGoal2.stBeamParams := PMPS_GVL.cstFullBeam; + stGoal2.stBeamParams.nTran := 0.5; + stGoal2.nRequestAssertionID := 2; + stGoal2.sPmpsState := 'stGoal2'; + stTrans.stBeamParams := PMPS_GVL.cst0RateBeam; + stTrans.nRequestAssertionID := 3; + stTrans.sPmpsState := 'stTrans'; + + // Just put a blanket global no beam so these won't wait for any changes ever + PMPS_GVL.stCurrentBeamParameters := stNoBeam; + TestInit(); + Test3dMove(); + TestNoMove(); + TestCount(); + + END_FUNCTION_BLOCK + + METHOD AssertInPool + VAR_IN_OUT + fbArbiter: FB_Arbiter; + stDbStateParams: ST_DbStateParams; + END_VAR + VAR_INPUT + bInPool: BOOL; + sContext: STRING; + END_VAR + IF bInPool THEN + AssertTrue( + fbArbiter.CheckRequestInPool(stDbStateParams.nRequestAssertionID), + CONCAT(CONCAT(stDbStateParams.sPmpsState, ' Beam parameters were not in the pool '), sContext), + ); + ELSE + AssertFalse( + fbArbiter.CheckRequestInPool(stDbStateParams.nRequestAssertionID), + CONCAT(CONCAT(stDbStateParams.sPmpsState, ' Beam parameters unexpectedly found in the pool '), sContext), + ); + END_IF + END_METHOD + + METHOD SetMotorDone + VAR_INPUT + END_VAR + // Force post-move state + astMotionStage[1].bBusy := FALSE; + astMotionStage[1].bDone := TRUE; + astMotionStage[2].bBusy := FALSE; + astMotionStage[2].bDone := TRUE; + astMotionStage[3].bBusy := FALSE; + astMotionStage[3].bDone := TRUE; + END_METHOD + + METHOD SetMotorMoving + VAR_INPUT + END_VAR + // Force a moving but not done state + astMotionStage[1].bBusy := TRUE; + astMotionStage[1].bDone := FALSE; + astMotionStage[2].bBusy := TRUE; + astMotionStage[2].bDone := FALSE; + astMotionStage[3].bBusy := TRUE; + astMotionStage[3].bDone := FALSE; + END_METHOD + + METHOD SetMotorStartup + VAR_INPUT + END_VAR + // Force some sort of default looking state + astMotionStage[1].bBusy := FALSE; + astMotionStage[1].bDone := FALSE; + astMotionStage[2].bBusy := FALSE; + astMotionStage[2].bDone := FALSE; + astMotionStage[3].bBusy := FALSE; + astMotionStage[3].bDone := FALSE; + END_METHOD + + METHOD Test3dMove : BOOL + (* + Can we safely do a 3d move? + *) + VAR_INST + fbBptm: FB_MotionBPTM; + fbArbiter: FB_Arbiter(2); + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbSubSysIO : FB_DummyArbIO; + + nState: UINT; + tonTimer: TON; + END_VAR + TEST('Test3DMove'); + + tonTimer( + IN:=TRUE, + PT:=T#5s, + ); + IF tonTimer.Q THEN + nState := 4; + END_IF + + CASE nState OF + 0: + // Establish baseline at Goal1 + SetMotorStartup(); + fbBptm( + astMotionStage:=astMotionStage, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=stGoal1, + stTransParams:=stTrans, + nActiveMotorCount:=3, + bEnable:=TRUE, + bAtState:=TRUE, + ); + IF fbBptm.bDone THEN + nState := 1; + END_IF + 1: + // Request a move + SetMotorStartup(); + fbBptm( + astMotionStage:=astMotionStage, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=stGoal2, + stTransParams:=stTrans, + nActiveMotorCount:=3, + bEnable:=TRUE, + bAtState:=FALSE, + ); + IF fbBptm.bTransitionAuthorized THEN + // We should have transition and goal 2 asserts in + AssertInPool(fbArbiter, stGoal1, FALSE, 'with trans auth'); + AssertInPool(fbArbiter, stGoal2, TRUE, 'with trans auth'); + AssertInPool(fbArbiter, stTrans, TRUE, 'with trans auth'); + nState := 2; + END_IF + 2: + // Simulate a move + SetMotorMoving(); + fbBptm( + astMotionStage:=astMotionStage, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=stGoal2, + stTransParams:=stTrans, + nActiveMotorCount:=3, + bEnable:=TRUE, + bAtState:=FALSE, + ); + // Same situation as before + AssertInPool(fbArbiter, stGoal1, FALSE, 'after move started'); + AssertInPool(fbArbiter, stGoal2, TRUE, 'after move started'); + AssertInPool(fbArbiter, stTrans, TRUE, 'after move started'); + nState := 3; + 3: + // Move is done + SetMotorDone(); + fbBptm( + astMotionStage:=astMotionStage, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=stGoal2, + stTransParams:=stTrans, + nActiveMotorCount:=3, + bEnable:=TRUE, + bAtState:=TRUE, + ); + IF fbBptm.bDone THEN + // Dropped the transition assert + AssertInPool(fbArbiter, stGoal1, FALSE, 'with move complete'); + AssertInPool(fbArbiter, stGoal2, TRUE, 'with move complete'); + AssertInPool(fbArbiter, stTrans, FALSE, 'with move complete'); + nState := 4; + END_IF + 4: + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + TEST_FINISHED(); + END_CASE + + fbSubSysIO( + LA:=fbArbiter, + FFO:=fbFFHWO, + ); + END_METHOD + + METHOD TestCount + (* + FB Should just error out if we forgot to give a count + *) + VAR_INST + fbBptm: FB_MotionBPTM; + fbArbiter: FB_Arbiter(1); + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + + tonWait: TON; + END_VAR + TEST('TestCount'); + + SetMotorStartup(); + fbBptm( + astMotionStage:=astMotionStage, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=stGoal1, + stTransParams:=stTrans, + bEnable:=True, + bAtState:=True, + ); + AssertTrue( + fbBptm.bMotorCountError, + 'Did not properly error on missing motor count', + ); + + tonWait( + IN:=TRUE, + PT:=T#1s, + ); + IF tonWait.Q THEN + // Should have no arbiter activity at all + AssertInPool(fbArbiter, stGoal1, FALSE, 'with bad count'); + AssertInPool(fbArbiter, stGoal2, FALSE, 'with bad count'); + AssertInPool(fbArbiter, stTrans, FALSE, 'with bad count'); + + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestInit : BOOL + (* + If we initialize with still motors, do we get an arbiter request at the current goal? Hopefully we do. + *) + VAR_INST + fbBptm: FB_MotionBPTM; + fbArbiter: FB_Arbiter(1); + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbSubSysIO : FB_DummyArbIO; + + tonTimer: TON; + END_VAR + TEST('TestInit'); + + SetMotorStartup(); + fbBptm( + astMotionStage:=astMotionStage, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=stGoal1, + stTransParams:=stTrans, + nActiveMotorCount:=3, + bEnable:=True, + bAtState:=True, + ); + fbSubSysIO( + LA:=fbArbiter, + FFO:=fbFFHWO, + ); + + tonTimer( + IN:=TRUE, + PT:=T#5s, + ); + IF tonTimer.Q OR fbBptm.bDone THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + // We should have a request in the pool for goal 1 but not for transition + // If no request are in the pool, we may come up in a no protection state! + // If both requests are in the pool, we may come up in a too much blocking beam state! + AssertInPool(fbArbiter, stGoal1, TRUE, 'at startup'); + AssertInPool(fbArbiter, stTrans, FALSE, 'at startup'); + + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestNoMove + (* + In place transitions should work at startup and also at done positions. + *) + VAR_INST + fbBptm: FB_MotionBPTM; + fbArbiter: FB_Arbiter(1); + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbSubSysIO : FB_DummyArbIO; + + nState: UINT; + tonTimer: TON; + END_VAR + TEST('TestNoMove'); + + tonTimer( + IN:=TRUE, + PT:=T#5s, + ); + IF tonTimer.Q THEN + nState := 3; + END_IF + + CASE nState OF + 0: + SetMotorStartup(); + fbBptm( + astMotionStage:=astMotionStage, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=stGoal1, + stTransParams:=stTrans, + nActiveMotorCount:=3, + bEnable:=True, + bAtState:=True, + ); + IF fbBptm.bDone THEN + nState := 1; + END_IF + 1: + SetMotorStartup(); + // NOTE: we kept bAtState TRUE the whole time, so this should be a completed in-place transition + fbBptm( + astMotionStage:=astMotionStage, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=stGoal2, + stTransParams:=stTrans, + nActiveMotorCount:=3, + bEnable:=True, + bAtState:=True, + ); + IF fbBptm.bDone THEN + // Only Goal2 should be in the pool + AssertInPool(fbArbiter, stGoal1, FALSE, 'after switching goals (1)'); + AssertInPool(fbArbiter, stGoal2, TRUE, 'after switching goals (1)'); + AssertInPool(fbArbiter, stTrans, FALSE, 'after switching goals (1)'); + nState := 2; + END_IF + 2: + // Repeat from a done position! + SetMotorDone(); + fbBptm( + astMotionStage:=astMotionStage, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=stGoal1, + stTransParams:=stTrans, + nActiveMotorCount:=3, + bEnable:=True, + bAtState:=True, + ); + IF fbBptm.bDone THEN + // Only Goal1 should be in the pool + AssertInPool(fbArbiter, stGoal1, TRUE, 'after switching goals (2)'); + AssertInPool(fbArbiter, stGoal2, FALSE, 'after switching goals (2)'); + AssertInPool(fbArbiter, stTrans, FALSE, 'after switching goals (2)'); + nState := 3; + END_IF + 3: + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + TEST_FINISHED(); + END_CASE + + fbSubSysIO( + LA:=fbArbiter, + FFO:=fbFFHWO, + ); + END_METHOD + + +Related: + * `FB_MotionBPTM`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + + +FB_MotionClearAsserts +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionClearAsserts + (* + Clear all of the PMPS asserts related to a states mover. + *) + VAR_IN_OUT + // All states to deactivate: transition + the static position states + astDbStateParams: ARRAY[0..GeneralConstants.MAX_STATES] OF ST_DbStateParams; + // The arbiter who made the PMPS assert requests + fbArbiter: FB_ARBITER; + END_VAR + VAR_INPUT + // Clear asserts on rising edge + bExecute: BOOL; + END_VAR + VAR_OUTPUT + END_VAR + VAR + rtExec: R_TRIG; + nIter: DINT; + END_VAR + rtExec(CLK:=bExecute); + IF rtExec.Q THEN + FOR nIter := 0 TO GeneralConstants.MAX_STATES DO + fbArbiter.RemoveRequest(astDbStateParams[nIter].nRequestAssertionID); + END_FOR + END_IF + + END_FUNCTION_BLOCK + + + + +FB_MotionClearAsserts_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionClearAsserts_Test EXTENDS TcUnit.FB_TestSuite + VAR + END_VAR + TestBasic(); + + END_FUNCTION_BLOCK + + METHOD TestBasic + VAR + nIter: UINT; + END_VAR + VAR_INST + fbClear: FB_MotionClearAsserts; + astDbStateParams: ARRAY[0..GeneralConstants.MAX_STATES] OF ST_DbStateParams; + fbArbiter: FB_Arbiter(1); + END_VAR + TEST('TestBasic'); + + FOR nIter := 0 TO GeneralConstants.MAX_STATES DO + astDbStateParams[nIter].nRequestAssertionID := 100 + nIter; + fbArbiter.AddRequest( + nReqID:=100 + nIter, + stReqBP:=PMPS_GVL.cstFullBeam, + sDevName:='UnitTest', + ); + END_FOR + + FOR nIter := 0 TO GeneralConstants.MAX_STATES DO + AssertTrue( + fbArbiter.CheckRequestInPool(100 + nIter), + CONCAT(CONCAT('State ', UDINT_TO_STRING(nIter)), ' was not in the pool'), + ); + END_FOR + + fbClear( + astDbStateParams:=astDbStateParams, + fbArbiter:=fbArbiter, + bExecute:=TRUE, + ); + + FOR nIter := 0 TO GeneralConstants.MAX_STATES DO + AssertFalse( + fbArbiter.CheckRequestInPool(100 + nIter), + CONCAT(CONCAT('State ', UDINT_TO_STRING(nIter)), ' was not cleared from the pool'), + ); + END_FOR + + TEST_FINISHED(); + END_METHOD + + +Related: + * `FB_MotionClearAsserts`_ + + +FB_MotionHoming +^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionHoming + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + VAR_INPUT + bExecute: BOOL; + END_VAR + VAR_OUTPUT + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorID: UDINT; + END_VAR + VAR + fbSetPos: MC_SetPosition; + fbJog: MC_Jog; + rtExec: R_TRIG; + ftExec: F_TRIG; + nHomeStateMachine: INT := IDLE; + nStateAfterStop: INT; + nMoves: INT; + bFirstDirection: BOOL; + bAtHome: BOOL; + bMove: BOOL; + nErrCount: INT; + bInterrupted: BOOL; + END_VAR + VAR CONSTANT + IDLE: INT := 0; + NEXT_MOVE: INT := 1; + CHECK_FWD: INT := 2; + CHECK_BWD: INT := 3; + FINAL_MOVE: INT := 4; + FINAL_SETPOS: INT := 5; + ERROR: INT := 6; + WAIT_STOP: INT := 7; + + (* + This is a simpler way of disabling the soft limits that ends up being really obvious if something has gone wrong. + If you turn the limits off/on, not only do you need to keep track of if you had soft limits set, + but you need to always restore this properly or risk some issue. + Instead, I set position to a ridiculous value that can always move forward or backward. + If this gets stuck for any reason it's very clear that something has gone wrong, + rather than a silent failure of the soft limit marks. + *) + FWD_START: LREAL := -99999999; + BWD_START: LREAL := 99999999; + END_VAR + fbSetPos.Options.ClearPositionLag := TRUE; + rtExec(CLK:=bExecute); + ftExec(CLK:=bExecute); + + bError R= NOT bExecute; + IF NOT bError THEN + nErrorID := 0; + END_IF + + CASE stMotionStage.nHomingMode OF + E_EpicsHomeCmd.LOW_LIMIT: + bFirstDirection := FALSE; + bAtHome := NOT stMotionStage.bLimitBackwardEnable; + bMove := TRUE; + E_EpicsHomeCmd.HIGH_LIMIT: + bFirstDirection := TRUE; + bAtHome := NOT stMotionStage.bLimitForwardEnable; + bMove := TRUE; + E_EpicsHomeCmd.HOME_VIA_LOW: + bFirstDirection := FALSE; + bAtHome := stMotionStage.bHome; + bMove := TRUE; + E_EpicsHomeCmd.HOME_VIA_HIGH: + bFirstDirection := TRUE; + bAtHome := stMotionStage.bHome; + bMove := TRUE; + E_EpicsHomeCmd.ABSOLUTE_SET: + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=bExecute, + Position:=stMotionStage.fHomePosition); + bBusy := rtExec.Q; + bDone := NOT rtExec.Q; + bMove := FALSE; + E_EpicsHomeCmd.NONE: + bMove := FALSE; + bBusy := rtExec.Q; + bDone := NOT rtExec.Q; + ELSE + bMove := FALSE; + END_CASE + + IF bMove THEN + IF bBusy AND ftExec.Q THEN + nHomeStateMachine := ERROR; + bInterrupted := TRUE; + END_IF + CASE nHomeStateMachine OF + // Wait for a rising edge + IDLE: + bBusy := FALSE; + nErrCount := 0; + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=FALSE); + fbJog( + Axis:=stMotionStage.Axis, + JogForward:=FALSE, + JogBackwards:=FALSE); + IF rtExec.Q THEN + nHomeStateMachine := NEXT_MOVE; + nMoves := 0; + bDone := FALSE; + bBusy := TRUE; + bError := FALSE; + nErrorID := 0; + bInterrupted := FALSE; + END_IF + // Figure out whether to move forward, move backward, or give up + NEXT_MOVE: + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=FALSE); + fbJog( + Axis:=stMotionStage.Axis, + JogForward:=FALSE, + JogBackwards:=FALSE); + CASE nMoves OF + 0: + IF bFirstDirection THEN + nStateAfterStop := CHECK_FWD; + ELSE + nStateAfterStop := CHECK_BWD; + END_IF + 1: + IF NOT bFirstDirection THEN + nStateAfterStop := CHECK_FWD; + ELSE + nStateAfterStop := CHECK_BWD; + END_IF + ELSE + nStateAfterStop := ERROR; + END_CASE + nMoves := nMoves + 1; + IF bAtHome THEN + nStateAfterStop := FINAL_MOVE; + END_IF + nHomeStateMachine := WAIT_STOP; + // Move forward until we find the home signal or reach end of travel + CHECK_FWD: + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=TRUE, + Position:=FWD_START); + fbJog( + Axis:=stMotionStage.Axis, + JogForward:=stMotionStage.bLimitForwardEnable AND NOT bATHome, + JogBackwards:=FALSE, + Mode:=E_JogMode.MC_JOGMODE_CONTINOUS, + Velocity:=stMotionStage.stAxisParameters.fRefVeloSearch); + IF NOT fbJog.JogForward THEN + nHomeStateMachine := NEXT_MOVE; + ELSIF fbJog.Error THEN + fbJog( + Axis:=stMotionStage.Axis, + JogForward:=FALSE, + JogBackwards:=FALSE); + nErrCount := nErrCount + 1; + IF nErrCount >= 3 THEN + nHomeStateMachine := ERROR; + END_IF + END_IF + // Move backward until we find the home signal or reach end of travel + CHECK_BWD: + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=TRUE, + Position:=BWD_START); + fbJog( + Axis:=stMotionStage.Axis, + JogForward:=FALSE, + JogBackwards:=stMotionStage.bLimitBackwardEnable AND NOT bATHome, + Mode:=E_JogMode.MC_JOGMODE_CONTINOUS, + Velocity:=stMotionStage.stAxisParameters.fRefVeloSearch); + IF NOT fbJog.JogBackwards THEN + nHomeStateMachine := NEXT_MOVE; + ELSIF fbJog.Error THEN + fbJog( + Axis:=stMotionStage.Axis, + JogForward:=FALSE, + JogBackwards:=FALSE); + nErrCount := nErrCount + 1; + IF nErrCount >= 3 THEN + nHomeStateMachine := ERROR; + END_IF + END_IF + // Set position to get within soft lims, move slowly off signal + FINAL_MOVE: + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=TRUE, + Position:=stMotionStage.fHomePosition); + IF bAtHome THEN + fbJog( + Axis:=stMotionStage.Axis, + JogForward:=NOT bFirstDirection, + JogBackwards:=bFirstDirection, + Mode:=E_JogMode.MC_JOGMODE_CONTINOUS, + Velocity:=stMotionStage.stAxisParameters.fRefVeloSync); + ELSIF fbJog.Error THEN + fbJog( + Axis:=stMotionStage.Axis, + JogForward:=FALSE, + JogBackwards:=FALSE); + nErrCount := nErrCount + 1; + IF nErrCount >= 3 THEN + nHomeStateMachine := ERROR; + END_IF + ELSE + fbJog( + Axis:=stMotionStage.Axis, + JogForward:=FALSE, + JogBackwards:=FALSE); + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=FALSE); + nHomeStateMachine := WAIT_STOP; + nStateAfterStop := FINAL_SETPOS; + END_IF + FINAL_SETPOS: + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=TRUE, + Position:=stMotionStage.fHomePosition); + nHomeStateMachine := IDLE; + bBusy := FALSE; + bDone := TRUE; + ERROR: + bError := TRUE; + nErrorID := fbJog.ErrorID; + nHomeStateMachine := FINAL_SETPOS; + fbSetPos( + Axis:=stMotionStage.Axis, + Execute:=FALSE); + IF bInterrupted THEN + stMotionStage.sCustomErrorMessage := 'Homing interrupted'; + ELSE + stMotionStage.sCustomErrorMessage := 'Homing failure'; + END_IF + WAIT_STOP: + IF stMotionStage.Axis.Status.NotMoving THEN + nHomeStateMachine := nStateAfterStop; + END_IF + END_CASE + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `E_EpicsHomeCmd`_ + * `ST_MotionStage`_ + + +FB_MotionPneumaticActuator +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + (*This function blcok implements a pnuematic actuator. That can be signle or double acting by setting the ibSingleCntrl accordingly*) + (* with double acting ibCntrlHold signal should be false, while with single acting the signal should be true*) + FUNCTION_BLOCK FB_MotionPneumaticActuator + VAR_INPUT + (*EPS Interlock Bits*) + ibInsertOK: BOOL; (*Actuator can be Inserted*) + ibRetractOK: BOOL; (*ACtuator can be retracted*) + ibPMPS_OK:BOOL; (*to be linked the Arbiter bit*) + ibSingleCntrl:BOOL;(* TRUE if Actuator requires one Output signal to be activated, FALSE if its double acting i.e two outputs are required*) + ibCntrlHold:BOOL; (* Control Signal must retain its value, must be TRUE in the case of single acting*) + ibOverrideInterlock:BOOL; (*if true interlocks are ignored*) + // Reset fault + {attribute 'pytmc' := ' + pv: FFO_Reset + '} + i_xReset: BOOL; + {attribute 'pytmc' := ' + pv: FFO_AutoReset + '} + i_xAutoReset: BOOL; + END_VAR + VAR_OUTPUT + {attribute 'pytmc' := ' + pv: + '} + stPneumaticActuator : ST_MotionPneumaticActuator; + {attribute 'pytmc' := ' + pv: MPS_OK + field: ZNAM FALSE + field: ONAM TRUE + field: DESC TRUE if MPS signal is OK + '} + xMPS_OK:BOOL; + END_VAR + VAR_IN_OUT + io_fbFFHWO : FB_HardwareFFOutput; + END_VAR + VAR + // PMPS + fbFF : FB_FastFault :=( + i_DevName := 'MPA', + i_Desc := 'Fault occurs when the device is moving', + i_TypeCode := E_MotionFFType.PNEUMATIC_MOVE); + + (*Init*) + xFirstPass : BOOL; + fbFSInit : R_TRIG; + + (* Timeouts*) + tTimeOutDuration: TIME:= T#10S; + tInserttimeout: TON; + tRetracttimeout:TON; + (*Limit switch latch timer*) + tLimitSwitchLatchDuration: TIME:=T#1S; + tInsertLimitSwitch:TON; + tRetractLimitSwitch:TON; + + (*Logging*) + fbLogger : FB_LogMessage := (eSubsystem:=E_SubSystem.MOTION); + ePrevState : E_PnuematicActuatorPositionState; + tAction : R_TRIG; // Primary action of this device (Insert_DO, Retract_DO, etc.) + tOverrideActivated : R_TRIG; + + (*IO*) + i_xInsertedLS AT%I*: BOOL; + i_xRetractedLS AT%I*: BOOL; + q_xInsert_DO AT%Q*: BOOL; + q_xRetract_DO AT%Q*: BOOL; + + END_VAR + (*Initialize*) + fbFSInit( CLK := TRUE, Q => xFirstPass); + IF xFirstPass THEN + stPneumaticActuator.eState := E_PnuematicActuatorPositionState.INVALID; + stPneumaticActuator.bRetract_SW := FALSE; + stPneumaticActuator.bInsert_SW := FALSE; + END_IF + + (*Soft IO Mapping to EPICS PVs*) + ACT_IO(); + + (* Manage States*) + IF stPneumaticActuator.i_bInLimitSwitch AND stPneumaticActuator.i_bOutLimitSwitch THEN + stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.INVALID; + ELSIF NOT stPneumaticActuator.i_bInLimitSwitch AND stPneumaticActuator.i_bOutLimitSwitch THEN + stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.RETRACTED; + ELSIF stPneumaticActuator.i_bInLimitSwitch AND NOT stPneumaticActuator.i_bOutLimitSwitch THEN + stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.INSERTED; + ELSIF NOT stPneumaticActuator.i_bInLimitSwitch AND NOT stPneumaticActuator.i_bOutLimitSwitch THEN + stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.MOVING; + ELSE + stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.INVALID ; + END_IF + + (*Set the Done/Busy signal*) + stPneumaticActuator.bDone := (stPneumaticActuator.bRetract_SW AND stPneumaticActuator.eState=E_PnuematicActuatorPositionState.RETRACTED) + OR (stPneumaticActuator.bInsert_SW AND stPneumaticActuator.eState=E_PnuematicActuatorPositionState.INSERTED); + stPneumaticActuator.bBusy := (stPneumaticActuator.bRetract_SW AND stPneumaticActuator.eState<>E_PnuematicActuatorPositionState.RETRACTED) + OR (stPneumaticActuator.bInsert_SW AND stPneumaticActuator.eState<>E_PnuematicActuatorPositionState.INSERTED); + (*MPS FAULT*) + (* MPS Faults when the actuator is in motion*) + xMPS_OK := (stPneumaticActuator.eState=E_PnuematicActuatorPositionState.RETRACTED) OR (stPneumaticActuator.eState=E_PnuematicActuatorPositionState.INSERTED); + (*PMPS PERMISSION*) + // yet to be implemented + + (* Can't have bRetract_SW and bInsert_SW both be true*) + If (stPneumaticActuator.bRetract_SW) AND (stPneumaticActuator.bInsert_SW) THEN + stPneumaticActuator.bRetract_SW := FALSE; + stPneumaticActuator.bInsert_SW := FALSE; + END_IF + //Redundant?? + (*Check if both digital outputs active at the same time, and clear all*) + IF stPneumaticActuator.q_bInsert THEN + stPneumaticActuator.q_bRetract := FALSE; + stPneumaticActuator.bRetract_SW:= FALSE; + END_IF; + IF stPneumaticActuator.q_bRetract THEN + stPneumaticActuator.q_bInsert := FALSE; + stPneumaticActuator.bInsert_SW:= FALSE; + END_IF; + + (*Actuate the device*) + stPneumaticActuator.q_bRetract := stPneumaticActuator.bRetractOK AND stPneumaticActuator.bRetract_SW AND NOT stPneumaticActuator.bInsert_SW ; + stPneumaticActuator.q_bInsert := stPneumaticActuator.bInsertOK AND stPneumaticActuator.bInsert_SW AND NOT stPneumaticActuator.bRetract_SW ; + + (*Reset the Control signal when command has been executed and give time to ensure the actuator is fully seated in either direction*) + IF (NOT ibSingleCntrl AND NOT ibCntrlHold) THEN + IF (stPneumaticActuator.bRetract_SW AND stPneumaticActuator.i_bOutLimitSwitch AND tRetractLimitSwitch.Q ) THEN stPneumaticActuator.q_bRetract := FALSE; END_IF + IF (stPneumaticActuator.bInsert_SW AND stPneumaticActuator.i_bInLimitSwitch AND tInsertLimitSwitch.Q) THEN stPneumaticActuator.q_bInsert := FALSE; END_IF + END_IF + + (*Timers*) + tInserttimeout(IN:= stPneumaticActuator.q_bInsert, PT := tTimeOutDuration ); + tRetracttimeout(IN:= stPneumaticActuator.q_bRetract, PT := tTimeOutDuration); + tInsertLimitSwitch(IN:= stPneumaticActuator.i_bInLimitSwitch, PT := tLimitSwitchLatchDuration); + tRetractLimitSwitch(IN:= stPneumaticActuator.i_bOutLimitSwitch, PT := tLimitSwitchLatchDuration); + + + ///Check moving postion timout + IF NOT stPneumaticActuator.i_bInLimitSwitch AND tInserttimeout.Q THEN + stPneumaticActuator.bError := TRUE; + stPneumaticActuator.sErrorMessage:= 'Actuator insert timeout'; + ELSIF NOT stPneumaticActuator.i_bOutLimitSwitch AND tRetracttimeout.Q THEN + stPneumaticActuator.bError := TRUE; + stPneumaticActuator.sErrorMessage:= 'Actuator retract timeout'; + END_IF + // Reset error + stPneumaticActuator.bError R= stPneumaticActuator.bReset; + + (*FAST FAULT*) + fbFF(i_xOK := xMPS_OK, + i_xReset := i_xReset, + i_xAutoReset := i_xAutoReset, + io_fbFFHWO := io_fbFFHWO); + + (*Soft IO Mapping to Epics pvs*) + ACT_IO(); + + END_FUNCTION_BLOCK + + ACTION ACT_IO: + (*Inputs*) + stPneumaticActuator.i_bInLimitSwitch := i_xInsertedLS; + stPneumaticActuator.i_bOutLimitSwitch := i_xRetractedLS; + + (*outputs*) + q_xInsert_DO:=stPneumaticActuator.q_bInsert; + q_xRetract_DO:=stPneumaticActuator.q_bRetract; + + (*EPICS*) + stPneumaticActuator.bRetractOK := ibRetractOK; + stPneumaticActuator.bInsertOK := ibInsertOK; + END_ACTION + + ACTION ACT_Logger: + // Log Valve timeouts + IF (tInserttimeout.Q OR tRetracttimeout.Q) THEN fbLogger(sMsg:=stPneumaticActuator.sErrorMessage, eSevr:=TcEventSeverity.Warning); END_IF + + // Log Actuator commands + // Log valve open + tAction(CLK:= (stPneumaticActuator.q_bRetract OR stPneumaticActuator.q_bInsert)); + IF tAction.Q THEN + IF(stPneumaticActuator.q_bRetract) THEN fbLogger(sMsg:='Actuator commanded retract', eSevr:=TcEventSeverity.Info); END_IF + IF(stPneumaticActuator.q_bInsert) THEN fbLogger(sMsg:='Actuator commanded insert', eSevr:=TcEventSeverity.Info); END_IF + END_IF + + + // State Logging + IF ePrevState <> stPneumaticActuator.eState THEN + CASE stPneumaticActuator.eState OF + E_PnuematicActuatorPositionState.INVALID: + fbLogger(sMsg:='Actuator invalid position.', eSevr:=TcEventSeverity.Critical); + E_PnuematicActuatorPositionState.MOVING: + fbLogger(sMsg:='Actuator moving', eSevr:=TcEventSeverity.Warning); + E_PnuematicActuatorPositionState.RETRACTED: + fbLogger(sMsg:='Actuator Retracted.', eSevr:=TcEventSeverity.Info); + E_PnuematicActuatorPositionState.INSERTED: + fbLogger(sMsg:='Actuator Inserted.', eSevr:=TcEventSeverity.Info); + END_CASE + ePrevState := stPneumaticActuator.eState; + END_IF + END_ACTION + + +Related: + * `E_MotionFFType`_ + * `E_PnuematicActuatorPositionState`_ + * `ST_MotionPneumaticActuator`_ + + +FB_MotionReadPMPSDBND +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionReadPMPSDBND + (* + When we read the JSON PMPS database file, update the lookup parameters for one state mover. + It is a building block not meant for use outside of lcls-twincat-motion. + + This is intended to support one N-dimensional state motion function block. + The keys for the database lookup can be set on any of the motor's position states. + Each of them have an allocated state.stPMPS.sPmpsState STRING parameter. + If there is a conflict and two of the motors disagree on parameter lookups, that will + be a fast fault. + + When the global JSON read function block is no longer busy and has no errors, + we will assume that the file has been read and we will update the parameters here. + + This will also re-read in the event that the input position state keys change in any way, + provided that we've read once before. + *) + VAR_IN_OUT + // Each motor's respective position states along its direction. These will not be modified. + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Hardware output to fault to if there is a problem. + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + // The database lookup key for the transition state. This has no corresponding ST_PositionState. + sTransitionKey: STRING; + // A name to use for fast faults, etc. + sDeviceName: STRING; + // For debug: set this to TRUE in online mode to read the database immediately. + bReadNow: BOOL; + END_VAR + VAR_OUTPUT + // The raw lookup results from this FB. Index 0 is the transition beam, the rest of the indices match the state positions. + astDbStateParams: ARRAY[0..GeneralConstants.MAX_STATES] OF ST_DbStateParams; + // TRUE if we've had at least one successful read. + bFirstReadDone: BOOL; + // This will be set to TRUE if there was an error reading from the database. + bError: BOOL; + END_VAR + VAR + ffError: FB_FastFault; + fbReadPmpsDb: FB_JsonDocToSafeBP; + ftDbBusy: F_TRIG; + ftRead: F_TRIG; + bReadPmpsDb: BOOL; + nIterMotor: DINT; + nIterState: DINT; + nIterState2: DINT; + sLoopNewKey: STRING; + sLoopPrevKey: STRING; + abStateError: ARRAY[0..GeneralConstants.MAX_STATES] OF BOOL; + asLookupKeys: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING; + asPrevLookupKeys: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING; + bNewKeys: BOOL; + sTempBackfill: STRING; + END_VAR + SelectLookupKeys(); + ReadDatabase(); + RunFastFaults(); + BackfillInfo(); + + END_FUNCTION_BLOCK + + ACTION BackfillInfo: + // Put the results of the PMPS lookup back to the motion states + // This is purely for debugging purposes, as only the astDbStateParams output is used by the libraries. + + // Copy everything except for the lookup key: avoid clobbering the user's original keys + // Do it this way instead of one element at a time to be forwards-compatible with any future additions to the db struct + FOR nIterState := 1 TO GeneralConstants.MAX_STATES DO + FOR nIterMotor := 1 TO MotionConstants.MAX_STATE_MOTORS DO + sTempBackfill := astPositionState[nIterMotor][nIterState].stPMPS.sPmpsState; + astPositionState[nIterMotor][nIterState].stPMPS := astDbStateParams[nIterState]; + astPositionState[nIterMotor][nIterState].stPMPS.sPmpsState := sTempBackfill; + END_FOR + END_FOR + END_ACTION + + ACTION ReadDatabase: + // Read the database at the right timing + ftDbBusy(CLK:=MOTION_GVL.fbPmpsFileReader.bBusy); + IF ftDbBusy.Q THEN + bReadPmpsDb S= NOT MOTION_GVL.fbPmpsFileReader.bError; + END_IF + + bReadPmpsDb S= bFirstReadDone AND bNewKeys; + bReadPmpsDb S= bReadNow; + bReadNow := FALSE; + + fbReadPmpsDb( + bExecute:=bReadPmpsDb, + jsonDoc:=PMPS_GVL.BP_jsonDoc, + sDeviceName:=sDeviceName, + io_fbFFHWO:=fbFFHWO, + arrStates:=astDbStateParams, + ); + bReadPmpsDb R= NOT fbReadPmpsDb.bBusy; + + ftRead(CLK:=fbReadPmpsDb.bBusy); + bFirstReadDone S= ftRead.Q AND NOT fbReadPmpsDb.bError; + END_ACTION + + ACTION RunFastFaults: + ffError( + i_xOK:=NOT bError, + i_xAutoReset:=TRUE, + i_DevName:=sDeviceName, + i_Desc:='Programmer error selecting state names in ND motion FB', + i_TypeCode:=E_MotionFFType.INTERNAL_ERROR, + io_fbFFHWO:=fbFFHWO, + ); + END_ACTION + + ACTION SelectLookupKeys: + // Fill the lookup key information in astDbStateParams based on the strings from astPositionState and sTransitionKey. + + // Start by emptying any pre-existing values + FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO + asLookupKeys[nIterState] := ''; + abStateError[nIterState] := FALSE; + END_FOR + + // Transition key is simple + asLookupKeys[0] := sTransitionKey; + + // The other keys might be at different points in the astPositionState array. + // Try all of the posibilities, set error if we end up overwriting something. + + // Outer loop: index of each motor at this position state + FOR nIterMotor := 1 TO MotionConstants.MAX_STATE_MOTORS DO + // Inner loop: index of each position state for this motor + FOR nIterState := 1 TO GeneralConstants.MAX_STATES DO + sLoopNewKey := astPositionState[nIterMotor][nIterState].stPMPS.sPmpsState; + IF sLoopNewKey <> '' THEN + // We have a new key, start doing things + sLoopPrevKey := asLookupKeys[nIterState]; + IF sLoopPrevKey = '' OR sLoopPrevKey = sLoopNewKey THEN + // No key yet, or exactly the same key (redudant programmer) + asLookupKeys[nIterState] := sLoopNewKey; + ELSE + // We already had a different key! Don't just override it, have an error! + bError := TRUE; + abStateError[nIterState] := TRUE; + END_IF + END_IF + END_FOR + END_FOR + + // Check for duplicated sPmpsState strings + FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO + FOR nIterState2 := 0 TO nIterState DO + IF nIterState <> nIterState2 AND asLookupKeys[nIterState] = asLookupKeys[nIterState2] AND asLookupKeys[nIterState] <> '' THEN + // Duplicated key, we need an error and a flag in both spots + bError := TRUE; + abStateError[nIterState] := TRUE; + abStateError[nIterState2] := TRUE; + END_IF + END_FOR + END_FOR + + // Clear the erroneous states so they won't be used as lookups + IF bError THEN + FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO + IF abStateError[nIterState] THEN + asLookupKeys[nIterState] := ''; + END_IF + END_FOR + END_IF + + // Copy the keys into the db state params + FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO + astDbStateParams[nIterState].sPmpsState := asLookupKeys[nIterState]; + END_FOR + + // Check if the keys changed from prev cycle + bNewKeys := FALSE; + FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO + IF asLookupKeys[nIterState] <> asPrevLookupKeys[nIterState] THEN + bNewKeys := TRUE; + EXIT; + END_IF + END_FOR + + // Save prev keys for next cycle + asPrevLookupKeys := asLookupKeys; + END_ACTION + + +Related: + * `E_MotionFFType`_ + * `MOTION_GVL`_ + * `MotionConstants`_ + * `ST_PositionState`_ + + +FB_MotionReadPMPSDBND_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionReadPMPSDBND_Test EXTENDS TcUnit.FB_TestSuite + (* + We test the actual db read in the pmps lib + Here, we test that the correct keys are ready for the read based on the inputs. + + The user submits a transition key and all of their ST_PositionState instances from all of their motors. + Any subset of these instances can have lookup keys. + + If only one state at the index has a lookup key, use that key. + If more than one state at the index has the same lookup key, use that key. + If states at the same index have different keys, that's an error and a fast fault. + If states at different indices have the same keys, that's an error and a fast fault. + *) + VAR + astCorrectStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astNonsenseStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astDuplicatedStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astHalfFullStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + nIter: UINT; + END_VAR + // Set up the state arrays that can be used in test methods + FOR nIter := 1 TO GeneralConstants.MAX_STATES DO + astCorrectStates[nIter].stPMPS.sPmpsState := CONCAT('State', UINT_TO_STRING(nIter)); + astNonsenseStates[nIter].stPMPS.sPmpsState := CONCAT('asdf', UINT_TO_STRING(nIter)); + IF UINT_TO_BOOL(nIter MOD 2) THEN + astDuplicatedStates[nIter].stPMPS.sPmpsState := 'State0'; + ELSE + astDuplicatedStates[nIter].stPMPS.sPmpsState := 'State1'; + END_IF + IF nIter <= GeneralConstants.MAX_STATES / 2 THEN + astHalfFullStates[nIter].stPMPS.sPmpsState := CONCAT('State', UINT_TO_STRING(nIter)); + END_IF + END_FOR + + TestSolo(); + TestTrio(); + TestNonsense(); + TestDupe(); + TestBackfill(); + TestHalfFull(); + + END_FUNCTION_BLOCK + + METHOD TestBackfill + VAR_INST + fbRead: FB_MotionReadPMPSDBND; + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + stDefaultBP: ST_DbStateParams; + END_VAR + TEST('TestBackfill'); + + astPositionState[1] := astCorrectStates; + // Pick a few parameters to drop in + astPositionState[1][3].stPMPS.stBeamParams.nRate := 999; + astPositionState[2][1].stPMPS.nRequestAssertionID := 777; + astPositionState[3][2].stPMPS.bBeamParamsLoaded := NOT stDefaultBP.bBeamParamsLoaded; + fbRead( + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + sTransitionKey:='State0', + sDeviceName:='TestBackfill', + ); + // Everything should be cleared to the defaults: the library should let us know what params got loaded (none) + AssertEquals_UDINT( + Expected:=stDefaultBP.stBeamParams.nRate, + Actual:=astPositionState[1][3].stPMPS.stBeamParams.nRate, + Message:='nRate of motor 1 state 3 not backfilled', + ); + AssertEquals_UDINT( + Expected:=stDefaultBP.nRequestAssertionID, + Actual:=astPositionState[2][1].stPMPS.nRequestAssertionID, + Message:='nRequestAssertionID of motor 2 state 3 not backfilled', + ); + AssertEquals_BOOL( + Expected:=stDefaultBP.bBeamParamsLoaded, + Actual:=astPositionState[3][2].stPMPS.bBeamParamsLoaded, + Message:='bBeamParamsLoaded of motor 3 state 2 not backfilled', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TestDupe + VAR_INST + fbRead: FB_MotionReadPMPSDBND; + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestDupe'); + + astPositionState[1] := astDuplicatedStates; + fbRead( + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + sTransitionKey:='State0', + sDeviceName:='TestTrio', + ); + fbFFHWO.EvaluateOutput(); + + AssertTrue( + fbRead.bError, + 'Should have had an error', + ); + FOR nIter := 0 TO GeneralConstants.MAX_STATES DO + AssertEquals_STRING( + Expected:='', + Actual:=fbRead.astDbStateParams[nIter].sPmpsState, + Message:=CONCAT('Errored output should have had no state names: ', UINT_TO_STRING(nIter)), + ); + END_FOR + + TEST_FINISHED(); + END_METHOD + + METHOD TestHalfFull + VAR_INST + fbRead: FB_MotionReadPMPSDBND; + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestHalfFull'); + + astPositionState[1] := astHalfFullStates; + fbRead( + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + sTransitionKey:='State0', + sDeviceName:='TestHalfFull', + ); + fbFFHWO.EvaluateOutput(); + + AssertFalse( + fbRead.bError, + 'Had an error', + ); + AssertEquals_STRING( + Expected:=fbRead.sTransitionKey, + Actual:=fbRead.astDbStateParams[0].sPmpsState, + Message:='Output did not have the correct transition state', + ); + FOR nIter := 1 TO GeneralConstants.MAX_STATES / 2 DO + AssertEquals_STRING( + Expected:=astCorrectStates[nIter].stPMPS.sPmpsState, + Actual:=fbRead.astDbStateParams[nIter].sPmpsState, + Message:=CONCAT('Output did not have the correct position state: ', UINT_TO_STRING(nIter)), + ); + END_FOR + + TEST_FINISHED(); + END_METHOD + + METHOD TestNonsense + VAR_INST + fbRead: FB_MotionReadPMPSDBND; + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestNonsense'); + + astPositionState[1] := astCorrectStates; + astPositionState[2] := astNonsenseStates; + fbRead( + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + sTransitionKey:='State0', + sDeviceName:='TestTrio', + ); + fbFFHWO.EvaluateOutput(); + + AssertTrue( + fbRead.bError, + 'Should have had an error', + ); + // Only the transition state should be spared from the nonsense + AssertEquals_STRING( + Expected:='State0', + Actual:=fbRead.astDbStateParams[0].sPmpsState, + Message:='Transition state should be OK', + ); + FOR nIter := 1 TO GeneralConstants.MAX_STATES DO + AssertEquals_STRING( + Expected:='', + Actual:=fbRead.astDbStateParams[nIter].sPmpsState, + Message:=CONCAT('Errored output should have had no state names: ', UINT_TO_STRING(nIter)), + ); + END_FOR + + TEST_FINISHED(); + END_METHOD + + METHOD TestSolo + VAR_INST + fbRead: FB_MotionReadPMPSDBND; + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestSolo'); + + astPositionState[1] := astCorrectStates; + fbRead( + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + sTransitionKey:='State0', + sDeviceName:='TestSolo', + ); + fbFFHWO.EvaluateOutput(); + + AssertFalse( + fbRead.bError, + 'Had an error', + ); + AssertEquals_STRING( + Expected:=fbRead.sTransitionKey, + Actual:=fbRead.astDbStateParams[0].sPmpsState, + Message:='Output did not have the correct transition state', + ); + FOR nIter := 1 TO GeneralConstants.MAX_STATES DO + AssertEquals_STRING( + Expected:=astCorrectStates[nIter].stPMPS.sPmpsState, + Actual:=fbRead.astDbStateParams[nIter].sPmpsState, + Message:=CONCAT('Output did not have the correct position state: ', UINT_TO_STRING(nIter)), + ); + END_FOR + + TEST_FINISHED(); + END_METHOD + + METHOD TestTrio + VAR_INST + fbRead: FB_MotionReadPMPSDBND; + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestTrio'); + + astPositionState[1] := astCorrectStates; + astPositionState[2] := astCorrectStates; + astPositionState[3] := astCorrectStates; + fbRead( + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + sTransitionKey:='State0', + sDeviceName:='TestTrio', + ); + fbFFHWO.EvaluateOutput(); + + AssertFalse( + fbRead.bError, + 'Had an error', + ); + AssertEquals_STRING( + Expected:=fbRead.sTransitionKey, + Actual:=fbRead.astDbStateParams[0].sPmpsState, + Message:='Output did not have the correct transition state', + ); + FOR nIter := 1 TO GeneralConstants.MAX_STATES DO + AssertEquals_STRING( + Expected:=astCorrectStates[nIter].stPMPS.sPmpsState, + Actual:=fbRead.astDbStateParams[nIter].sPmpsState, + Message:=CONCAT('Output did not have the correct position state: ', UINT_TO_STRING(nIter)), + ); + END_FOR + + TEST_FINISHED(); + END_METHOD + + +Related: + * `FB_MotionReadPMPSDBND`_ + * `MotionConstants`_ + * `ST_PositionState`_ + + +FB_MotionRequest +^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionRequest + (* + Request a move from an axis controlled via EPICS using FB_MotionStage + This exists to manage situations where different bits of code may need to move the same motor. + With just the ST_MotionStage/FB_MotionStage setup it is possible for two function blocks to + fight with and interfere with each other and with the EPICS commands. + *) + VAR_IN_OUT + // Motor to move + stMotionStage: ST_MotionStage; + END_VAR + VAR_INPUT + // Start move on rising edge, stop move on falling edge + bExecute: BOOL; + // Reset errors on rising edge + bReset: BOOL; + // Define behavior for when the motor is already moving + enumMotionRequest: E_MotionRequest := E_MotionRequest.WAIT; + // Goal position + fPos: LREAL; + // Move velocity + fVel: LREAL; + // Optional acceleration + fAcc: LREAL; + // Optional deceleration + fDec: LREAL; + END_VAR + VAR_OUTPUT + // True if in error state + bError: BOOL; + // Error code + nErrorId: UDINT; + // What the error code means + sErrorMessage: STRING; + // If TRUE, we are moving the motor + bBusy: BOOL; + // If TRUE, we are not moving the motor and our most recent move was successful + bDone: BOOL; + END_VAR + VAR + rtExec: R_TRIG; + ftExec: F_TRIG; + rtReset: R_TRIG; + ftBusy: F_TRIG; + nState: UINT := 0; + bMyMove: BOOL; + bCausedError: BOOL; + END_VAR + // Define local constants for our state machine states + VAR CONSTANT + INIT: UINT := 0; + WAIT_EXEC: UINT := 1; + PICK_REQUEST: UINT := 2; + WAIT_OTHER_MOVE: UINT := 3; + STOP_OTHER_MOVE: UINT := 4; + START_MOVE: UINT := 5; + WAIT_MY_MOVE: UINT := 6; + STOP_MY_MOVE: UINT := 7; + DONE_MOVING: UINT := 8; + ERROR: UINT := 9; + END_VAR + rtExec(CLK:=bExecute); + ftExec(CLK:=bExecute); + rtReset(CLK:=bReset); + + // Go back to INIT state on reset + IF rtReset.Q THEN + nState := INIT; + stMotionStage.bReset := TRUE; + END_IF + IF rtExec.Q OR ftExec.Q THEN + bDone := FALSE; + END_IF + + CASE nState OF + // Start by setting everything to a known value + INIT: + nState := WAIT_EXEC; + bError := FALSE; + sErrorMessage := ''; + bDone := FALSE; + bCausedError := FALSE; + // Normal "waiting for move command" state + WAIT_EXEC: + bMyMove := FALSE; + // Looking for a rising edge on bExecute + IF rtExec.Q THEN + bDone := FALSE; + nState := PICK_REQUEST; + END_IF + // Decide how to handle the request + PICK_REQUEST: + IF stMotionStage.bBusy THEN + CASE enumMotionRequest OF + E_MotionRequest.WAIT: + nState := WAIT_OTHER_MOVE; + E_MotionRequest.INTERRUPT: + nState := STOP_OTHER_MOVE; + E_MotionRequest.ABORT: + nState := ERROR; + bError := TRUE; + nErrorId := 16#7900; + END_CASE + ELSE + nState := START_MOVE; + END_IF + // Watch the other move, then see if it's our turn + WAIT_OTHER_MOVE: + IF NOT stMotionStage.bBusy THEN + // Try to pick request again next cycle once the move is over + nState := PICK_REQUEST; + END_IF + // Interrupt the other move, then go to start ours + STOP_OTHER_MOVE: + stMotionStage.bExecute := FALSE; + IF NOT stMotionStage.bBusy THEN + nState := START_MOVE; + END_IF + // Set the correct values on ST_MotionStage to start a new absolute move + START_MOVE: + bMyMove := TRUE; + stMotionStage.bExecute := TRUE; + stMotionStage.nCommand := E_EpicsMotorCmd.MOVE_ABSOLUTE; + stMotionStage.fPosition := fPos; + stMotionStage.fVelocity := fVel; + stMotionStage.fAcceleration := fAcc; + stMotionStage.fDeceleration := fDec; + nState := WAIT_MY_MOVE; + // Watch our ongoing move, look for the move to end or requests to stop the move from this FB + WAIT_MY_MOVE: + ftBusy(CLK:=stMotionStage.bBusy); + IF ftBusy.Q THEN + nState := DONE_MOVING; + END_IF + // Implement stop on falling trigger + IF ftExec.Q THEN + nState := STOP_MY_MOVE; + END_IF + // Request a stop and wait for it to happen + STOP_MY_MOVE: + stMotionStage.bExecute := FALSE; + IF NOT stMotionStage.bBusy THEN + nState := DONE_MOVING; + END_IF + // Pick out the bDone state and return to waiting + DONE_MOVING: + bDone := stMotionStage.bDone; + nState := WAIT_EXEC; + // Lock us into the error state until the FB is reset + ERROR: + bMyMove := FALSE; + END_CASE + + // Transition to the ERROR state if applicable + IF bMyMove AND stMotionStage.bError THEN + nState := ERROR; + bError := TRUE; + nErrorId := stMotionStage.nErrorId; + bCausedError := TRUE; + END_IF + sErrorMessage := F_MotionErrorCodeLookup(nErrorId := nErrorId); + + CASE nState OF + INIT, WAIT_EXEC, ERROR: + bBusy := FALSE; + ELSE + bBusy := TRUE; + END_CASE + + END_FUNCTION_BLOCK + + +Related: + * `E_EpicsMotorCmd`_ + * `E_MotionRequest`_ + * `FB_MotionStage`_ + * `F_MotionErrorCodeLookup`_ + * `ST_MotionStage`_ + + +FB_MotionStage +^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionStage + (* + Default implementation for PLC behavior when motor IOC asks for a move + This can be extended or replaced in your PLC project if you want + non-default behavior to arise from the motor record processing + *) + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + VAR + fbDriveVirtual: FB_DriveVirtual; + fbMotionHome: FB_MotionHoming; + fbSaveRestore: FB_EncSaveRestore; + fbLogError: FB_LogMotionError; + bExecute: BOOL; + bExecMove: BOOL; + bExecHome: BOOL; + bFwdHit: BOOL; + bBwdHit: BOOL; + ftExec: F_TRIG; + rtExec: R_TRIG; + rtUserExec: R_TRIG; + rtTarget: R_TRIG; + rtHomed: R_TRIG; + fbSetEnables: FB_SetEnables; + bPosGoal: BOOL; + bNegGoal: BOOL; + fbEncoderValue: FB_EncoderValue; + fbNCParams: FB_MotionStageNCParams; + bNewMoveReq: BOOL; + bPrepareDisable: BOOL; + bMoveCmd: BOOL; + rtMoveCmdShortcut: R_TRIG; + rtHomeCmdShortcut: R_TRIG; + END_VAR + // Start with an accurate status + stMotionStage.Axis.ReadStatus(); + + // Check for the plc shortcut commands + // Used for testing or to circumvent motor record issues + rtMoveCmdShortcut(CLK:=stMotionStage.bMoveCmd); + rtHomeCmdShortcut(CLK:=stMotionStage.bHomeCmd); + // Execute on rising edge + IF rtMoveCmdShortcut.Q AND NOT stMotionStage.bExecute THEN + stMotionStage.bExecute := TRUE; + stMotionStage.nCommand := E_EpicsMotorCmd.MOVE_ABSOLUTE; + ELSIF rtHomeCmdShortcut.Q AND NOT stMotionStage.bExecute THEN + stMotionStage.bExecute := TRUE; + stMotionStage.nCommand := E_EpicsMotorCmd.HOME; + END_IF + // Always reset, even if not rising edge, so command can be issued again + IF stMotionStage.bMoveCmd OR stMotionStage.bHomeCmd THEN + stMotionStage.bMoveCmd := FALSE; + stMotionStage.bHomeCmd := FALSE; + END_IF + + // Automatically fill the correct nCmdData for homing + IF stMotionStage.nCommand = E_EpicsMotorCmd.HOME THEN + stMotionStage.nCmdData := stMotionStage.nHomingMode; + END_IF + + // Check if the command wants to cause a move + bMoveCmd R= stMotionStage.nCmdData = E_EpicsHomeCmd.ABSOLUTE_SET; + bMoveCmd R= stMotionStage.nCmdData = E_EpicsHomeCmd.NONE; + bMoveCmd S= stMotionStage.nCommand <> E_EpicsMotorCmd.HOME; + + // Handle main execs + rtUserExec(CLK := stMotionStage.bExecute); + bNewMoveReq S= rtUserExec.Q AND bMoveCmd; + bNewMoveReq R= NOT stMotionStage.bExecute; + bPrepareDisable R= bNewMoveReq; + + bPosGoal := stMotionStage.stAxisStatus.fActPosition < stMotionStage.fPosition; + bNegGoal := stMotionStage.stAxisStatus.fActPosition > stMotionStage.fPosition; + + // Moves are automatically allowed if no safety hooks. Otherwise, some other code will set this. + stMotionStage.bSafetyReady S= stMotionStage.bPowerSelf; + + // Handle auto-enable timing + CASE stMotionStage.nEnableMode OF + E_StageEnableMode.ALWAYS: + stMotionStage.bEnable := TRUE; + E_StageEnableMode.DURING_MOTION: + IF bNewMoveReq THEN + IF stMotionStage.nCommand = E_EpicsMotorCmd.HOME THEN + stMotionStage.bEnable := stMotionStage.bSafetyReady; + ELSIF bPosGoal THEN + IF stMotionStage.bAllForwardEnable THEN + stMotionStage.bEnable S= stMotionStage.bSafetyReady; + ELSIF NOT stMotionStage.bError THEN + // Not an error, just a warning + stMotionStage.sErrorMessage := 'Cannot move past positive limit.'; + stMotionStage.bExecute := FALSE; + END_IF + ELSIF bNegGoal THEN + IF stMotionStage.bAllBackwardEnable THEN + stMotionStage.bEnable S= stMotionStage.bSafetyReady; + ELSIF NOT stMotionStage.bError THEN + // Not an error, just a warning + stMotionStage.sErrorMessage := 'Cannot move past negative limit.'; + stMotionStage.bExecute := FALSE; + END_IF + ELSE + // Super rare condition where we asked for a move to exactly the same floating point we're already at + stMotionStage.bEnable S= stMotionStage.bSafetyReady; + END_IF + IF stMotionStage.bEnable OR stMotionStage.bError THEN + bNewMoveReq := FALSE; + END_IF + END_IF + END_CASE + + // Update all enable booleans + fbSetEnables(stMotionStage:=stMotionStage); + + IF stMotionStage.stAxisStatus.bBusy AND NOT bExecute THEN + // Wait for the previous move to end + bExecute := FALSE; + ELSIF bMoveCmd THEN + // Do not start the move until we have power and the safety system says it is OK + bExecute := stMotionStage.bExecute AND stMotionStage.bAllEnable AND stMotionStage.bEnableDone AND stMotionStage.bSafetyReady; + ELSE + bExecute := stMotionStage.bExecute; + END_IF + + IF bExecute AND NOT stMotionStage.bError THEN + // Reset local warnings if things are going well + stMotionStage.sErrorMessage := ''; + END_IF + + // No moves allowed in error states + IF stMotionStage.bError THEN + bExecute := FALSE; + END_IF + + + bExecHome := bExecute AND stMotionStage.nCommand = 10; + bExecMove := bExecute AND NOT bExecHome; + + // Handle standard commands using ESS's FB + fbDriveVirtual(En:=TRUE, + bEnable:=stMotionStage.bAllEnable, + bReset:=stMotionStage.bReset, + bExecute:=bExecMove, + nCommand:=INT_TO_UINT(stMotionStage.nCommand), + nCmdData:=INT_TO_UINT(stMotionStage.nCmdData), + fVelocity:=stMotionStage.fVelocity, + fPosition:=stMotionStage.fPosition, + fAcceleration:=stMotionStage.fAcceleration, + fDeceleration:=stMotionStage.fDeceleration, + bLimitFwd:=stMotionStage.bAllForwardEnable, + bLimitBwd:=stMotionStage.bAllBackwardEnable, + bHomeSensor:=stMotionStage.bHome, + fHomePosition:=stMotionStage.fHomePosition, + bPowerSelf:=stMotionStage.bPowerSelf, + nMotionAxisID=>stMotionStage.nMotionAxisID, + Axis:=stMotionStage.Axis); + + // Some custom home handling + fbMotionHome( + stMotionStage:=stMotionStage, + bExecute:=bExecHome); + + // Update status again after the move starts or stops + stMotionStage.Axis.ReadStatus(); + + // Check for a new error + IF NOT stMotionStage.bError THEN + stMotionStage.bError := fbDriveVirtual.bError; + stMotionStage.nErrorId := fbDriveVirtual.nErrorId; + END_IF + IF NOT stMotionStage.bError THEN + stMotionStage.bError := fbMotionHome.bError; + stMotionStage.nErrorId := fbMotionHome.nErrorId; + END_IF + IF NOT stMotionStage.bError AND stMotionStage.bExecute AND NOT stMotionStage.bUserEnable THEN + stMotionStage.bError := TRUE; + stMotionStage.nErrorId := 1; + stMotionStage.sCustomErrorMessage := 'Move requested, but user enable is disabled!'; + END_IF + + // Set the error message if we have one + IF stMotionStage.bError THEN + // Hook if other code wants to inject a non-NC error + IF stMotionStage.sCustomErrorMessage <> '' THEN + stMotionStage.sErrorMessage := stMotionSTage.sCustomErrorMessage; + ELSE + stMotionStage.sErrorMessage := F_MotionErrorCodeLookup(nErrorId := stMotionStage.nErrorId); + END_IF + END_IF + + fbLogError( + stMotionStage:=stMotionStage, + bEnable:=TRUE); + + // When we start, set the busy/done appropriately + rtExec(CLK:=bExecute); + IF rtExec.Q THEN + stMotionStage.bBusy := TRUE; + stMotionStage.bDone := FALSE; + END_IF + + // Force everything off in case of error + IF stMotionStage.bError THEN + stMotionStage.bBusy := FALSE; + stMotionStage.bDone := FALSE; + stMotionStage.bEnable := FALSE; + END_IF + + // Check the limits and cancel execution if appropriate. Without this block we have infinite error spam + bFwdHit := stMotionStage.Axis.Status.PositiveDirection AND NOT stMotionStage.bAllForwardEnable; + bBwdHit := stMotionStage.Axis.Status.NegativeDirection AND NOT stMotionStage.bAllBackwardEnable; + IF (bFwdHit OR bBwdHit) AND NOT fbMotionHome.bBusy THEN + stMotionStage.bExecute := FALSE; + END_IF + + // Check done moving via user stop, fbDriveVirtual and Target Position Monitoring, or from homing. + ftExec(CLK:=stMotionStage.bExecute); + rtTarget(CLK:=(stMotionStage.Axis.Status.InTargetPosition AND fbDriveVirtual.bDone AND bExecMove)); + rtHomed(CLK:=fbMotionHome.bDone AND bExecHome); + IF ftExec.Q OR rtTarget.Q OR rtHomed.Q THEN + IF NOT stMotionStage.bDone THEN + stMotionStage.bDone := TRUE; + stMotionStage.bBusy := FALSE; + IF NOT stMotionStage.Axis.Status.Error THEN + bExecute := FALSE; + stMotionStage.bExecute := FALSE; + END_IF + END_IF + END_IF + + // Handle auto-disable timing + bPrepareDisable S= stMotionStage.nEnableMode = E_StageEnableMode.DURING_MOTION AND ftExec.Q; + // Delay the disable until we reach standstill, else brake issues or other race conditions + IF bPrepareDisable AND stMotionStage.Axis.Status.MotionState = MC_AXISSTATE_STANDSTILL THEN + bPrepareDisable := FALSE; + stMotionStage.bEnable := FALSE; + END_IF + + // Get a definitive bEnabled reading + CASE stMotionStage.Axis.Status.MotionState OF + // We are not enabled if there is an issue + MC_AXISSTATE_UNDEFINED, MC_AXISSTATE_DISABLED, MC_AXISSTATE_ERRORSTOP: + stMotionStage.bEnableDone := FALSE; + ELSE + stMotionStage.bEnableDone := TRUE; + END_CASE + + // Handle the brake. TRUE means brake disabled/released + IF stMotionStage.nBrakeMode <> E_StageBrakeMode.NO_BRAKE THEN + CASE stMotionStage.Axis.Status.MotionState OF + MC_AXISSTATE_UNDEFINED, + MC_AXISSTATE_DISABLED, + MC_AXISSTATE_ERRORSTOP: + stMotionStage.bBrakeRelease := FALSE; + MC_AXISSTATE_STANDSTILL: + IF stMotionStage.nBrakeMode = E_StageBrakeMode.IF_MOVING THEN + stMotionStage.bBrakeRelease := FALSE; + ELSE + stMotionStage.bBrakeRelease := TRUE; + END_IF + ELSE + stMotionStage.bBrakeRelease := TRUE; + END_CASE + END_IF + + // Sync the epics status struct + stMotionStage.stAxisStatus := fbDriveVirtual.stAxisStatus; + stMotionStage.stAxisStatus.bEnabled := stMotionStage.bEnableDone; + + // Override homing status, dmov as appropriate + stMotionStage.bHomed := fbMotionHome.bDone AND NOT fbMotionHome.bError; + stMotionStage.stAxisStatus.bHomed := stMotionStage.bHomed; + stMotionStage.stAxisStatus.bExecute := bExecute; + stMotionStage.stAxisStatus.nCommand := 3; // If this is not 3, the IOC stops updating positions during homing + + // Fill in auxiliary status info + stMotionStage.fPosDiff := stMotionStage.Axis.NcToPlc.PosDiff; + + // Reset everything when bReset is flagged + IF stMotionStage.bReset THEN + stMotionStage.bEnable := FALSE; + stMotionStage.bReset := FALSE; + stMotionStage.bExecute := FALSE; + stMotionStage.bError := FALSE; + stMotionStage.nErrorId := 0; + stMotionStage.sErrorMessage := ''; + stMotionStage.sCustomErrorMessage := ''; + bExecute := FALSE; + END_IF + + fbEncoderValue(stMotionStage:=stMotionStage); + fbNCParams( + stMotionStage:=stMotionStage, + bEnable:=TRUE, + tRefreshDelay:=T#1s); + + // Save and restore as long as not an absolute encoder + fbSaveRestore( + stMotionStage:=stMotionStage, + bEnable:=stMotionStage.nHomingMode <> E_EpicsHomeCmd.NONE); + + END_FUNCTION_BLOCK + + +Related: + * `E_EpicsHomeCmd`_ + * `E_EpicsMotorCmd`_ + * `E_StageBrakeMode`_ + * `E_StageEnableMode`_ + * `FB_DriveVirtual`_ + * `FB_EncSaveRestore`_ + * `FB_EncoderValue`_ + * `FB_LogMotionError`_ + * `FB_MotionHoming`_ + * `FB_MotionStageNCParams`_ + * `FB_SetEnables`_ + * `F_MotionErrorCodeLookup`_ + * `ST_MotionStage`_ + + +FB_MotionStageNCParams +^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionStageNCParams + (* + Read and refresh axis parameters struct on ST_MotionStage + *) + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + VAR_INPUT + bEnable: BOOL; + tRefreshDelay: TIME; + END_VAR + VAR_OUTPUT + bError: BOOL; + END_VAR + VAR + mcReadParams: MC_ReadParameterSet; + timer: TON; + bExecute: BOOL := TRUE; + nLatchErrId: UDINT; + END_VAR + timer( + IN:=bEnable AND NOT bExecute, + PT:=tRefreshDelay); + bExecute S= timer.Q; + mcReadParams( + Parameter:=stMotionStage.stAxisParameters, + Axis:=stMotionStage.Axis, + Execute:=bEnable AND bExecute, + Error=>bError); + IF mcReadParams.ErrorID <> 0 THEN + nLatchErrId := 0; + END_IF + bExecute R= mcReadParams.Done OR mcReadParams.Error; + stMotionStage.bAxisParamsInit S= mcReadParams.Done; + + END_FUNCTION_BLOCK + + +Related: + * `ST_MotionStage`_ + + +FB_MotionStageSim +^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotionStageSim + (* + Set all the values needed for a fake motor to be movable + via the IOC, then call FB_MotionStage + *) + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + VAR_INPUT + nEnableMode: E_StageEnableMode := E_StageEnableMode.ALWAYS; + END_VAR + VAR + fbMotionStage: FB_MotionStage; + bInit: BOOL; + END_VAR + IF NOT bInit THEN + bInit := TRUE; + // Stand-in for no forward limit + stMotionStage.bLimitForwardEnable := TRUE; + // Stand-in for no reverse limit + stMotionStage.bLimitBackwardEnable := TRUE; + // Stand-in for no STO button + stMotionStage.bHardwareEnable := TRUE; + // Stand-in for no PMPS governer + stMotionStage.bPowerSelf := TRUE; + // Always keep it enabled for testing ease + stMotionStage.nEnableMode := nEnableMode; + END_IF + // Call FB_MotionStage to do the thing + fbMotionStage(stMotionStage := stMotionStage); + + END_FUNCTION_BLOCK + + +Related: + * `E_StageEnableMode`_ + * `FB_MotionStage`_ + * `ST_MotionStage`_ + + +FB_MotorTestSuite +^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_MotorTestSuite EXTENDS TcUnit.FB_TestSuite + (* + Base class for motion tests. + + Contains some helper methods that would otherwise need to be instantiated many times, + but in this form can be accessed quickly and succinctly in the test suite. + *) + + + END_FUNCTION_BLOCK + + METHOD SetEnables + (* + Set a motion stage's enables such that it is fully allowed to move. + *) + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + stMotionStage.bHardwareEnable := TRUE; + stMotionStage.bLimitBackwardEnable := TRUE; + stMotionStage.bLimitForwardEnable := TRUE; + stMotionStage.bPowerSelf := TRUE; + END_METHOD + + METHOD SetEnablesPMPS + (* + Set a motion stage's enables such that only PMPS would be preventing a move. + *) + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + SetEnables(stMotionStage); + stMotionStage.bPowerSelf := FALSE; + END_METHOD + + METHOD SetGoodState + (* + Mark a state as valid and ready to use. + *) + VAR_IN_OUT + stPositionState: ST_PositionState; + END_VAR + stPositionState.bMoveOk := TRUE; + stPositionState.bValid := TRUE; + END_METHOD + + +Related: + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_NcAxis +^^^^^^^^^ + +:: + + ///######################################################### + ///Function block to communicate between Nc and Plc. + /// + /// Library: + /// Tc2_MC2.lib + /// + /// Global Variables: + /// + /// Data types: + /// + /// External functions: + /// + ///########################################################### + FUNCTION_BLOCK FB_NcAxis + VAR + sVersion: STRING:='1.0.0'; + END_VAR + VAR_INPUT + En: BOOL; + END_VAR + VAR_OUTPUT + EnO: BOOL; + bError: BOOL; + Status: ST_AxisStatus; + END_VAR + VAR + Axis: AXIS_REF; + InfoData_State AT %I*: UINT; + END_VAR + EnO:=En; + + IF En AND InfoData_State<>16#8 THEN + bError:=TRUE; + ELSE + bError:=FALSE; + END_IF + + IF En THEN + Axis.ReadStatus(); + Status:=Axis.Status; + END_IF + + END_FUNCTION_BLOCK + + + + +FB_NCErrorFFO +^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_NCErrorFFO + (* + Configure a ST_MotionStage to trigger an FFO when we have an error. + + This can be configured to only apply to specific error ranges, + though the default is the normal 16#4XXX NC error range. The error + ranges are: + 16#40XX General Errors + 16#41XX Channel Errors + 16#42XX Group Errors + 16#43XX Axis Errors + 16#44XX Encoder Errors + 16#45XX Controller Errors + 16#46XX Drive Errors + 16#4AXX Table Errors + 16#4BXX NC PLC Errors + 16#4CXX Kinematic Transformation + + There is also a new extended NC error range, but it is sparsely populated. + This range is 16#8XXX: + 16#8100 - 16#811F: Bode plot (diagnosis) + 16#8120 - 16#8FFF: Further errors + + To configure multiple ranges, simply use multiple instances of this + function block. + *) + VAR_IN_OUT + // Motion stage to monitor + stMotionStage: ST_MotionStage; + // FFO to trip + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + // Reset the fault + bReset: BOOL; + // Auto-reset the fault + bAutoReset: BOOL; + // The lowest error code that will trip the FFO + nLowErrorId: UDINT := 16#4000; + // The highest error code that will trip the FFO + nHighErrorId: UDINT := 16#4FFF; + // A description of the fault + sDesc: STRING := 'Motor error'; + END_VAR + VAR_OUTPUT + // Quick way for nearby code to check if this block has tripped the FFO. + bTripped: BOOL; + // Error code sent to PMPS. Is always 16#20XX, where XX is the first two hex in the NC error. + nErrorTypeCode: UINT; + END_VAR + VAR + bInit: BOOL; + stBeamParams: ST_BeamParams; + fbFF: FB_FastFault; + rtTrip: R_TRIG; + END_VAR + IF NOT bInit THEN + fbFF.i_Desc := sDesc; + IF LEN(stMotionStage.sName) > 0 THEN + fbFF.i_DevName := stMotionStage.sName; + ELSE + fbFF.i_DevName := 'Unnamed Motor'; + END_IF + bInit := TRUE; + END_IF + + bTripped := stMotionStage.bError AND stMotionStage.nErrorId >= nLowErrorId AND stMotionStage.nErrorId <= nHighErrorId; + rtTrip(CLK:=bTripped); + IF rtTrip.Q THEN + nErrorTypeCode := E_MotionFFType.LOW_RESERVED_NC + UDINT_TO_UINT(SHR(stMotionStage.nErrorId, 8)); + nErrorTypeCode := MIN(nErrorTypeCode, E_MotionFFType.HIGH_RESERVED_NC); + END_IF + fbFF(i_xOK := NOT bTripped, + i_xReset := bReset, + i_xAutoReset := bAutoReset, + i_TypeCode:= nErrorTypeCode, + io_fbFFHWO := fbFFHWO); + + END_FUNCTION_BLOCK + + +Related: + * `E_MotionFFType`_ + * `ST_MotionStage`_ + + +FB_NCErrorFFO_Test +^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_NCErrorFFO_Test EXTENDS TcUnit.FB_TestSuite + (* + Test the following related FBs: + - FB_NCErrorFFO + - FB_EncErrorFFO + + These function blocks are designed to trip the beam when there + is an NC error reported by stMotionStage. + *) + VAR + stMotionStage: ST_MotionStage; + fbMotionStage: FB_MotionStage; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbCauseNCError: FB_CauseNCError; + + fbNCErrorFFO: FB_NCErrorFFO; + fbEncErrorFFO: FB_EncErrorFFO; + + nTestCounter: UINT; + bOneTestDone: BOOL; + tonTimer: TON; + END_VAR + fbMotionStage(stMotionStage:=stMotionStage); + // Limit to drive errors so I can isolate it from the enc error + fbNCErrorFFO( + stMotionStage:=stMotionStage, + fbFFHWO:=fbFFHWO, + bAutoReset:=TRUE, + nLowErrorId:=16#4500, + nHighErrorId:=16#45FF, + ); + fbEncErrorFFO( + stMotionStage:=stMotionStage, + fbFFHWO:=fbFFHWO, + bAutoReset:=TRUE, + ); + // Fast fault output is TRUE when there are no issues and FALSE when there is an issue + fbFFHWO.EvaluateOutput(); + + TestNC(0); + TestEnc(1); + + IF bOneTestDone THEN + bOneTestDone := FALSE; + nTestCounter := nTestCounter + 1; + tonTimer(IN:=FALSE); + fbCauseNCError( + Axis:=stMotionStage.Axis, + bExecute:=FALSE, + ); + stMotionStage.bReset := TRUE; + fbMotionStage(stMotionStage:=stMotionStage); + END_IF + // Use this timer to time out any tests that stall + tonTimer( + IN:=TRUE, + PT:=T#5s, + ); + + END_FUNCTION_BLOCK + + METHOD TestEnc + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + nState: UINT; + END_VAR + TEST('TestEncError'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + CASE nState OF + 0: + // First cycle: no error, no fault + AssertFalse( + stMotionStage.bError, + 'Should have had no error before running this test', + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Should have had no fault with no error', + ); + nState := 1; + 1: + // Next time: cause an error + fbCauseNCError( + Axis:=stMotionStage.Axis, + bExecute:=TRUE, + nErrorCode:=16#4467, // Invalid encoder position data + ); + END_CASE + + // Wait for the fault or the timeout, then check everything + IF tonTimer.Q OR (NOT fbFFHWO.q_xFastFaultOut AND stMotionStage.nErrorID = 16#4467) THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + AssertTrue( + stMotionStage.bError, + 'Did not get motor error in error test', + ); + AssertEquals_UDINT( + Expected:=16#4467, + Actual:=stMotionStage.nErrorId, + Message:='Error causer is broken', + ); + AssertFalse( + fbFFHWO.q_xFastFaultOut, + Message:='Did not cause a fast fault', + ); + AssertFalse( + fbNCErrorFFO.bTripped, + Message:='Drive error FB tripped with an enc error', + ); + AssertTrue( + fbEncErrorFFO.bTripped, + Message:='Enc error fb did not trip with an enc error', + ); + bOneTestDone := TRUE; + nState := 0; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestNC + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + nState: UINT; + END_VAR + TEST('TestNCError'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + CASE nState OF + 0: + // First cycle: no error, no fault + AssertFalse( + stMotionStage.bError, + 'Should have had no error before running this test', + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Should have had no fault with no error', + ); + nState := 1; + 1: + // Next time: cause an error + fbCauseNCError( + Axis:=stMotionStage.Axis, + bExecute:=TRUE, + nErrorCode:=16#4550, // Position lag monitoring error code + ); + END_CASE + + // Wait for the fault or the timeout, then check everything + IF tonTimer.Q OR (NOT fbFFHWO.q_xFastFaultOut AND stMotionStage.nErrorId = 16#4550) THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + AssertTrue( + stMotionStage.bError, + 'Did not get motor error in error test', + ); + AssertEquals_UDINT( + Expected:=16#4550, + Actual:=stMotionStage.nErrorId, + Message:='Error causer is broken', + ); + AssertFalse( + fbFFHWO.q_xFastFaultOut, + Message:='Did not cause a fast fault', + ); + AssertTrue( + fbNCErrorFFO.bTripped, + Message:='NC error FB did not trip with a drive error', + ); + AssertFalse( + fbEncErrorFFO.bTripped, + Message:='Enc error tripped with a drive error', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + +Related: + * `FB_CauseNCError`_ + * `FB_EncErrorFFO`_ + * `FB_MotionStage`_ + * `FB_NCErrorFFO`_ + * `ST_MotionStage`_ + + +FB_PerMotorFFOND +^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PerMotorFFOND + (* + PMPS fast faults that must be done per motor, rather than per state, based purely + on the motor status and not other PMPS considerations. + + These currently include: + - Fault if the encoder has an error. Every other protection is based on the encoder, + so we can't trust anything if the encoder is faulting. + *) + VAR_IN_OUT + // All motors associated with the state mover. + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + // Fast fault output to fault to. + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + // The number of motors we're actually using + nActiveMotorCount: UINT; + // Identifying name to use in group fast faults + sDeviceName: STRING; + END_VAR + VAR_OUTPUT + // Set to TRUE if the arrays don't have the same bounds. In this FB, that's an automatic fault. + bMotorCountError: BOOL; + END_VAR + VAR + afbEncError: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF FB_EncErrorFFO; + ffProgrammerError: FB_FastFault; + nIter: DINT; + END_VAR + CheckCount(); + IF NOT bMotorCountError THEN + HandleLoops(); + END_IF + HandleFFO(); + + END_FUNCTION_BLOCK + + ACTION CheckCount: + // Make sure the motor count is valid (positive, nonzero, less or equal to the max) + bMotorCountError S= nActiveMotorCount <= 0; + bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS; + END_ACTION + + ACTION HandleFFO: + ffProgrammerError( + i_xOK:=NOT bMotorCountError, + i_xAutoReset:=TRUE, + i_DevName:=sDeviceName, + i_Desc:='Programmer error picking motor count', + i_TypeCode:=E_MotionFFType.INTERNAL_ERROR, + io_fbFFHWO:=fbFFHWO, + ); + END_ACTION + + ACTION HandleLoops: + FOR nIter := 1 TO nActiveMotorCount DO + afbEncError[nIter]( + stMotionstage:=astMotionStage[nIter], + fbFFHWO:=fbFFHWO, + bAutoReset:=TRUE, + ); + END_FOR + END_ACTION + + +Related: + * `E_MotionFFType`_ + * `FB_EncErrorFFO`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + + +FB_PerMotorFFOND_Test +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PerMotorFFOND_Test EXTENDS TcUnit.FB_TestSuite + (* + FFO if an illogical motor count is passed + FFO if any motor has what looks like an encoder error + - We'll just simulate this without doing it legit + - The legit test is done elsewhere + More FFOs may be added later and these will need to be tested too + *) + VAR + END_VAR + TestBlankCount(); + TestTwoMotorEncError(); + + END_FUNCTION_BLOCK + + METHOD TestBlankCount : BOOL + VAR_INST + fbFFO: FB_PerMotorFFOND; + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestBlankCount'); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Started with a fault', + ); + fbFFO( + astMotionStage:=astMotionStage, + fbFFHWO:=fbFFHWO, + ); + fbFFHWO.EvaluateOutput(); + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Blank count did not fault', + ); + AssertTrue( + fbFFO.bMotorCountError, + 'Blank count did not error', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TestTwoMotorEncError : BOOL + VAR_INST + fbFFO: FB_PerMotorFFOND; + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestTwoMotorEncError'); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Started with a fault', + ); + astMotionStage[2].bError := TRUE; + astMotionStage[2].nErrorId := 16#4467; // Invalid encoder position data + fbFFO( + astMotionStage:=astMotionStage, + fbFFHWO:=fbFFHWO, + nActiveMotorCount:=2, + ); + fbFFHWO.EvaluateOutput(); + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Encoder error did not fault', + ); + + TEST_FINISHED(); + END_METHOD + + +Related: + * `FB_PerMotorFFOND`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + + +FB_PMPSJsonTestHelper +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PMPSJsonTestHelper + (* + Create a JSON doc in memory to match the input structs + Assumes 1 device for simplicity + Writes to the global pmps json doc + *) + VAR_IN_OUT + astBeamParams: ARRAY[*] OF ST_DbStateParams; + END_VAR + VAR_INPUT + bExecute: BOOL; + sDevName: STRING; + END_VAR + VAR_OUTPUT + END_VAR + VAR + rtExec: R_TRIG; + jsonRoot: SJsonValue; + jsonDevice: SJsonValue; + ajsonState: ARRAY[0..GeneralConstants.MAX_STATES] OF SJsonValue; + fbJson: FB_JsonDomParser; + + nIter: DINT; + nId: DINT; + + aseVRange: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING; + asRate: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING; + asBCRange: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING; + asTran: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING; + END_VAR + rtExec(CLK:=bExecute); + IF NOT rtExec.Q THEN + RETURN; + END_IF + + jsonRoot := fbJson.NewDocument(); + jsonDevice := fbJson.AddObjectMember(jsonRoot, sDevName); + FOR nIter := LOWER_BOUND(astBeamParams, 1) TO UPPER_BOUND(astBeamParams, 1) DO + ajsonState[nIter] := fbJson.AddObjectMember(jsonDevice, astBeamParams[nIter].sPmpsState); + + nId := nId + 1; + fbJson.AddIntMember( + v:=ajsonState[nIter], + member:='id', + value:=nId, + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='beamline', + value:='tst', + ); + aseVRange[nIter] := bitmaskToString(astBeamParams[nIter].stBeamParams.neVRange, 32); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='neVRange', + value:=aseVRange[nIter], + ); + asRate[nIter] := UDINT_TO_STRING(astBeamParams[nIter].stBeamParams.nRate); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='nRate', + value:=asRate[nIter], + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='ap_ygap', + value:='', + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='ap_xgap', + value:='', + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='damage_limit', + value:='', + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='notes', + value:='', + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='reactive_temp', + value:='', + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='reactive_pressure', + value:='', + ); + asBCRange[nIter] := bitmaskToString(astBeamParams[nIter].stBeamParams.nBCRange, 15); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='nBeamClassRange', + value:=asBCRange[nIter], + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='name', + value:=astBeamParams[nIter].sPmpsState, + ); + asTran[nIter] := REAL_TO_STRING(astBeamParams[nIter].stBeamParams.nTran); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='nTran', + value:=asTran[nIter], + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='ap_name', + value:='None', + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='ap_ycenter', + value:='', + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='ap_xcenter', + value:='', + ); + fbJson.AddStringMember( + v:=ajsonState[nIter], + member:='pulse_energy', + value:='', + ); + fbJson.AddBoolMember( + v:=ajsonState[nIter], + member:='special', + value:=FALSE, + ); + END_FOR + + PMPS_GVL.BP_jsonDoc := jsonRoot; + + END_FUNCTION_BLOCK + + METHOD bitmaskToString : STRING + VAR_INPUT + nBitmask: DWORD; + nBits: UINT; + END_VAR + VAR + nIter: UINT; + END_VAR + bitmaskToString := ''; + FOR nIter := 1 TO nBits DO + bitmaskToString := CONCAT(DWORD_TO_STRING(SHR(nBitmask, nIter - 1) AND 1), bitmaskToString); + END_FOR + END_METHOD + + + + +FB_PositionState1D +^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionState1D + (* + 1-Dimensional position state function block. + + This allows the user to move a motor among some set of named state positions. + + To use a states block, you must define enums that match the state options and give them pytmc pragmas. + See FB_PositionState1D_InOut for a simple example. + These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables. + The enum values must match the array indices in astPositionState. + + A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us + to accept a new, possibly conflicting, move request on the next cycle to interrupt the first. + + The motor must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly. + + With no PMPS handling, this FB basically just links the state names with positions in both directions for set and readback. + *) + VAR_IN_OUT + // The motor to move. + stMotionStage: ST_MotionStage; + // All possible position states, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE + io: io + expand: :%.2d + '} + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input. + eEnumSet: UINT; + // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output. + eEnumGet: UINT; + END_VAR + VAR_INPUT + // Set this to TRUE to enable input state moves, or FALSE to disable them. + bEnable: BOOL; + // Normal EPICS inputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stEpicsToPlc: ST_StateEpicsToPlc; + END_VAR + VAR_OUTPUT + // Normal EPICS outputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPlcToEpics: ST_StatePlcToEpics; + END_VAR + VAR + fbCore: FB_PositionStateND_Core; + astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + astMotionStageMax[1] := stMotionStage; + astPositionStateMax[1] := astPositionState; + + fbCore( + astMotionStageMax:=astMotionStageMax, + astPositionStateMax:=astPositionStateMax, + stEpicsToPlc:=stEpicsToPlc, + stPlcToEpics:=stPlcToEpics, + eEnumSet:=eEnumSet, + eEnumGet:=eEnumGet, + bEnable:=bEnable, + nActiveMotorCount:=1, + ); + + stMotionStage := astMotionStageMax[1]; + astPositionState := astPositionStateMax[1]; + + END_FUNCTION_BLOCK + + +Related: + * `FB_MotionStage`_ + * `FB_PositionState1D_InOut`_ + * `FB_PositionStateND_Core`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + * `ST_StateEpicsToPlc`_ + * `ST_StatePlcToEpics`_ + + +FB_PositionState1D_InOut +^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionState1D_InOut + (* + An example and usable drop-in instance for a 1D state device with just an IN and an OUT state. + *) + VAR_IN_OUT + // Include a stage that can be passed into the FB + stMotionStage: ST_MotionStage; + // Simplify the interface, the user just needs to construct and pass in and out position states + stIn: ST_PositionState; + stOut: ST_PositionState; + END_VAR + VAR_INPUT + // Define an ENUM for EPICS to use to set a new value. It is expected this will be written to during one cycle, so don't continually apply a value here in the PLC code. + // It is exposed as an input so we can test it using the PLC. + {attribute 'pytmc' := ' + pv: STATE:SET + io: io + '} + eStateReq: E_EpicsInOut; + END_VAR + VAR_OUTPUT + // Define an ENUM for EPICS to use to report the new value. + {attribute 'pytmc' := ' + pv: STATE:GET + io: i + '} + eStateGet: E_EpicsInOut; + END_VAR + VAR + // Include the standard fb with blank pv pragma + {attribute 'pytmc' := 'pv:'} + fbPositionState1D: FB_PositionState1D; + // The standard fb expects a full array of position states + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + // Optional: default state names + IF stIn.sName = '' THEN + stIn.sName := 'IN'; + END_IF + IF stOut.sName = '' THEN + stOut.sName := 'OUT'; + END_IF + + // Assemble the states array, matching the enum values (IN is 1, OUT is 2) + astPositionState[1] := stIn; + astPositionState[2] := stOut; + + // Call the main function block, passing our motors, states, enums and an enable + fbPositionState1D( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + eEnumSet:=eStateReq, + eEnumGet:=eStateGet, + bEnable:=TRUE, + ); + + // Send updates made on the array back to the inputs (VAR_IN_OUT) for maximum clarity + stIn := astPositionState[1]; + stOut := astPositionState[2]; + + END_FUNCTION_BLOCK + + +Related: + * `E_EpicsInOut`_ + * `FB_PositionState1D`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionState2D +^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionState2D + (* + 2-Dimensional position state function block. + + This allows the user to move 2 motors among some set of named state positions. + + To use a states block, you must define enums that match the state options and give them pytmc pragmas. + See FB_PositionState1D_InOut for a simple example. + These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables. + The enum values must match the array indices in astPositionState1 and astPositionState2. + + A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us + to accept a new, possibly conflicting, move request on the next cycle to interrupt the first. + + The motors must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly. + + With no PMPS handling, this FB basically just links the state names with positions in both directions for set and readback. + *) + VAR_IN_OUT + // The 1st motor to move + stMotionStage1: ST_MotionStage; + // The 2nd motor to move + stMotionStage2: ST_MotionStage; + // All possible position states for motor 1, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:01 + io: io + expand: :%.2d + '} + astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // All possible position states for motor 2, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:02 + io: io + expand: :%.2d + '} + astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input. + eEnumSet: UINT; + // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output. + eEnumGet: UINT; + END_VAR + VAR_INPUT + // Set this to TRUE to enable input state moves, or FALSE to disable them. + bEnable: BOOL; + // Normal EPICS inputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stEpicsToPlc: ST_StateEpicsToPlc; + END_VAR + VAR_OUTPUT + // Normal EPICS outputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPlcToEpics: ST_StatePlcToEpics; + END_VAR + VAR + fbCore: FB_PositionStateND_Core; + astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + astMotionStageMax[1] := stMotionStage1; + astMotionStageMax[2] := stMotionStage2; + astPositionStateMax[1] := astPositionState1; + astPositionStateMax[2] := astPositionState2; + + fbCore( + astMotionStageMax:=astMotionStageMax, + astPositionStateMax:=astPositionStateMax, + stEpicsToPlc:=stEpicsToPlc, + stPlcToEpics:=stPlcToEpics, + eEnumSet:=eEnumSet, + eEnumGet:=eEnumGet, + bEnable:=bEnable, + nActiveMotorCount:=2, + ); + + stMotionStage1 := astMotionStageMax[1]; + stMotionStage2 := astMotionStageMax[2]; + astPositionState1 := astPositionStateMax[1]; + astPositionState2 := astPositionStateMax[2]; + + END_FUNCTION_BLOCK + + +Related: + * `FB_MotionStage`_ + * `FB_PositionState1D_InOut`_ + * `FB_PositionStateND_Core`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + * `ST_StateEpicsToPlc`_ + * `ST_StatePlcToEpics`_ + + +FB_PositionState2D_InOut +^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionState2D_InOut + (* + An example and usable drop-in instance for a 2D state device with just an IN and an OUT state. + *) + VAR_IN_OUT + // Include stages that can be passed into the FB + stMotionStage1: ST_MotionStage; + stMotionStage2: ST_MotionStage; + // Simplify the interface, the user just needs to construct and pass in and out position states + stIn1: ST_PositionState; + stOut1: ST_PositionState; + stIn2: ST_PositionState; + stOut2: ST_PositionState; + END_VAR + VAR_INPUT + // Define an ENUM for EPICS to use to set a new value. It is expected this will be written to during one cycle, so don't continually apply a value here in the PLC code. + // It is exposed as an input so we can test it using the PLC. + {attribute 'pytmc' := ' + pv: STATE:SET + io: io + '} + eStateSet: E_EpicsInOut; + END_VAR + VAR_OUTPUT + // Define an ENUM for EPICS to use to report the new value. + {attribute 'pytmc' := ' + pv: STATE:GET + io: i + '} + eStateGet: E_EpicsInOut; + END_VAR + VAR + // Include the standard fb with blank pv pragma + {attribute 'pytmc' := 'pv:'} + fbPositionState2D: FB_PositionState2D; + // The standard fb expects a full array of position states per motor + astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + // Optional: default state names + IF stIn1.sName = '' THEN + stIn1.sName := 'IN'; + END_IF + IF stOut1.sName = '' THEN + stOut1.sName := 'OUT'; + END_IF + IF stIn2.sName = '' THEN + stIn2.sName := 'IN'; + END_IF + IF stOut2.sName = '' THEN + stOut2.sName := 'OUT'; + END_IF + + // Assemble the states arrays, matching the enum values (IN is 1, OUT is 2) + astPositionState1[1] := stIn1; + astPositionState1[2] := stOut1; + astPositionState2[1] := stIn2; + astPositionState2[2] := stOut2; + + // Call the main function block, passing our motors, states, and an enable + fbPositionState2D( + stMotionStage1:=stMotionStage1, + astPositionState1:=astPositionState1, + stMotionStage2:=stMotionStage2, + astPositionState2:=astPositionState2, + eEnumSet:=eStateSet, + eEnumGet:=eStateGet, + bEnable:=TRUE, + ); + + // Send updates made on the array back to the inputs (VAR_IN_OUT) for maximum clarity + stIn1 := astPositionState1[1]; + stOut1 := astPositionState1[2]; + stIn2 := astPositionState2[1]; + stOut2 := astPositionState2[2]; + + END_FUNCTION_BLOCK + + +Related: + * `E_EpicsInOut`_ + * `FB_PositionState2D`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionState3D +^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionState3D + (* + 3-Dimensional position state function block. + + This allows the user to move 3 motors among some set of named state positions. + + To use a states block, you must define enums that match the state options and give them pytmc pragmas. + See FB_PositionState1D_InOut for a simple example. + These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables. + The enum values must match the array indices in astPositionState1, astPositionState2, and astPositionState3. + + A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us + to accept a new, possibly conflicting, move request on the next cycle to interrupt the first. + + The motors must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly. + + With no PMPS handling, this FB basically just links the state names with positions in both directions for set and readback. + *) + VAR_IN_OUT + // The 1st motor to move + stMotionStage1: ST_MotionStage; + // The 2nd motor to move + stMotionStage2: ST_MotionStage; + // The 3rd motor to move + stMotionStage3: ST_MotionStage; + // All possible position states for motor 1, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:01 + io: io + expand: :%.2d + '} + astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // All possible position states for motor 2, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:02 + io: io + expand: :%.2d + '} + astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // All possible position states for motor 3, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:03 + io: io + expand: :%.2d + '} + astPositionState3: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input. + eEnumSet: UINT; + // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output. + eEnumGet: UINT; + END_VAR + VAR_INPUT + // Set this to TRUE to enable input state moves, or FALSE to disable them. + bEnable: BOOL; + // Normal EPICS inputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stEpicsToPlc: ST_StateEpicsToPlc; + END_VAR + VAR_OUTPUT + // Normal EPICS outputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPlcToEpics: ST_StatePlcToEpics; + END_VAR + VAR + fbCore: FB_PositionStateND_Core; + astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + astMotionStageMax[1] := stMotionStage1; + astMotionStageMax[2] := stMotionStage2; + astMotionStageMax[3] := stMotionStage3; + astPositionStateMax[1] := astPositionState1; + astPositionStateMax[2] := astPositionState2; + astPositionStateMax[3] := astPositionState3; + + fbCore( + astMotionStageMax:=astMotionStageMax, + astPositionStateMax:=astPositionStateMax, + stEpicsToPlc:=stEpicsToPlc, + stPlcToEpics:=stPlcToEpics, + eEnumSet:=eEnumSet, + eEnumGet:=eEnumGet, + bEnable:=bEnable, + nActiveMotorCount:=3, + ); + + stMotionStage1 := astMotionStageMax[1]; + stMotionStage2 := astMotionStageMax[2]; + stMotionStage3 := astMotionStageMax[3]; + astPositionState1 := astPositionStateMax[1]; + astPositionState2 := astPositionStateMax[2]; + astPositionState3 := astPositionStateMax[3]; + + END_FUNCTION_BLOCK + + +Related: + * `FB_MotionStage`_ + * `FB_PositionState1D_InOut`_ + * `FB_PositionStateND_Core`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + * `ST_StateEpicsToPlc`_ + * `ST_StatePlcToEpics`_ + + +FB_PositionStateBase +^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use FB_PositionState1D instead'} + FUNCTION_BLOCK FB_PositionStateBase + (* + Handles EPICS moves between multiple states for a single axis + Should be subclassed for a specific enumSet and enumGet. + See body comment or FB_PositionStateInOut for an implementation example. + *) + VAR_IN_OUT + // Motor to move + stMotionStage: ST_MotionStage; + END_VAR + VAR_INPUT + // If TRUE, start a move when setState transitions to a nonzero number + bEnable: BOOL; + // On rising edge, reset this FB + {attribute 'pytmc' := ' + pv: RESET + io: io + field: ZNAM False + field: ONAM True + '} + bReset: BOOL; + END_VAR + VAR_OUTPUT + // If TRUE, there is an error + {attribute 'pytmc' := ' + pv: ERR + io: i + field: ZNAM False + field: ONAM True + '} + bError: BOOL; + // Error ID + {attribute 'pytmc' := ' + pv: ERRID + io: i + '} + nErrorId: UDINT; + // The error that caused bError to flip TRUE + {attribute 'pytmc' := ' + pv: ERRMSG + io: i + '} + sErrorMessage: STRING; + // If TRUE, we are moving the motor + {attribute 'pytmc' := ' + pv: BUSY + io: i + field: ZNAM False + field: ONAM True + '} + bBusy: BOOL; + // If TRUE, we are not moving the motor and the last move completed successfully + {attribute 'pytmc' := ' + pv: DONE + io: i + field: ZNAM False + field: ONAM True + '} + bDone: BOOL; + END_VAR + VAR + // Pre-allocated array of states + {attribute 'pytmc' := ' + pv: + io: io + expand: %.2d + '} + arrStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + + // Corresponding arrStates index to move to, or 0 if no move selected + setState: INT; + // The current position we are trying to reach, or 0 + goalState: INT; + // The readback position + getState: INT; + + bInit: BOOL; + stUnknown: ST_PositionState; + stGoal: ST_PositionState; + fbStateMove: FB_PositionStateMove; + fbStateInternal: ARRAY[1..GeneralConstants.MAX_STATES] OF FB_PositionStateInternal; + nIndex: INT; + bNewGoal: BOOL; + bInnerExec: BOOL; + bInnerReset: BOOL; + rtReset: R_TRIG; + bMoveRequested: BOOL; + END_VAR + (* + Subclass me, define enums to translate setState and getState, call Exec + + Example: + + + setState := enumSet; + Exec(); + enumGet := getState; + enumSet := setState; + *) + + END_FUNCTION_BLOCK + + ACTION Exec: + StateHandler(); + END_ACTION + + ACTION StateHandler: + // Reset just goes through the first-cycle init again + rtReset(CLK:=bReset); + IF rtReset.Q THEN + bInit := FALSE; + bReset := FALSE; + END_IF + + // First-cycle init + IF NOT bInit THEN + bError := FALSE; + nErrorID := 0; + sErrorMessage := ''; + bBusy := FALSE; + bDone := FALSE; + bNewGoal := FALSE; + bInnerExec := FALSE; + bInnerReset := TRUE; + setState := 0; + goalState := 0; + END_IF + + // All state internal handlers + FOR nIndex := 1 TO GeneralConstants.MAX_STATES DO + IF arrStates[nIndex].bValid THEN + fbStateInternal[nIndex]( + stMotionStage:=stMotionStage, + stPositionState:=arrStates[nIndex]); + END_IF + END_FOR + + // Check where we are by going through all possible states. + // Note this favors the highest-number state that we're at, it's up to you to make your states mutually exclusive. + getState := 0; + FOR nIndex := 1 TO GeneralConstants.MAX_STATES DO + IF F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=arrStates[nIndex]) THEN + getState := nIndex; + END_IF + END_FOR + + // Use the changing set pv as a rising-edge trigger + IF setState <> goalState THEN + goalState := setState; + bNewGoal := TRUE; + END_IF + + // Special move handling for error/enable state + IF bError OR NOT bEnable THEN + bInnerExec := FALSE; + ELSIF bNewGoal THEN + IF fbStateMove.bBusy THEN + // Stop previous move if we were already moving but want a new move + bInnerExec := FALSE; + ELSE + // If we hit this branch, we're ready to start a new move + bInnerExec := TRUE; + bInnerReset := FALSE; + bNewGoal := FALSE; + END_IF + END_IF + + // Pick the correct goal structure or Unknown + IF goalState = 0 THEN + stGoal := stUnknown; + ELSE + stGoal := arrStates[goalState]; + END_IF + + // Do the move + fbStateMove( + stMotionStage := stMotionStage, + stPositionState := stGoal, + bExecute := bInnerExec, + bReset := bInnerReset, + enumMotionRequest := E_MotionRequest.INTERRUPT, + bBusy => bBusy); + + // Only pass up bDone information if this FB is active + IF bInnerExec THEN + bDone := fbStateMove.bDone; + END_IF + + // Pick up any new errors, but don't override uncleared existing errors + IF NOT bError THEN + bError := fbStateMove.bError; + IF bError THEN + nErrorId := fbStateMove.nErrorId; + sErrorMessage := fbStateMove.sErrorMessage; + END_IF + END_IF + + // Reset the setpoint and goal to 0 if we're not doing anything + // because FB is waiting for a change from 0 to "something" + bMoveRequested := bInnerExec AND NOT bDone; + IF NOT bError AND NOT bNewGoal AND NOT bMoveRequested THEN + setState := 0; + goalState := 0; + bInnerExec := FALSE; + END_IF + + // Bring inner reset back low at the end of the init cycle so that it can be triggered again later + IF NOT bInit THEN + bInit := TRUE; + bInnerReset := FALSE; + END_IF + END_ACTION + + +Related: + * `E_MotionRequest`_ + * `FB_PositionState1D`_ + * `FB_PositionStateInOut`_ + * `FB_PositionStateInternal`_ + * `FB_PositionStateMove`_ + * `F_AtPositionState`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateBase_WithPMPS +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use FB_PositionStatePMPS1D instead'} + FUNCTION_BLOCK FB_PositionStateBase_WithPMPS EXTENDS FB_PositionStateBase + (* + Handles EPICS moves between multiple states for a single axis with PMPS. + Should be subclassed for a specific enumSet and enumGet. + See body comment or FB_PositionStateInOut_WithPMPS for an implementation example. + *) + VAR_IN_OUT + fbArbiter: FB_Arbiter; + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + sPmpsDeviceName: STRING; + sTransitionKey: STRING; + {attribute 'pytmc' := ' + pv: PMPS:ARB:ENABLE + io: io + '} + bArbiterEnabled: BOOL := TRUE; + tArbiterTimeout: TIME := T#1s; + bMoveOnArbiterTimeout: BOOL := TRUE; + fStateBoundaryDeadband: LREAL := 0; + bBPOKAutoReset: BOOL := False; + END_VAR + VAR + {attribute 'pytmc' := 'pv: PMPS'} + fbStatePMPS: FB_PositionStatePMPS; + fbEncErrFFO: FB_EncErrorFFO; + END_VAR + (* + Subclass me, define enums to translate setState and getState, call Exec + + Example: + + + setState := enumSet; + Exec(); + enumGet := getState; + enumSet := setState; + *) + + END_FUNCTION_BLOCK + + ACTION Exec: + StateHandler(); + PMPSHandler(); + END_ACTION + + ACTION PMPSHandler: + fbStatePMPS( + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stMotionStage:=stMotionStage, + arrStates:=arrStates, + sPmpsDeviceName:=sPmpsDeviceName, + sTransitionKey:=sTransitionKey, + stPmpsDoc:= PMPS_GVL.BP_jsonDoc, + bRequestTransition:=setState <> 0, + setState:=setState, + getState:=getState, + bArbiterEnabled:=bArbiterEnabled, + tArbiterTimeout:=tArbiterTimeout, + bMoveOnArbiterTimeout:=bMoveOnArbiterTimeout, + fStateBoundaryDeadband:=fStateBoundaryDeadband, + bBPOKAutoReset:=bBPOKAutoReset); + + fbEncErrFFO( + stMotionStage:=stMotionStage, + fbFFHWO:=fbFFHWO, + bAutoReset:=TRUE); + END_ACTION + + +Related: + * `FB_EncErrorFFO`_ + * `FB_PositionStateBase`_ + * `FB_PositionStateInOut_WithPMPS`_ + * `FB_PositionStatePMPS`_ + * `FB_PositionStatePMPS1D`_ + + +FB_PositionStateBase_WithPMPS_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'No longer any reason to use this, all state classes can have unit tests.'} + FUNCTION_BLOCK FB_PositionStateBase_WithPMPS_Test EXTENDS FB_PositionStateBase + (* + Handles EPICS moves between multiple states for a single axis with fake PMPS. + Should be subclassed for a specific enumSet and enumGet. + See body comment or FB_PositionStateInOut_WithPMPS_Test for an implementation example. + *) + VAR_INPUT + stTransitionBeam: ST_BeamParams := PMPS_GVL.cst0RateBeam; + nTransitionAssertionID: UDINT; + END_VAR + VAR + fbStatePMPS: FB_PositionStatePMPS_Test; + END_VAR + (* + Subclass me, define enums to translate setState and getState, call Exec + + Example: + + + setState := enumSet; + Exec(); + enumGet := getState; + enumSet := setState; + *) + + END_FUNCTION_BLOCK + + ACTION Exec: + StateHandler(); + PMPSHandler(); + END_ACTION + + ACTION PMPSHandler: + fbStatePMPS( + stMotionStage:=stMotionStage, + arrStates:=arrStates, + bRequestTransition:=setState <> 0, + setState:=setState, + getState:=getState); + END_ACTION + + +Related: + * `FB_PositionStateBase`_ + * `FB_PositionStateInOut_WithPMPS_Test`_ + * `FB_PositionStatePMPS_Test`_ + + +FB_PositionStateInOut +^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use FB_PositionState1D_InOut instead'} + FUNCTION_BLOCK FB_PositionStateInOut EXTENDS FB_PositionStateBase + (* + Example usage of FB_PositionStateBase for a simple IN/OUT axis. See NOTE: comments. + Also usable as a drop-in for these cases (no need to roll your own in/out) + *) + VAR_INPUT + // The enum position to move to + {attribute 'pytmc' := ' + pv: SET + io: io + '} + enumSet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumSet + + // Information about the OUT position + stOut: ST_PositionState; // NOTE: Do not pragma these, let it happen in the manager. + // Information about the IN position + stIn: ST_PositionState; + END_VAR + VAR_OUTPUT + // The enum state readback + {attribute 'pytmc' := ' + pv: GET + io: i + '} + enumGet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumGet + END_VAR + VAR + bInOutInit: BOOL; + END_VAR + IF NOT bInOutInit THEN + bInOutInit := TRUE; + arrStates[1] := stOut; + arrStates[2] := stIn; + stOut.sName := 'OUT'; + stIn.sName := 'IN'; + END_IF + setState := enumSet; + Exec(); + enumGet := getState; + enumSet := setState; + + END_FUNCTION_BLOCK + + +Related: + * `ENUM_EpicsInOut_INT`_ + * `FB_PositionState1D_InOut`_ + * `FB_PositionStateBase`_ + * `ST_PositionState`_ + + +FB_PositionStateInOut_WithPMPS +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use FB_PositionStatePMPS1D_InOut instead'} + FUNCTION_BLOCK FB_PositionStateInOut_WithPMPS EXTENDS FB_PositionStateBase_WithPMPS + (* + Example usage of FB_PositionStateBase_WithPMPS for a simple IN/OUT axis. See NOTE: comments. + Also usable as a drop-in for these cases (no need to roll your own in/out) + + This is the PMPS version. Note that the only difference is that we extend the _WithPMPS FB. + *) + VAR_INPUT + // The enum position to move to + {attribute 'pytmc' := ' + pv: SET + io: io + '} + enumSet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumSet + + // Information about the OUT position + stOut: ST_PositionState; // NOTE: Do not pragma these, let it happen in the manager. + // Information about the IN position + stIn: ST_PositionState; + END_VAR + VAR_OUTPUT + // The enum state readback + {attribute 'pytmc' := ' + pv: GET + io: i + '} + enumGet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumGet + END_VAR + VAR + bInOutInit: BOOL; + END_VAR + IF NOT bInOutInit THEN + bInOutInit := TRUE; + arrStates[1] := stOut; + arrStates[2] := stIn; + stOut.sName := 'OUT'; + stIn.sName := 'IN'; + END_IF + setState := enumSet; + Exec(); + enumGet := getState; + enumSet := setState; + + END_FUNCTION_BLOCK + + +Related: + * `ENUM_EpicsInOut_INT`_ + * `FB_PositionStateBase_WithPMPS`_ + * `FB_PositionStatePMPS1D_InOut`_ + * `ST_PositionState`_ + + +FB_PositionStateInOut_WithPMPS_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'No longer any reason to use this, all state classes can have unit tests.'} + FUNCTION_BLOCK FB_PositionStateInOut_WithPMPS_Test EXTENDS FB_PositionStateBase_WithPMPS_Test + (* + Example usage of FB_PositionStateBase_WithPMPS_Test for a simple IN/OUT axis. See NOTE: comments. + Also usable as a drop-in for these cases (no need to roll your own in/out) + + This is the PMPS version. Note that the only difference is that we extend the _WithPMPS_Test FB. + *) + VAR_INPUT + // The enum position to move to + {attribute 'pytmc' := ' + pv: SET + io: io + '} + enumSet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumSet + + // Information about the OUT position + stOut: ST_PositionState; // NOTE: Do not pragma these, let it happen in the manager. + // Information about the IN position + stIn: ST_PositionState; + END_VAR + VAR_OUTPUT + // The enum state readback + {attribute 'pytmc' := ' + pv: GET + io: i + '} + enumGet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumGet + END_VAR + VAR + bInOutInit: BOOL; + END_VAR + IF NOT bInOutInit THEN + bInOutInit := TRUE; + arrStates[1] := stOut; + arrStates[2] := stIn; + stOut.sName := 'OUT'; + stIn.sName := 'IN'; + END_IF + setState := enumSet; + Exec(); + enumGet := getState; + enumSet := setState; + + END_FUNCTION_BLOCK + + +Related: + * `ENUM_EpicsInOut_INT`_ + * `FB_PositionStateBase_WithPMPS_Test`_ + * `ST_PositionState`_ + + +FB_PositionStateInternal +^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateInternal + (* + Routines that must be called on all ST_PositionState + + Currently, this FB: + - ensures that a position state has both a proper encoder count + and a proper position in engineering units with both of these quantities matching + - handles the parameter locking feature, which nominally prevents the user from changing + details about a locked state via EPICS + *) + VAR_IN_OUT + stMotionStage: ST_MotionStage; + stPositionState: ST_PositionState; + END_VAR + VAR_OUTPUT + END_VAR + VAR + fbEncConverter: FB_RawCountConverter; + fbLock: FB_PositionStateLock; + END_VAR + // Mark that we've been here + stPositionState.bUpdated := TRUE; + + // Update pos state's count or egu position as appropriate + IF stMotionStage.bAxisParamsInit THEN + fbEncConverter( + stParameters:=stMotionStage.stAxisParameters, + nCountCheck:=stPositionState.nEncoderCount, + fPosCheck:=stPositionState.fPosition); + IF stPositionState.bUseRawCounts THEN + stPositionState.fPosition := fbEncConverter.fPosGet; + ELSE + stPositionState.nEncoderCount := fbEncConverter.nCountGet; + END_IF + END_IF + + // Handle state parameter locking + fbLock( + stPositionState:=stPositionState, + bEnable:=stMotionStage.bAxisParamsInit); + + END_FUNCTION_BLOCK + + +Related: + * `FB_PositionStateLock`_ + * `FB_RawCountConverter`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateInternalND +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateInternalND + (* + Given a standard ND state setup, call all the required state management FBs. + *) + VAR_IN_OUT + // All the motors to apply the standard routines to + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + // Each motor's respective position states along its direction + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + VAR + // The individual instantiated internal FBs. Must have the same bounds as astPositionState. + afbStateInternal: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF FB_PositionStateInternal; + nIterMotors: DINT; + nIterStates: DINT; + END_VAR + FOR nIterMotors := 1 TO MotionConstants.MAX_STATE_MOTORS DO + FOR nIterStates := 1 TO GeneralConstants.MAX_STATES DO + afbStateInternal[nIterMotors][nIterStates]( + stMotionStage:=astMotionStage[nIterMotors], + stPositionState:=astPositionState[nIterMotors][nIterStates], + ); + END_FOR + END_FOR + + END_FUNCTION_BLOCK + + +Related: + * `FB_PositionStateInternal`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateLock +^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateLock + (* + Implements immutability for a locked ST_PositionState + Once this is called the first time, the parameters at the time of the call will be restored on all subsequent calls. + *) + VAR_IN_OUT + stPositionState: ST_PositionState; + END_VAR + VAR_INPUT + bEnable: BOOL; + END_VAR + VAR + stCachedPositionState: ST_PositionState; + bInit: BOOL := FALSE; + END_VAR + IF bEnable THEN + // Force values to be cached if we've cached something + IF bInit AND stPositionState.bLocked THEN + stPositionState.sName := stCachedPositionState.sName; + stPositionState.fPosition := stCachedPositionState.fPosition; + stPositionState.fDelta := stCachedPositionState.fDelta; + stPositionState.fVelocity := stCachedPositionState.fVelocity; + stPositionState.fAccel := stCachedPositionState.fAccel; + stPositionState.fDecel := stCachedPositionState.fDecel; + // If we haven't cached and we should, make the cache. Note that we skip bLocked, bValid, and bMoveOk + ELSIF NOT bInit AND stPositionState.bLocked THEN + stCachedPositionState.sName := stPositionState.sName; + stCachedPositionState.fPosition := stPositionState.fPosition; + stCachedPositionState.fDelta := stPositionState.fDelta; + stCachedPositionState.fVelocity := stPositionState.fVelocity; + stCachedPositionState.fAccel := stPositionState.fAccel; + stCachedPositionState.fDecel := stPositionState.fDecel; + bInit := TRUE; + // Do nothing, or unlock the state if bLocked goes FALSE + ELSIF NOT stPositionState.bLocked THEN + bInit := FALSE; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `ST_PositionState`_ + + +FB_PositionStateManager +^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use FB_PositionState1D instead'} + FUNCTION_BLOCK FB_PositionStateManager + (* + Handles EPICS moves between multiple states for a single axis + Should be wrapped inside a block with enums for states, + see FB_EpicsInOut for an example. + *) + VAR_IN_OUT + // Motor to move + stMotionStage: ST_MotionStage; + + // Allocated space for 15 states besides Unknown (16 is the max for an EPICS MBBI) + {attribute 'pytmc' := ' + pv: + io: io + expand: %.2d + '} + arrStates: ARRAY[1..15] OF ST_PositionState; + + // Corresponding arrStates index to move to, or 0 if no move selected + setState: INT; + END_VAR + VAR_INPUT + // If TRUE, start a move when setState transitions to a nonzero number + bEnable: BOOL; + // On rising edge, reset this FB + {attribute 'pytmc' := ' + pv: RESET + io: io + field: ZNAM False + field: ONAM True + '} + bReset: BOOL; + END_VAR + VAR_OUTPUT + // If TRUE, there is an error + {attribute 'pytmc' := ' + pv: ERR + io: i + field: ZNAM False + field: ONAM True + '} + bError: BOOL; + // Error ID + {attribute 'pytmc' := ' + pv: ERRID + io: i + '} + nErrorId: UDINT; + // The error that caused bError to flip TRUE + {attribute 'pytmc' := ' + pv: ERRMSG + io: i + '} + sErrorMessage: STRING; + // If TRUE, we are moving the motor + {attribute 'pytmc' := ' + pv: BUSY + io: i + field: ZNAM False + field: ONAM True + '} + bBusy: BOOL; + // If TRUE, we are not moving the motor and the last move completed successfully + {attribute 'pytmc' := ' + pv: DONE + io: i + field: ZNAM False + field: ONAM True + '} + bDone: BOOL; + + // The current position we are trying to reach, or 0 + goalState: INT; + // The readback position + getState: INT; + END_VAR + VAR + bInit: BOOL; + stUnknown: ST_PositionState; + stGoal: ST_PositionState; + fbStateMove: FB_PositionStateMove; + fbStateInternal: ARRAY[1..15] OF FB_PositionStateInternal; + nIndex: INT; + bNewGoal: BOOL; + bInnerExec: BOOL; + bInnerReset: BOOL; + rtReset: R_TRIG; + bMoveRequested: BOOL; + END_VAR + // Reset just goes through the first-cycle init again + rtReset(CLK:=bReset); + IF rtReset.Q THEN + bInit := FALSE; + END_IF + + // First-cycle init + IF NOT bInit THEN + bError := FALSE; + sErrorMessage := ''; + bBusy := FALSE; + bDone := FALSE; + bNewGoal := FALSE; + bInnerExec := FALSE; + bInnerReset := TRUE; + setState := 0; + goalState := 0; + END_IF + + // All state internal handlers + FOR nIndex := 1 TO 15 DO + IF arrStates[nIndex].bValid THEN + fbStateInternal[nIndex]( + stMotionStage:=stMotionStage, + stPositionState:=arrStates[nIndex]); + END_IF + END_FOR + + // Check where we are by going through all possible states. + // Note this favors the highest-number state that we're at, it's up to you to make your states mutually exclusive. + getState := 0; + FOR nIndex := 1 TO 15 DO + IF F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=arrStates[nIndex]) THEN + getState := nIndex; + END_IF + END_FOR + + // Use the changing set pv as a rising-edge trigger + IF setState <> goalState THEN + goalState := setState; + bNewGoal := TRUE; + END_IF + + // Special move handling for error/enable state + IF bError OR NOT bEnable THEN + bInnerExec := FALSE; + // Reset inner block this cycle if we were already moving but want a new move + ELSIF bInnerExec AND bNewGoal THEN + bInnerExec := FALSE; + bInnerReset := TRUE; + // If we hit this branch, we're starting a new move + ELSIF bNewGoal THEN + bInnerExec := TRUE; + bInnerReset := FALSE; + bNewGoal := FALSE; + END_IF + + // Pick the correct goal structure or Unknown + IF goalState = 0 THEN + stGoal := stUnknown; + ELSE + stGoal := arrStates[goalState]; + END_IF + + // Do the move + fbStateMove( + stMotionStage := stMotionStage, + stPositionState := stGoal, + bExecute := bInnerExec, + bReset := bInnerReset, + enumMotionRequest := E_MotionRequest.INTERRUPT, + bBusy => bBusy); + + // Only pass up bDone information if this FB is active + IF bInnerExec THEN + bDone := fbStateMove.bDone; + END_IF + + // Pick up any new errors, but don't override uncleared existing errors + IF NOT bError THEN + bError := fbStateMove.bError; + nErrorId := fbStateMove.nErrorId; + sErrorMessage := fbStateMove.sErrorMessage; + END_IF + + // Reset the setpoint and goal to 0 if we're not doing anything + // because FB is waiting for a change from 0 to "something" + bMoveRequested := bInnerExec AND NOT bDone; + IF NOT bError AND NOT bNewGoal AND NOT bMoveRequested THEN + setState := 0; + goalState := 0; + bInnerExec := FALSE; + END_IF + + // Bring inner reset back low at the end of the init cycle so that it can be triggered again later + IF NOT bInit THEN + bInit := TRUE; + bInnerReset := FALSE; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `E_MotionRequest`_ + * `FB_EpicsInOut`_ + * `FB_PositionState1D`_ + * `FB_PositionStateInternal`_ + * `FB_PositionStateMove`_ + * `F_AtPositionState`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateMove +^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateMove + (* + Request a move to a particular state from an axis controlled via EPICS + pytmc PVs here only exposed if using directly and not through another states function block. + *) + VAR_IN_OUT + // Motor to move + stMotionStage: ST_MotionStage; + + // State to move to + {attribute 'pytmc' := ' + pv: + '} + stPositionState: ST_PositionState; + END_VAR + VAR_INPUT + // Start move on rising edge, stop move on falling edge + {attribute 'pytmc' := ' + pv: GO + io: io + field: ZNAM False + field: ONAM True + '} + bExecute: BOOL; + + // Rising edge error reset + {attribute 'pytmc' := ' + pv: RESET + io: io + field: ZNAM False + field: ONAM True + '} + bReset: BOOL; + + // Define behavior for when a move is already active + enumMotionRequest: E_MotionRequest := E_MotionRequest.WAIT; + END_VAR + VAR_OUTPUT + // TRUE if the motor is at this state + {attribute 'pytmc' := ' + pv: AT_STATE + io: input + field: ZNAM False + field: ONAM True + '} + bAtState: BOOL; + + // TRUE if we have an error + {attribute 'pytmc' := ' + pv: ERR + io: input + field: ZNAM False + field: ONAM True + '} + bError: BOOL; + + // Error code + {attribute 'pytmc' := ' + pv: ERRID + io: input + '} + nErrorID: UDINT; + + // Error description + {attribute 'pytmc' := ' + pv: ERRMSG + io: input + '} + sErrorMessage: STRING; + + // TRUE if we are moving to a state + {attribute 'pytmc' := ' + pv: BUSY + io: input + field: ZNAM False + field: ONAM True + '} + bBusy: BOOL; + + // TRUE if we are not moving and we reached a state successfully on our last move + {attribute 'pytmc' := ' + pv: DONE + io: input + field: ZNAM False + field: ONAM True + '} + bDone: BOOL; + END_VAR + VAR + fbMotionRequest: FB_MotionRequest; + bAllowMove: BOOL; + END_VAR + // Veto the move for uninitialized and unsafe states + bAllowMove := stPositionState.bMoveOk AND stPositionState.bValid AND stPositionState.bUpdated; + + // Do the move + fbMotionRequest( + stMotionStage := stMotionStage, + bExecute := bExecute AND bAllowMove, + bReset := bReset, + enumMotionRequest := enumMotionRequest, + fPos := stPositionState.fPosition, + fVel := stPositionState.fVelocity, + fAcc := stPositionState.fAccel, + fDec := stPositionState.fDecel, + bError => bError, + nErrorId => nErrorId, + sErrorMessage => sErrorMessage, + bBusy => bBusy, + bDone => bDone); + + // Inject custom error if we can't move because of bMoveOk or bValid + IF bExecute AND NOT bAllowMove THEN + bError := TRUE; + IF stPositionState.bValid THEN + nErrorId := 16#7901; + ELSE + nErrorId := 16#7902; + END_IF + sErrorMessage := F_MotionErrorCodeLookup(nErrorId := nErrorID); + END_IF + + // This can be useful if we're running this FB standalone for some reason + bAtState := F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=stPositionState); + + END_FUNCTION_BLOCK + + +Related: + * `E_MotionRequest`_ + * `FB_MotionRequest`_ + * `F_AtPositionState`_ + * `F_MotionErrorCodeLookup`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateMove_Test +^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateMove_Test EXTENDS FB_MotorTestSuite + (* + Test that FB_PositionStateMove can be used to move motors to named state positions + And that the API behaves exactly as described. + *) + VAR + stMotionStage: ST_MotionStage; + fbMotionStage: FB_MotionStage; + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + afbInternal: ARRAY[1..3] OF FB_PositionStateInternal; + stDummyPos: ST_PositionState; + stInvalid: ST_PositionState; + stNotUpdated: ST_PositionState; + stUnsafe: ST_PositionState; + fbMove: FB_PositionStateMove; + + nTestCounter: UINT; + bOneTestDone: BOOL; + fTestStartPos: LREAL; + tonTimer: TON; + nIter: DINT; + bStatesReady: BOOL; + END_VAR + astPositionState[1].sName := 'UNO'; + astPositionState[1].fPosition := 10; + astPositionState[1].fDelta := 1; + astPositionState[1].fVelocity := 10; + SetGoodState(astPositionState[1]); + + astPositionState[2].sName := 'DOS'; + astPositionState[2].fPosition := 20; + astPositionState[2].fDelta := 1; + astPositionState[2].fVelocity := 10; + SetGoodState(astPositionState[2]); + + astPositionState[3].sName := 'TRES'; + astPositionState[3].fPosition := 30; + astPositionState[3].fDelta := 1; + astPositionState[3].fVelocity := 10; + SetGoodState(astPositionState[3]); + + bStatesReady := TRUE; + FOR nIter := 1 TO 3 DO + afbInternal[nIter]( + stMotionStage:=stMotionStage, + stPositionState:=astPositionState[nIter], + ); + bStatesReady := bStatesReady AND astPositionState[nIter].bUpdated; + END_FOR + stInvalid.bValid := FALSE; + stInvalid.bUpdated := TRUE; + stInvalid.bMoveOk := TRUE; + stNotUpdated.bValid := TRUE; + stNotUpdated.bUpdated := FALSE; + stNotUpdated.bMoveOk := TRUE; + stUnsafe.bValid := TRUE; + stUnsafe.bUpdated := TRUE; + stUnsafe.bMoveOk := FALSE; + + SetEnables(stMotionStage); + fbMotionStage(stMotionStage:=stMotionStage); + + IF bStatesReady AND nTestCounter = 0 THEN + // Don't run any tests until the states are ready + nTestCounter := 1; + // Warm up the motion FB with a exec false runthrough + fbMove( + stMotionStage:=stMotionStage, + stPositionState:=stDummyPos, + bExecute:=FALSE, + ); + END_IF + + // Test that we can move to state 1 and the outputs are correct as we go + TestMove(1, 1, FALSE); + // Test that we can move to state 2 and the outputs are correct as we go + TestMove(2, 2, FALSE); + // Test that we can interrupt a move to state 3 by dropping bExecute + TestMove(3, 3, TRUE); + // Test that we cannot move to an invalid state + TestBadStates(4); + + IF bOneTestDone THEN + bOneTestDone := FALSE; + nTestCounter := nTestCounter + 1; + fbMove( + stMotionStage:=stMotionStage, + stPositionState:=stDummyPos, + bExecute:=FALSE, + bReset:=TRUE, + ); + fbMove( + stMotionStage:=stMotionStage, + stPositionState:=stDummyPos, + bExecute:=FALSE, + bReset:=FALSE, + ); + tonTimer(IN:=FALSE); + END_IF + // Use this timer to time out any tests that stall + tonTimer( + IN:=bStatesReady, + PT:=T#5s, + ); + + END_FUNCTION_BLOCK + + METHOD TestBadStates + VAR_INPUT + nTestIndex: UINT; + END_VAR + TEST(CONCAT('TestInvalid', UINT_TO_STRING(nTestIndex))); + IF nTestCounter <> nTestIndex THEN + RETURN; + END_IF + + AssertFalse( + fbMove.bError, + 'Started with an error', + ); + + fbMove( + stMotionStage:=stMotionstage, + stPositionState:=stInvalid, + bExecute:=TRUE, + ); + + AssertTrue( + fbMove.bError, + 'Invalid should have given an error', + ); + + fbMove( + stMotionStage:=stMotionstage, + stPositionState:=stInvalid, + bExecute:=FALSE, + bReset:=TRUE, + ); + + AssertFalse( + fbMove.bError, + 'Started with an error', + ); + + fbMove( + stMotionStage:=stMotionstage, + stPositionState:=stNotUpdated, + bExecute:=TRUE, + bReset:=FALSE, + ); + + AssertTrue( + fbMove.bError, + 'Not updated should have given an error', + ); + + fbMove( + stMotionStage:=stMotionstage, + stPositionState:=stNotUpdated, + bExecute:=FALSE, + bReset:=TRUE, + ); + + AssertFalse( + fbMove.bError, + 'Started with an error', + ); + + fbMove( + stMotionStage:=stMotionstage, + stPositionState:=stUnsafe, + bExecute:=TRUE, + bReset:=FALSE, + ); + + AssertTrue( + fbMove.bError, + 'Unsafe should have given an error', + ); + + bOneTestDone := TRUE; + TEST_FINISHED(); + END_METHOD + + METHOD TestMove + VAR_INPUT + nTestIndex: UINT; + nStateIndex: UINT; + bInterrupt: BOOL; + END_VAR + VAR_INST + bLocalInit: BOOL; + bInterruptStarted: BOOL; + END_VAR + TEST(CONCAT('TestMove', UINT_TO_STRING(nTestIndex))); + IF nTestCounter <> nTestIndex THEN + RETURN; + END_IF + + IF NOT bLocalInit THEN + // Starting output checks + AssertFalse( + Condition:=fbMove.bBusy, + Message:='Tried to start test with busy motor', + ); + AssertFalse( + Condition:=fbMove.bError, + Message:='Tried to start test with errored motor', + ); + bLocalInit := TRUE; + END_IF + + bInterruptStarted S= bInterrupt AND stMotionStage.bBusy; + fbMove( + stMotionStage:=stMotionstage, + stPositionState:=astPositionState[nStateIndex], + bExecute:=NOT bInterruptStarted, + ); + + IF fbMove.bDone OR tonTimer.Q OR (bInterruptStarted AND NOT fbMove.bBusy) THEN + AssertFalse( + tonTimer.Q, + 'Test timed out', + ); + IF bInterrupt THEN + AssertFalse( + fbMove.bAtState, + Message:='Should have been interrupted, but made it to the goal', + ); + ELSE + AssertTrue( + fbMove.bAtState, + Message:='Did not end at the state', + ); + AssertEquals_LREAL( + Expected:=astPositionState[nStateIndex].fPosition, + Actual:=stMotionStage.stAxisStatus.fActPosition, + Delta:=0.01, + Message:='Did not reach the goal state', + ); + END_IF + AssertFalse( + fbMove.bBusy, + Message:='Was busy while done', + ); + AssertFalse( + fbMove.bError, + Message:=CONCAT('Should not end in error: ', stMotionStage.sErrorMessage), + ); + + bOneTestDone := TRUE; + bLocalInit := FALSE; + bInterruptStarted := FALSE; + TEST_FINISHED(); + END_IF + END_METHOD + + +Related: + * `FB_MotionStage`_ + * `FB_MotorTestSuite`_ + * `FB_PositionStateInternal`_ + * `FB_PositionStateMove`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateMoveND +^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateMoveND + (* + This function block coordinates multidimensional state moves for groups of motors. + It is a building block not meant for use outside of lcls-twintcat-motion. + + Use FB_PositionState1D, FB_PositionState2D, ... etc. instead + *) + VAR_IN_OUT + // Array of motors to move together + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + // 1D Position states: the current position to send each axis to + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_PositionState; + END_VAR + VAR_INPUT + // The number of motors we're actually using + nActiveMotorCount: UINT; + // Start all moves on rising edge, stop all moves on falling edge + bExecute: BOOL; + // Reset any errors + bReset: BOOL; + // Define behavior for when a move request is interrupted with a new request + enumMotionRequest: E_MotionRequest := E_MotionRequest.WAIT; + END_VAR + VAR_OUTPUT + // TRUE if ALL of the motors are at their goal states + bAtState: BOOL; + // TRUE if ANY of this FB's moves are in progress + bBusy: BOOL; + // TRUE if ALL motors have completed the last move request from this FB + bDone: BOOL; + // TRUE if ANY of this FB's moves had an error + bError: BOOL; + // How many FBs are erroring + nErrorCount: UINT; + // Which component is the source of the example/summarized error + nShownError: DINT; + // One of the error ids + nErrorID: UDINT; + // The error error message matching the ID + sErrorMessage: STRING; + END_VAR + VAR + // 1D State movers: FBs to move the motors + afbPositionStateMove: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF FB_PositionStateMove; + nIndex: DINT; + bMotorCountError: BOOL; + nLowerBound: DINT; + nUpperBound: DINT; + END_VAR + CheckCount(); + IF NOT bMotorCountError THEN + DoStateMoves(); + CombineOutputs(); + END_IF + + END_FUNCTION_BLOCK + + ACTION CheckCount: + // Make sure the motor count is valid (positive, nonzero, less or equal to the max) + bMotorCountError S= nActiveMotorCount <= 0; + bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS; + + IF bMotorCountError THEN + bError := TRUE; + sErrorMessage := 'Internal Error: invalid motor count'; + END_IF + END_ACTION + + ACTION CombineOutputs: + // bAtState is TRUE if ALL entries are TRUE + bAtState := TRUE; + FOR nIndex := 1 TO nActiveMotorCount DO + bAtState := bAtState AND afbPositionStateMove[nIndex].bAtState; + END_FOR + + // bBusy is TRUE if ANY entry is TRUE + bBusy := FALSE; + FOR nIndex := 1 TO nActiveMotorCount DO + bBusy := bBusy OR afbPositionStateMove[nIndex].bBusy; + END_FOR + + // bDone is TRUE if ALL entries are TRUE + bDone := TRUE; + FOR nIndex := 1 TO nActiveMotorCount DO + bDone := bDone AND afbPositionStateMove[nIndex].bDone; + END_FOR + + // bError is TRUE if ANY entry is TRUE + // also set nShownError and increment nErrorCount + bError := FALSE; + nErrorCount := 0; + FOR nIndex := 1 TO nActiveMotorCount DO + bError := bError OR afbPositionStateMove[nIndex].bError; + IF afbPositionStateMove[nIndex].bError THEN + nShownError := nIndex; + nErrorCount := nErrorCount + 1; + END_IF + END_FOR + + // Pick error id and message using nShownError + IF bError THEN + nErrorID := afbPositionStateMove[nShownError].nErrorID; + sErrorMessage := afbPositionStateMove[nShownError].sErrorMessage; + ELSE + nErrorID := 0; + sErrorMessage := ''; + END_IF + END_ACTION + + ACTION DoStateMoves: + // Do the individual moves + FOR nIndex := 1 TO nActiveMotorCount DO + afbPositionStateMove[nIndex]( + stMotionStage:=astMotionStage[nIndex], + stPositionState:=astPositionState[nIndex], + bExecute:=bExecute, + bReset:=bReset, + enumMotionRequest:=enumMotionRequest, + ); + END_FOR + END_ACTION + + +Related: + * `E_MotionRequest`_ + * `FB_PositionState1D`_ + * `FB_PositionState2D`_ + * `FB_PositionStateMove`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateMoveND_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateMoveND_Test EXTENDS FB_MotorTestSuite + (* + Test that FB_PositionStateMoveND can be used to move motors to named state positions + And that the API behaves exactly as described. + *) + VAR + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + afbMotionStage: ARRAY[1..3] OF FB_MotionStage; + astGoalPositions: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_PositionState; + afbInternal: ARRAY[1..3] OF FB_PositionStateInternal; + stDummyPos: ST_PositionState; + fbMove: FB_PositionStateMoveND; + + bInit: BOOL; + nTestCounter: UINT; + bOneTestDone: BOOL; + fTestStartPos: LREAL; + tonTimer: TON; + nIter: DINT; + bStatesReady: BOOL; + END_VAR + IF NOT bInit THEN + ResetGoals(); + bInit := TRUE; + END_IF + + bStatesReady := TRUE; + FOR nIter := 1 TO 3 DO + afbInternal[nIter]( + stMotionStage:=astMotionStage[nIter], + stPositionState:=astGoalPositions[nIter], + ); + bStatesReady := bStatesReady AND astGoalPositions[nIter].bUpdated; + SetEnables(astMotionStage[nIter]); + afbMotionStage[nIter](stMotionStage:=astMotionStage[nIter]); + END_FOR + + IF bStatesReady AND nTestCounter = 0 THEN + // Don't run any tests until the states are ready + nTestCounter := 1; + // Warm up the motion FB with a exec false runthrough + fbMove( + astMotionStage := astMotionStage, + astPositionState := astGoalPositions, + nActiveMotorCount := 3, + bExecute := FALSE, + ); + END_IF + + // Move to somewhere + TestMove(1, 1, 5, 10, FALSE); + // Somewhere else + TestMove(2, -10, 0, 5, FALSE); + // Interrupt on the way to the last place + TestMove(3, 0, 0, 0, TRUE); + + IF bOneTestDone THEN + bOneTestDone := FALSE; + nTestCounter := nTestCounter + 1; + ResetGoals(); + fbMove( + astMotionStage := astMotionStage, + astPositionState := astGoalPositions, + nActiveMotorCount := 3, + bExecute := FALSE, + bReset := TRUE, + ); + tonTimer(IN:=FALSE); + END_IF + // Use this timer to time out any tests that stall + tonTimer( + IN:=bStatesReady, + PT:=T#5s, + ); + + END_FUNCTION_BLOCK + + METHOD ResetGoals + VAR_INPUT + END_VAR + astGoalPositions[1].sName := 'Goal1'; + astGoalPositions[1].fPosition := 0; + astGoalPositions[1].fDelta := 1; + astGoalPositions[1].fVelocity := 10; + astGoalPositions[1].bUseRawCounts := FALSE; + SetGoodState(astGoalPositions[1]); + + astGoalPositions[2].sName := 'Goal2'; + astGoalPositions[2].fPosition := 0; + astGoalPositions[2].fDelta := 1; + astGoalPositions[2].fVelocity := 10; + astGoalPositions[2].bUseRawCounts := FALSE; + SetGoodState(astGoalPositions[2]); + + astGoalPositions[3].sName := 'Goal3'; + astGoalPositions[3].fPosition := 0; + astGoalPositions[3].fDelta := 1; + astGoalPositions[3].fVelocity := 10; + astGoalPositions[3].bUseRawCounts := FALSE; + SetGoodState(astGoalPositions[3]); + END_METHOD + + METHOD TestMove + VAR_INPUT + nTestIndex: UINT; + fMotor1Pos: LREAL; + fMotor2Pos: LREAL; + fMotor3Pos: LREAL; + bInterrupt: BOOL; + END_VAR + VAR_INST + bLocalInit: BOOL; + bInterruptStarted: BOOL; + END_VAR + TEST(CONCAT('TestMove', UINT_TO_STRING(nTestIndex))); + IF nTestCounter <> nTestIndex THEN + RETURN; + END_IF + + IF NOT bLocalInit THEN + // Starting output checks + AssertFalse( + Condition:=fbMove.bBusy, + Message:='Tried to start test with busy motor', + ); + AssertFalse( + Condition:=fbMove.bError, + Message:='Tried to start test with errored motor', + ); + bLocalInit := TRUE; + END_IF + + astGoalPositions[1].fPosition := fMotor1Pos; + astGoalPositions[2].fPosition := fMotor2Pos; + astGoalPositions[3].fPosition := fMotor3Pos; + + bInterruptStarted S= bInterrupt AND astMotionStage[1].bBusy AND astMotionStage[2].bBusy AND astMotionStage[3].bBusy; + fbMove( + astMotionStage:=astMotionStage, + astPositionState:=astGoalPositions, + nActiveMotorCount:=3, + bExecute:=NOT bInterruptStarted, + ); + IF fbMove.bDone OR tonTimer.Q OR (bInterruptStarted AND NOT fbMove.bBusy) THEN + IF bInterrupt THEN + AssertFalse( + fbMove.bAtState, + Message:='Should have been interrupted, but made it to the goal', + ); + ELSE + AssertTrue( + fbMove.bAtState, + Message:='Did not end at the state', + ); + FOR nIter := 1 TO 3 DO + AssertEquals_LREAL( + Expected:=astGoalPositions[nIter].fPosition, + Actual:=astMotionStage[nIter].stAxisStatus.fActPosition, + Delta:=0.01, + Message:='Did not reach the goal state', + ); + END_FOR + + END_IF + AssertFalse( + fbMove.bBusy, + Message:='Was busy while done', + ); + AssertFalse( + fbMove.bError, + Message:='Should not end in error', + ); + + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + +Related: + * `FB_MotionStage`_ + * `FB_MotorTestSuite`_ + * `FB_PositionStateInternal`_ + * `FB_PositionStateMoveND`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateND_Core +^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateND_Core + (* + Collection of all the actions shared between all states FBs + This is used in e.g. + - FB_PositionState1D + - FB_PositionState2D + - ... etc. + - FB_PositionStatePMPS1D + - FB_PositionStatePMPS2D + - ... etc. + + This is essentially input handling, position state reading, standard management blocks, and the motion state machine. + *) + VAR_IN_OUT + // All motors to be used in the states move, including blank/uninitialized structs. + astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + // All position states for all motors, including unused/invalid states. + astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Normal EPICS inputs, gathered into a single struct + stEpicsToPlc: ST_StateEpicsToPlc; + // Normal EPICS outputs, gathered into a single struct + stPlcToEpics: ST_StatePlcToEpics; + // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input. + eEnumSet: UINT; + // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output. + eEnumGet: UINT; + END_VAR + VAR_INPUT + // Set this to TRUE to enable input state moves, or FALSE to disable them. + bEnable: BOOL; + // Set this to the number of motors to be included in astMotionStageMax + nActiveMotorCount: UINT; + END_VAR + VAR_OUTPUT + // The current position index goal, where the motors are supposed to be moving towards. + nCurrGoal: UINT; + END_VAR + VAR + fbInput: FB_StatesInputHandler; + fbInternal: FB_PositionStateInternalND; + fbMove: FB_PositionStateMoveND; + fbRead: FB_PositionStateReadND; + astMoveGoals: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_PositionState; + stInvalidPos: ST_PositionState; + nIterMotor: DINT; + END_VAR + stEpicsToPlc.nSetValue := eEnumSet; + + fbInternal( + astMotionStage:=astMotionStageMax, + astPositionState:=astPositionStateMax, + ); + + fbRead( + astMotionStage:=astMotionStageMax, + astPositionState:=astPositionStateMax, + nActiveMotorCount:=nActiveMotorCount, + bKnownState=>, + bMovingState=>, + nPositionIndex=>stPlcToEpics.nGetValue, + ); + + fbInput( + stUserInput:=stEpicsToPlc, + bMoveBusy:=fbMove.bBusy, + nStartingState:=fbRead.nPositionIndex, + nCurrGoal=>nCurrGoal, + bExecMove=>, + bResetMove=>, + ); + + FOR nIterMotor := 1 TO MotionConstants.MAX_STATE_MOTORS DO + IF nCurrGoal > 0 THEN + astMoveGoals[nIterMotor] := astPositionStateMax[nIterMotor][nCurrGoal]; + ELSE + astMoveGoals[nIterMotor] := stInvalidPos; + END_IF + END_FOR + + fbMove( + astMotionStage:=astMotionStageMax, + astPositionState:=astMoveGoals, + nActiveMotorCount:=nActiveMotorCount, + bExecute:=fbInput.bExecMove AND bEnable, + bReset:=fbInput.bResetMove, + enumMotionRequest:=E_MotionRequest.INTERRUPT, + bAtState=>, + bError=>stPlcToEpics.bError, + nErrorID=>stPlcToEpics.nErrorID, + sErrorMessage=>stPlcToEpics.sErrorMsg, + bBusy=>stPlcToEpics.bBusy, + bDone=>stPlcToEpics.bDone, + ); + + eEnumSet := stEpicsToPlc.nSetValue; + eEnumGet := stPlcToEpics.nGetValue; + + END_FUNCTION_BLOCK + + +Related: + * `E_MotionRequest`_ + * `FB_PositionState1D`_ + * `FB_PositionState2D`_ + * `FB_PositionStateInternalND`_ + * `FB_PositionStateMoveND`_ + * `FB_PositionStatePMPS1D`_ + * `FB_PositionStatePMPS2D`_ + * `FB_PositionStateReadND`_ + * `FB_StatesInputHandler`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + * `ST_StateEpicsToPlc`_ + * `ST_StatePlcToEpics`_ + + +FB_PositionStateND_Test +^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateND_Test EXTENDS FB_MotorTestSuite + (* + Sanity checks for the following: + - FB_PositionState1D + - FB_PositionState2D + - FB_PositionState3D + The internals have already been tested, but we need to make sure that + they've been put together at least somewhat sensibly. + This FB will simply use each FB to move and check the results. + + Additional tests: + - Regression test for issue #197 (input deadlock) + *) + VAR + stMotionStage1: ST_MotionStage; + stMotionStage2: ST_MotionStage; + stMotionStage3: ST_MotionStage; + astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astPositionState3: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + afbInternal: ARRAY[1..3] OF ARRAY[1..3] OF FB_PositionStateInternal; + afbMotionStage: ARRAY[1..3] OF FB_MotionStage; + + fb_Move1D: FB_PositionState1D; + fb_Move2D: FB_PositionState2D; + fb_Move3D: FB_PositionState3D; + + nTestCounter: UINT; + bOneTestDone: BOOL; + fTestStartPos: LREAL; + tonTimer: TON; + nIter: DINT; + bStatesReady: BOOL; + + eSetPos: E_TestStates; + eGetPos: E_TestStates; + END_VAR + bStatesReady := TRUE; + FOR nIter := 1 TO 3 DO; + astPositionState1[nIter].fPosition := nIter; + astPositionState1[nIter].fDelta := 1; + astPositionState1[nIter].fVelocity := 100; + astPositionState2[nIter].fPosition := 10 + nIter; + astPositionState2[nIter].fDelta := 1; + astPositionState2[nIter].fVelocity := 100; + astPositionState3[nIter].fPosition := 20 + nIter; + astPositionState3[nIter].fDelta := 1; + astPositionState3[nIter].fVelocity := 100; + afbInternal[nIter][1]( + stMotionStage:=stMotionStage1, + stPositionState:=astPositionState1[nIter], + ); + afbInternal[nIter][2]( + stMotionStage:=stMotionStage2, + stPositionState:=astPositionState2[nIter], + ); + afbInternal[nIter][3]( + stMotionStage:=stMotionStage3, + stPositionState:=astPositionState3[nIter], + ); + SetGoodState(astPositionState1[nIter]); + SetGoodState(astPositionState2[nIter]); + SetGoodState(astPositionState3[nIter]); + bStatesReady := bStatesReady AND astPositionState1[nIter].bUpdated; + bStatesReady := bStatesReady AND astPositionState2[nIter].bUpdated; + bStatesReady := bStatesReady AND astPositionState3[nIter].bUpdated; + END_FOR + SetEnables(stMotionStage1); + SetEnables(stMotionStage2); + SetEnables(stMotionStage3); + afbMotionStage[1](stMotionStage:=stMotionStage1); + afbMotionStage[2](stMotionStage:=stMotionStage2); + afbMotionStage[3](stMotionStage:=stMotionStage3); + + IF bStatesReady AND nTestCounter = 0 THEN + // Don't run any tests until the states are ready + nTestCounter := 1; + // Run all the motion FBs for one cycle to warm them up + fb_Move1D( + stMotionStage:=stMotionStage1, + astPositionState:=astPositionState1, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + fb_Move2D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + fb_Move3D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + stMotionStage3:=stMotionStage3, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + astPositionState3:=astPositionState3, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + END_IF + + Test1D(1, E_TestStates.OUT); + Test1D(2, E_TestStates.TARGET1); + Test1D(3, E_TestStates.TARGET2); + Test2D(4, E_TestStates.OUT); + Test2D(5, E_TestStates.TARGET1); + Test2D(6, E_TestStates.TARGET2); + Test3D(7, E_TestStates.OUT); + Test3D(8, E_TestStates.TARGET1); + Test3D(9, E_TestStates.TARGET2); + TestInputDeadlock(10); + + IF bOneTestDone THEN + bOneTestDone := FALSE; + nTestCounter := nTestCounter + 1; + tonTimer(IN:=FALSE); + END_IF + // Use this timer to time out any tests that stall + tonTimer( + IN:=bStatesReady, + PT:=T#5s, + ); + + END_FUNCTION_BLOCK + + METHOD Test1D + VAR_INPUT + nTestID: UINT; + nState: E_TestStates; + END_VAR + VAR_INST + nLocalInit: BOOL; + END_VAR + TEST(CONCAT('Test1D_state', DINT_TO_STRING(nState))); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + IF NOT nLocalInit THEN + eSetPos := nState; + nLocalInit := TRUE; + END_IF + + fb_Move1D( + stMotionStage:=stMotionStage1, + astPositionState:=astPositionState1, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + IF tonTimer.Q OR fb_Move1D.stPlcToEpics.bDone THEN + AssertTrue( + Condition:=fb_Move1D.stPlcToEpics.bDone, + Message:='Done should be True after move', + ); + AssertFalse( + Condition:=fb_Move1D.stPlcToEpics.bBusy, + Message:='Busy should be False after move', + ); + AssertFalse( + Condition:=fb_Move1D.stPlcToEpics.bError, + Message:='Error should be False after move', + ); + AssertEquals_DINT( + Expected:=nState, + Actual:=eGetPos, + Message:='Did not get to the input state', + ); + AssertEquals_LREAL( + Expected:=astPositionState1[nState].fPosition, + Actual:=stMotionStage1.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position', + ); + fb_Move1D.stEpicsToPlc.bReset := TRUE; + fb_Move1D( + stMotionStage:=stMotionStage1, + astPositionState:=astPositionState1, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + bOneTestDone := TRUE; + nLocalInit := FALSE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD Test2D + VAR_INPUT + nTestID: UINT; + nState: E_TestStates; + END_VAR + VAR_INST + nLocalInit: BOOL; + END_VAR + TEST(CONCAT('Test2D_state', DINT_TO_STRING(nState))); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + IF NOT nLocalInit THEN + eSetPos := nState; + nLocalInit := TRUE; + END_IF + + fb_Move2D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + IF tonTimer.Q OR fb_Move2D.stPlcToEpics.bDone THEN + AssertTrue( + Condition:=fb_Move2D.stPlcToEpics.bDone, + Message:='Done should be True after move', + ); + AssertFalse( + Condition:=fb_Move2D.stPlcToEpics.bBusy, + Message:='Busy should be False after move', + ); + AssertFalse( + Condition:=fb_Move2D.stPlcToEpics.bError, + Message:='Error should be False after move', + ); + AssertEquals_DINT( + Expected:=nState, + Actual:=eGetPos, + Message:='Did not get to the input state', + ); + AssertEquals_LREAL( + Expected:=astPositionState1[nState].fPosition, + Actual:=stMotionStage1.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position for stage 1', + ); + AssertEquals_LREAL( + Expected:=astPositionState2[nState].fPosition, + Actual:=stMotionStage2.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position for stage 2', + ); + fb_Move2D.stEpicsToPlc.bReset := TRUE; + fb_Move2D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + bOneTestDone := TRUE; + nLocalInit := FALSE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD Test3D + VAR_INPUT + nTestID: UINT; + nState: E_TestStates; + END_VAR + VAR_INST + nLocalInit: BOOL; + END_VAR + TEST(CONCAT('Test3D_state', DINT_TO_STRING(nState))); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + IF NOT nLocalInit THEN + eSetPos := nState; + nLocalInit := TRUE; + END_IF + + fb_Move3D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + stMotionStage3:=stMotionStage3, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + astPositionState3:=astPositionState3, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + IF tonTimer.Q OR fb_Move3D.stPlcToEpics.bDone THEN + AssertTrue( + Condition:=fb_Move3D.stPlcToEpics.bDone, + Message:='Done should be True after move', + ); + AssertFalse( + Condition:=fb_Move3D.stPlcToEpics.bBusy, + Message:='Busy should be False after move', + ); + AssertFalse( + Condition:=fb_Move3D.stPlcToEpics.bError, + Message:='Error should be False after move', + ); + AssertEquals_DINT( + Expected:=nState, + Actual:=eGetPos, + Message:='Did not get to the input state', + ); + AssertEquals_LREAL( + Expected:=astPositionState1[nState].fPosition, + Actual:=stMotionStage1.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position for stage 1', + ); + AssertEquals_LREAL( + Expected:=astPositionState2[nState].fPosition, + Actual:=stMotionStage2.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position for stage 2', + ); + AssertEquals_LREAL( + Expected:=astPositionState3[nState].fPosition, + Actual:=stMotionStage3.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position for stage 3', + ); + fb_Move3D.stEpicsToPlc.bReset := TRUE; + fb_Move3D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + stMotionStage3:=stMotionStage3, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + astPositionState3:=astPositionState3, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + bOneTestDone := TRUE; + nLocalInit := FALSE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestInputDeadlock + (* + Regression test for issue #197 + + How to reproduce the issue: + 1. Get the function block into any motion error + 2. Ask for a move while in the error state + + Then, the state mover never moves again. + + To test we will follow steps 1 and 2, then reset the error, then move. + + With our fix, our second attempt at the move (after an error reset) will succeed. + Our first attempt will fail regardless, since you cannot move a motor that is in an error state. + + Without our fix, the motor could never be moved ever again and this move will time out. + *) + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + nTestStep: UINT := 1; + eNewGoal: E_TestStates; + END_VAR + TEST('TestInputDeadlock'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + CASE nTestStep OF + // Step 1: Normal move + 1: + // Normal move: pick any other state + IF eGetPos = E_TestStates.OUT THEN + eNewGoal := E_TestStates.TARGET1; + ELSE + eNewGoal := E_TestStates.OUT; + END_IF + eSetPos := eNewGoal; + nTestStep := 2; + // Step 2: Cause a motion error. Easiest is to just set bError to TRUE during a move. + 2: + // Cause the error if it's time + IF stMotionStage1.bBusy THEN + stMotionStage1.bError := TRUE; + stMotionStage1.nErrorId := 16#4FFF; + ELSIF stMotionStage1.bError THEN + nTestStep := 3; + END_IF + // Step 3: another normal move. This should get us into the potential bugged state. + 3: + eSetPos := eNewGoal; + nTestStep := 4; + // Step 4: reset the error, which will allow fixed versions of the code to resume normal operations. + 4: + fb_Move1D.stEpicsToPlc.bReset := TRUE; + IF NOT stMotionStage1.bError THEN + nTestStep := 5; + END_IF + // Step 5: last normal move, which will succeed if we fixed the bug. + 5: + eSetPos := eNewGoal; + IF eGetPos = E_TestStates.Unknown THEN + nTestStep := 6; + END_IF + // Step 6: wait for the move to finish + 6: + IF eGetPos = eNewGoal THEN + nTestStep := 7; + END_IF + END_CASE + + fb_Move1D( + stMotionStage:=stMotionStage1, + astPositionState:=astPositionState1, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + + // Timeout and checks + IF tonTimer.Q OR nTestStep = 7 THEN + AssertFalse( + tonTimer.Q, + 'Timeout in deadlock test', + ); + AssertEquals_UINT( + Expected:=eNewGoal, + Actual:=eGetPos, + 'Did not reach a goal state in deadlock test', + ); + fb_Move1D.stEpicsToPlc.bReset := TRUE; + fb_Move1D( + stMotionStage:=stMotionStage1, + astPositionState:=astPositionState1, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + bEnable:=TRUE, + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + +Related: + * `E_TestStates`_ + * `FB_MotionStage`_ + * `FB_MotorTestSuite`_ + * `FB_PositionState1D`_ + * `FB_PositionState2D`_ + * `FB_PositionState3D`_ + * `FB_PositionStateInternal`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStatePMPS +^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use FB_PositionStatePMPS1D instead'} + FUNCTION_BLOCK FB_PositionStatePMPS EXTENDS FB_PositionStatePMPS_Base + (* + Hooks up a position state to an arbiter and an FFO + Use BeamParameterTransitionManager to manage transition requests between states + Hook up to the inputs/outputs of the state function block + Raises FFO if beam parameters are worse than required for current state + *) + VAR_IN_OUT + fbArbiter: FB_Arbiter; + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + bReadPmpsDb: BOOL; + sPmpsDeviceName: STRING; + sTransitionKey: STRING; + stPmpsDoc: SJsonValue; + stHighBeamThreshold: ST_BeamParams := PMPS_GVL.cstFullBeam; + bBPOKAutoReset: BOOL := False; + END_VAR + VAR + arrPMPS: ARRAY[0..GeneralConstants.MAX_STATES] OF ST_DbStateParams; + nBPIndex: UINT; + nTransitionAssertionID: UDINT; + nLastReqAssertionID: UDINT; + fbReadPmpsDb: FB_JsonDocToSafeBP; + ftDbBusy: F_TRIG; + rtReadDBExec: R_TRIG; + ftRead: F_TRIG; + bptm: BeamParameterTransitionManager; + ffBeamParamsOk: FB_FastFault; + ffZeroRate: FB_FastFault; + ffBPTMTimeoutAndMove: FB_FastFault; + ffBPTMError: FB_FastFault; + ffMaint: FB_FastFault; + ffUnknown: FB_FastFault; + bFFOxOk: BOOL; + bAtSafeState: BOOL; + nIter: UINT; + END_VAR + Exec(); + + END_FUNCTION_BLOCK + + ACTION AssertHere: + fbArbiter.AddRequest( + sDevName := stMotionStage.sName, + nReqID := stStateReq.stPMPS.nRequestAssertionID, + stReqBP := stStateReq.stPMPS.stBeamParams); + END_ACTION + + ACTION ClearAsserts: + fbArbiter.RemoveRequest(nTransitionAssertionID); + FOR nIter := 1 TO GeneralConstants.MAX_STATES DO + fbArbiter.RemoveRequest(arrStates[nIter].stPMPS.nRequestAssertionID); + END_FOR + END_ACTION + + ACTION HandleBPTM: + (* + Handle finishing the bptm late if timed out + bptm needs a rising edge of bTransDone after authorizing transition + If we fall into this block, bTransDone would otherwise be stuck at TRUE forever + so the BPTM would never see a rising edge and therefore stay stuck + We set to FALSE here to reset the BPTM, then gets set to TRUE again if really done. + *) + rtDoLateFinish(CLK:=bLateFinish AND bInternalAuth); + IF rtDoLateFinish.Q THEN + bTransDone := FALSE; + bLateFinish := FALSE; + END_IF + + IF stStateReq.stPMPS.nRequestAssertionID <> nTransitionAssertionID THEN + (* + Edge case: the request is swapped out without a move + Same as above: we need a rising edge of bTransDone, so cause a falling edge and the let the rising edge happen next cycle + This will already be false when we request a positional move + *) + bTransDone R= stStateReq.stPMPS.nRequestAssertionID <> nLastReqAssertionID; + // Just normal bptm call + bptm(fbArbiter:=fbArbiter, + i_sDeviceName:=stMotionStage.sName, + i_TransitionAssertionID:=nTransitionAssertionID, + i_stTransitionAssertion:=stTransitionBeam, + i_nRequestedAssertionID:=stStateReq.stPMPS.nRequestAssertionID, + i_stRequestedAssertion:=stStateReq.stPMPS.stBeamParams, + i_xDoneMoving:=bTransDone, + stCurrentBeamParameters:=PMPS_GVL.stCurrentBeamParameters, + q_xTransitionAuthorized=>bInternalAuth, + bDone=>bBPTMDone); + nLastReqAssertionID := stStateReq.stPMPS.nRequestAssertionID; + END_IF + END_ACTION + + ACTION HandleFFO: + // stBeamNeeded will point to Unknown/No beam if we are out of state bounds or in motion + // Otherwise we'll have the current state's beam parameters + + // Check for bad conditions + bFFOxOk := F_SafeBPCompare(PMPS_GVL.stCurrentBeamParameters, stBeamNeeded); + // It is safe to reset automatically if our current state can take full beam. + // Otherwise we'll have to ask for a user acknowledgement to clear. + // This avoids rapidly cycling the FFOs on/off + // You can pass in a different stHighBeamThreshold as an input parameter to customize this behavior + bAtSafeState := F_SafeBPCompare(stHighBeamThreshold, stBeamNeeded); + + // If the beam parameters are wrong, it is a fault! This encompasses all unknown arbiter-related errors. + ffBeamParamsOk.i_xOK := bFFOxOk; + ffBeamParamsOk.i_xReset S= bFFOxOk AND bAtSafeState; + ffBeamParamsOk.i_xReset R= NOT ffBeamParamsOk.i_xOK; + ffBeamParamsOk.i_xAutoReset := bBPOKAutoReset; + + ffBeamParamsOk( + i_DevName:=stMotionStage.sName, + i_Desc:='Beam parameter mismatch', + i_TypeCode:=16#1000, + io_fbFFHWO:=fbFFHWO); + + // Trip the beam for zero-rate states. This is a PMPS training wheel and should ultimately be removed. + // Note: I think this is already redundant + ffZeroRate( + i_xOk := stBeamNeeded.nRate > 0, + i_xAutoReset := TRUE, + i_DevName := stMotionStage.sName, + i_Desc := 'Device requesting zero rate', + i_TypeCode := 16#1001, + io_fbFFHWO := fbFFHWO); + + // Trip the beam for BPTM timeouts if we want to move + // Only reset at safe beam OR at no bptm errors (some other FF should catch additional issues) + ffBPTMTimeoutAndMove.i_xOK := NOT (bArbiterTimeout AND bMoveOnArbiterTimeout); + ffBPTMTimeoutAndMove.i_xReset S= bAtSafeState OR (bptm.bDone AND NOT bptm.bError); + ffBPTMTimeoutAndMove.i_xReset R= NOT ffBPTMTimeoutAndMove.i_xOK; + ffBPTMTimeoutAndMove( + i_DevName := stMotionStage.sName, + i_Desc := 'BPTM Timeout', + i_TypeCode := 16#1002, + io_fbFFHWO := fbFFHWO); + + // Trip the beam for BPTM Errors + ffBPTMError.i_xOK := NOT bptm.bError; + ffBPTMError.i_xReset S= bptm.bDone AND NOT bptm.bError; + ffBPTMError.i_xReset R= NOT ffBPTMError.i_xOK; + ffBPTMError( + i_DevName := stMotionStage.sName, + i_Desc := 'BPTM error, state transition failed', + i_TypeCode := 16#1003, + io_fbFFHWO := fbFFHWO); + + // Trip the beam for maintenance mode + ffMaint( + i_xOK := NOT bMaintMode, + i_xAutoReset := TRUE, + i_DevName := stMotionStage.sName, + i_Desc := 'Device is in maintenance mode', + i_TypeCode := 16#1004, + io_fbFFHWO := fbFFHWO); + + // Trip the beam for unknown state + ffUnknown( + i_xOK := getState > 0 OR bInTransition, + i_xAutoReset := TRUE, + i_DevName := stMotionStage.sName, + i_Desc := 'Unknown position between moves', + i_TypeCode := 16#1005, + io_fbFFHWO := fbFFHWO); + END_ACTION + + ACTION HandlePmpsDb: + // Automatically read from the pmps db when it updates + // Assume update if no longer busy and no errors + + ftDbBusy(CLK:=MOTION_GVL.fbPmpsFileReader.bBusy); + IF ftDbBusy.Q THEN + bReadPmpsDb S= NOT MOTION_GVL.fbPmpsFileReader.bError; + END_IF + + rtReadDBExec(CLK:=bReadPmpsDb); + IF rtReadDBExec.Q THEN + arrPMPS[0].sPmpsState := sTransitionKey; + FOR nBPIndex := 1 TO GeneralConstants.MAX_STATES BY 1 DO + arrPMPS[nBPIndex] := arrStates[nBPIndex].stPMPS; + END_FOR + END_IF + + fbReadPmpsDb( + bExecute:=bReadPmpsDb, + jsonDoc:=stPmpsDoc, + sDeviceName:=sPmpsDeviceName, + io_fbFFHWO:=fbFFHWO, + arrStates:=arrPMPS, + ); + bReadPmpsDb R= NOT fbReadPmpsDb.bBusy; + + ftRead(CLK:=fbReadPmpsDb.bBusy); + + stTransitionState.sName := 'Transition'; + IF ftRead.Q AND NOT fbReadPmpsDb.bError THEN + stTransitionDb := arrPMPS[0]; + stTransitionBeam := arrPMPS[0].stBeamParams; + nTransitionAssertionID := arrPMPS[0].nRequestAssertionID; + stTransitionState.stPMPS := arrPMPS[0]; + FOR nBPIndex := 1 TO GeneralConstants.MAX_STATES BY 1 DO + arrStates[nBPIndex].stPMPS := arrPMPS[nBPIndex]; + END_FOR + END_IF + END_ACTION + + +Related: + * `FB_PositionStatePMPS1D`_ + * `FB_PositionStatePMPS_Base`_ + * `MOTION_GVL`_ + + +FB_PositionStatePMPS1D +^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStatePMPS1D + (* + 1-Dimensional position state function block with PMPS. + + This allows the user to move a motor among some set of named state positions with PMPS protection. + + To use a states block, you must define enums that match the state options and give them pytmc pragmas. + See FB_PositionState1D_InOut for a simple example. + These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables. + The enum values must match the array indices in astPositionState. + + A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us + to accept a new, possibly conflicting, move request on the next cycle to interrupt the first. + + The motor must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly. + + PMPS handling is done via database lookups by setting sPmpsState on each position state and on + the transition state input appropriately. + *) + VAR_IN_OUT + // The motor to move. + stMotionStage: ST_MotionStage; + // All possible position states, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE + io: io + expand: :%.2d + '} + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input. + eEnumSet: UINT; + // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output. + eEnumGet: UINT; + // The fast fault output to fault to. + fbFFHWO: FB_HardwareFFOutput; + // The arbiter to request beam conditions from. + fbArbiter: FB_Arbiter; + END_VAR + VAR_INPUT + // Set this to TRUE to enable input state moves, or FALSE to disable them. + bEnableMotion: BOOL; + // Set this to TRUE to enable beam parameter checks, or FALSE to disable them. + bEnableBeamParams: BOOL; + // Set this to TRUE to enable position limit checks, or FALSE to disable them. + bEnablePositionLimits: BOOL; + // The name of the device for use in the PMPS DB lookup and diagnostic screens. + sDeviceName: STRING; + // The name of the transition state in the PMPS database. + sTransitionKey: STRING; + // Normal EPICS inputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stEpicsToPlc: ST_StateEpicsToPlc; + // PMPS EPICS inputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPMPSEpicsToPlc: ST_StatePMPSEpicsToPlc; + // Set this to TRUE to re-read the loaded database immediately (useful for debug) + bReadDBNow: BOOL; + END_VAR + VAR_OUTPUT + // Normal EPICS outputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPlcToEpics: ST_StatePlcToEpics; + // PMPS EPICS outputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPMPSPlcToEpics: ST_StatePMPSPlcToEpics; + // The PMPS database lookup associated with the current position state. + stDbStateParams: ST_DbStateParams; + END_VAR + VAR + fbCore: FB_PositionStateND_Core; + fbPMPSCore: FB_PositionStatePMPSND_Core; + astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + astMotionStageMax[1] := stMotionStage; + astPositionStateMax[1] := astPositionState; + + fbCore( + astMotionStageMax:=astMotionStageMax, + astPositionStateMax:=astPositionStateMax, + stEpicsToPlc:=stEpicsToPlc, + stPlcToEpics:=stPlcToEpics, + eEnumSet:=eEnumSet, + eEnumGet:=eEnumGet, + bEnable:=bEnableMotion, + nActiveMotorCount:=1, + nCurrGoal=>, + ); + fbPMPSCore( + astMotionStageMax:=astMotionStageMax, + astPositionStateMax:=astPositionStateMax, + stEpicsToPlc:=stEpicsToPlc, + stPMPSEpicsToPlc:=stPMPSEpicsToPlc, + stPlcToEpics:=stPlcToEpics, + stPMPSPlcToEpics:=stPMPSPlcToEpics, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter, + bEnableBeamParams:=bEnableBeamParams, + bEnablePositionLimits:=bEnablePositionLimits, + nActiveMotorCount:=1, + sDeviceName:=sDeviceName, + sTransitionKey:=sTransitionKey, + nCurrGoal:=fbCore.nCurrGoal, + bReadDBNow:=bReadDBNow, + stDbStateParams=>stDbStateParams, + ); + + stMotionStage := astMotionStageMax[1]; + astPositionState := astPositionStateMax[1]; + + END_FUNCTION_BLOCK + + +Related: + * `FB_MotionStage`_ + * `FB_PositionState1D_InOut`_ + * `FB_PositionStateND_Core`_ + * `FB_PositionStatePMPSND_Core`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + * `ST_StateEpicsToPlc`_ + * `ST_StatePMPSEpicsToPlc`_ + * `ST_StatePMPSPlcToEpics`_ + * `ST_StatePlcToEpics`_ + + +FB_PositionStatePMPS1D_InOut +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStatePMPS1D_InOut + (* + An example and usable drop-in instance for a 1D pmps state device with just an IN and an OUT state. + Note that the outward-facing API is nearly identical to the non-PMPS version + *) + VAR_IN_OUT + // Include a stage that can be passed into the FB + stMotionStage: ST_MotionStage; + // Simplify the interface, the user just needs to construct and pass in and out position states + stIn: ST_PositionState; + stOut: ST_PositionState; + // Include PMPS output helpers + fbFFHWO: FB_HardwareFFOutput; + fbArbiter: FB_Arbiter; + END_VAR + VAR_INPUT + // Define an ENUM for EPICS to use to set a new value. It is expected this will be written to during one cycle, so don't continually apply a value here in the PLC code. + // It is exposed as an input so we can test it using the PLC. + {attribute 'pytmc' := ' + pv: STATE:SET + io: io + '} + eStateSet: E_EpicsInOut; + END_VAR + VAR_OUTPUT + // Define an ENUM for EPICS to use to report the new value. + {attribute 'pytmc' := ' + pv: STATE:GET + io: i + '} + eStateGet: E_EpicsInOut; + END_VAR + VAR + // Include the standard fb with blank pv pragma + {attribute 'pytmc' := 'pv:'} + fbPositionStatePMPS1D: FB_PositionStatePMPS1D; + // The standard fb expects a full array of position states + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + // Optional: default state names + IF stIn.sName = '' THEN + stIn.sName := 'IN'; + END_IF + IF stOut.sName = '' THEN + stOut.sName := 'OUT'; + END_IF + + // Assemble the states array, matching the enum values (IN is 1, OUT is 2) + astPositionState[1] := stIn; + astPositionState[2] := stOut; + + // Call the main function block, passing our motors, states, and an enable + fbPositionStatePMPS1D( + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter, + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + eEnumSet:=eStateSet, + eEnumGet:=eStateGet, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + ); + + // Send updates made on the array back to the inputs (VAR_IN_OUT) for maximum clarity + stIn := astPositionState[1]; + stOut := astPositionState[2]; + + END_FUNCTION_BLOCK + + +Related: + * `E_EpicsInOut`_ + * `FB_PositionStatePMPS1D`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStatePMPS2D +^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStatePMPS2D + (* + 2-Dimensional position state function block with PMPS. + + This allows the user to move 2 motors among some set of named state positions with PMPS protection. + + To use a states block, you must define enums that match the state options and give them pytmc pragmas. + See FB_PositionState1D_InOut for a simple example. + These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables. + The enum values must match the array indices in astPositionState1 and astPositionState2. + + A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us + to accept a new, possibly conflicting, move request on the next cycle to interrupt the first. + + The motors must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly. + + PMPS handling is done via database lookups by setting sPmpsState on each position state and on + the transition state input appropriately. + *) + VAR_IN_OUT + // The 1st motor to move + stMotionStage1: ST_MotionStage; + // The 2nd motor to move + stMotionStage2: ST_MotionStage; + // All possible position states for motor 1, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:M1 + io: io + expand: :%.2d + '} + astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // All possible position states for motor 2, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:M2 + io: io + expand: :%.2d + '} + astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input. + eEnumSet: UINT; + // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output. + eEnumGet: UINT; + // The fast fault output to fault to. + fbFFHWO: FB_HardwareFFOutput; + // The arbiter to request beam conditions from. + fbArbiter: FB_Arbiter; + END_VAR + VAR_INPUT + // Set this to TRUE to enable input state moves, or FALSE to disable them. + bEnableMotion: BOOL; + // Set this to TRUE to enable beam parameter checks, or FALSE to disable them. + bEnableBeamParams: BOOL; + // Set this to TRUE to enable position limit checks, or FALSE to disable them. + bEnablePositionLimits: BOOL; + // The name of the device for use in the PMPS DB lookup and diagnostic screens. + sDeviceName: STRING; + // The name of the transition state in the PMPS database. + sTransitionKey: STRING; + // Normal EPICS inputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + // PMPS EPICS inputs, gathered into a single struct + stEpicsToPlc: ST_StateEpicsToPlc; + {attribute 'pytmc' := 'pv: STATE'} + stPMPSEpicsToPlc: ST_StatePMPSEpicsToPlc; + // Set this to TRUE to re-read the loaded database immediately (useful for debug) + bReadDBNow: BOOL; + END_VAR + VAR_OUTPUT + // Normal EPICS outputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPlcToEpics: ST_StatePlcToEpics; + // PMPS EPICS outputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPMPSPlcToEpics: ST_StatePMPSPlcToEpics; + // The PMPS database lookup associated with the current position state. + stDbStateParams: ST_DbStateParams; + END_VAR + VAR + fbCore: FB_PositionStateND_Core; + fbPMPSCore: FB_PositionStatePMPSND_Core; + astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + astMotionStageMax[1] := stMotionStage1; + astMotionStageMax[2] := stMotionStage2; + astPositionStateMax[1] := astPositionState1; + astPositionStateMax[2] := astPositionState2; + + fbCore( + astMotionStageMax:=astMotionStageMax, + astPositionStateMax:=astPositionStateMax, + stEpicsToPlc:=stEpicsToPlc, + stPlcToEpics:=stPlcToEpics, + eEnumSet:=eEnumSet, + eEnumGet:=eEnumGet, + bEnable:=bEnableMotion, + nActiveMotorCount:=2, + nCurrGoal=>, + ); + fbPMPSCore( + astMotionStageMax:=astMotionStageMax, + astPositionStateMax:=astPositionStateMax, + stEpicsToPlc:=stEpicsToPlc, + stPMPSEpicsToPlc:=stPMPSEpicsToPlc, + stPlcToEpics:=stPlcToEpics, + stPMPSPlcToEpics:=stPMPSPlcToEpics, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter, + bEnableBeamParams:=bEnableBeamParams, + bEnablePositionLimits:=bEnablePositionLimits, + nActiveMotorCount:=2, + sDeviceName:=sDeviceName, + sTransitionKey:=sTransitionKey, + nCurrGoal:=fbCore.nCurrGoal, + bReadDBNow:=bReadDBNow, + stDbStateParams=>stDbStateParams, + ); + + stMotionStage1 := astMotionStageMax[1]; + stMotionStage2 := astMotionStageMax[2]; + astPositionState1 := astPositionStateMax[1]; + astPositionState2 := astPositionStateMax[2]; + + END_FUNCTION_BLOCK + + +Related: + * `FB_MotionStage`_ + * `FB_PositionState1D_InOut`_ + * `FB_PositionStateND_Core`_ + * `FB_PositionStatePMPSND_Core`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + * `ST_StateEpicsToPlc`_ + * `ST_StatePMPSEpicsToPlc`_ + * `ST_StatePMPSPlcToEpics`_ + * `ST_StatePlcToEpics`_ + + +FB_PositionStatePMPS2D_InOut +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStatePMPS2D_InOut + (* + An example and usable drop-in instance for a 2D state device with just an IN and an OUT state. + Note that the outward-facing API is nearly identical to the non-PMPS version + *) + VAR_IN_OUT + // Include stages that can be passed into the FB + stMotionStage1: ST_MotionStage; + stMotionStage2: ST_MotionStage; + // Simplify the interface, the user just needs to construct and pass in and out position states + stIn1: ST_PositionState; + stOut1: ST_PositionState; + stIn2: ST_PositionState; + stOut2: ST_PositionState; + // Include PMPS output helpers + fbFFHWO: FB_HardwareFFOutput; + fbArbiter: FB_Arbiter; + END_VAR + VAR_INPUT + // Define an ENUM for EPICS to use to set a new value. It is expected this will be written to during one cycle, so don't continually apply a value here in the PLC code. + // It is exposed as an input so we can test it using the PLC. + {attribute 'pytmc' := ' + pv: STATE:SET + io: io + '} + eStateSet: E_EpicsInOut; + END_VAR + VAR_OUTPUT + // Define an ENUM for EPICS to use to report the new value. + {attribute 'pytmc' := ' + pv: STATE:GET + io: i + '} + eStateGet: E_EpicsInOut; + END_VAR + VAR + // Include the standard fb with blank pv pragma + {attribute 'pytmc' := 'pv:'} + fbPositionStatePMPS2D: FB_PositionStatePMPS2D; + // The standard fb expects a full array of position states per motor + astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + // Optional: default state names + IF stIn1.sName = '' THEN + stIn1.sName := 'IN'; + END_IF + IF stOut1.sName = '' THEN + stOut1.sName := 'OUT'; + END_IF + IF stIn2.sName = '' THEN + stIn2.sName := 'IN'; + END_IF + IF stOut2.sName = '' THEN + stOut2.sName := 'OUT'; + END_IF + + // Assemble the states arrays, matching the enum values (IN is 1, OUT is 2) + astPositionState1[1] := stIn1; + astPositionState1[2] := stOut1; + astPositionState2[1] := stIn2; + astPositionState2[2] := stOut2; + + // Call the main function block, passing our motors, states, and an enable + fbPositionStatePMPS2D( + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter, + stMotionStage1:=stMotionStage1, + astPositionState1:=astPositionState1, + stMotionStage2:=stMotionStage2, + astPositionState2:=astPositionState2, + eEnumSet:=eStateSet, + eEnumGet:=eStateGet, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + ); + + // Send updates made on the array back to the inputs (VAR_IN_OUT) for maximum clarity + stIn1 := astPositionState1[1]; + stOut1 := astPositionState1[2]; + stIn2 := astPositionState2[1]; + stOut2 := astPositionState2[2]; + + END_FUNCTION_BLOCK + + +Related: + * `E_EpicsInOut`_ + * `FB_PositionStatePMPS2D`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStatePMPS3D +^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStatePMPS3D + (* + 3-Dimensional position state function block with PMPS. + + This allows the user to move 3 motors among some set of named state positions with PMPS protection. + + To use a states block, you must define enums that match the state options and give them pytmc pragmas. + See FB_PositionState1D_InOut for a simple example. + These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables. + The enum values must match the array indices in astPositionState1, astPositionState2, and astPositionState3. + + A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us + to accept a new, possibly conflicting, move request on the next cycle to interrupt the first. + + The motors must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly. + + PMPS handling is done via database lookups by setting sPmpsState on each position state and on + the transition state input appropriately. + *) + VAR_IN_OUT + // The 1st motor to move + stMotionStage1: ST_MotionStage; + // The 2nd motor to move + stMotionStage2: ST_MotionStage; + // The 3rd motor to move + stMotionStage3: ST_MotionStage; + // All possible position states for motor 1, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:M1 + io: io + expand: :%.2d + '} + astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // All possible position states for motor 2, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:M2 + io: io + expand: :%.2d + '} + astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // All possible position states for motor 3, including unused/invalid states. + {attribute 'pytmc' := ' + pv: STATE:M3 + io: io + expand: :%.2d + '} + astPositionState3: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input. + eEnumSet: UINT; + // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output. + eEnumGet: UINT; + // The fast fault output to fault to. + fbFFHWO: FB_HardwareFFOutput; + // The arbiter to request beam conditions from. + fbArbiter: FB_Arbiter; + END_VAR + VAR_INPUT + // Set this to TRUE to enable input state moves, or FALSE to disable them. + bEnableMotion: BOOL; + // Set this to TRUE to enable beam parameter checks, or FALSE to disable them. + bEnableBeamParams: BOOL; + // Set this to TRUE to enable position limit checks, or FALSE to disable them. + bEnablePositionLimits: BOOL; + // The name of the device for use in the PMPS DB lookup and diagnostic screens. + sDeviceName: STRING; + // The name of the transition state in the PMPS database. + sTransitionKey: STRING; + // Normal EPICS inputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + // PMPS EPICS inputs, gathered into a single struct + stEpicsToPlc: ST_StateEpicsToPlc; + {attribute 'pytmc' := 'pv: STATE'} + stPMPSEpicsToPlc: ST_StatePMPSEpicsToPlc; + // Set this to TRUE to re-read the loaded database immediately (useful for debug) + bReadDBNow: BOOL; + END_VAR + VAR_OUTPUT + // Normal EPICS outputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPlcToEpics: ST_StatePlcToEpics; + // PMPS EPICS outputs, gathered into a single struct + {attribute 'pytmc' := 'pv: STATE'} + stPMPSPlcToEpics: ST_StatePMPSPlcToEpics; + // The PMPS database lookup associated with the current position state. + stDbStateParams: ST_DbStateParams; + END_VAR + VAR + fbCore: FB_PositionStateND_Core; + fbPMPSCore: FB_PositionStatePMPSND_Core; + astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + astMotionStageMax[1] := stMotionStage1; + astMotionStageMax[2] := stMotionStage2; + astMotionStageMax[3] := stMotionStage3; + astPositionStateMax[1] := astPositionState1; + astPositionStateMax[2] := astPositionState2; + astPositionStateMax[3] := astPositionState3; + + fbCore( + astMotionStageMax:=astMotionStageMax, + astPositionStateMax:=astPositionStateMax, + stEpicsToPlc:=stEpicsToPlc, + stPlcToEpics:=stPlcToEpics, + eEnumSet:=eEnumSet, + eEnumGet:=eEnumGet, + bEnable:=bEnableMotion, + nActiveMotorCount:=3, + nCurrGoal=>, + ); + fbPMPSCore( + astMotionStageMax:=astMotionStageMax, + astPositionStateMax:=astPositionStateMax, + stEpicsToPlc:=stEpicsToPlc, + stPMPSEpicsToPlc:=stPMPSEpicsToPlc, + stPlcToEpics:=stPlcToEpics, + stPMPSPlcToEpics:=stPMPSPlcToEpics, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter, + bEnableBeamParams:=bEnableBeamParams, + bEnablePositionLimits:=bEnablePositionLimits, + nActiveMotorCount:=3, + sDeviceName:=sDeviceName, + sTransitionKey:=sTransitionKey, + nCurrGoal:=fbCore.nCurrGoal, + bReadDBNow:=bReadDBNow, + stDbStateParams=>stDbStateParams, + ); + + stMotionStage1 := astMotionStageMax[1]; + stMotionStage2 := astMotionStageMax[2]; + stMotionStage3 := astMotionStageMax[3]; + astPositionState1 := astPositionStateMax[1]; + astPositionState2 := astPositionStateMax[2]; + astPositionState3 := astPositionStateMax[3]; + + END_FUNCTION_BLOCK + + +Related: + * `FB_MotionStage`_ + * `FB_PositionState1D_InOut`_ + * `FB_PositionStateND_Core`_ + * `FB_PositionStatePMPSND_Core`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + * `ST_StateEpicsToPlc`_ + * `ST_StatePMPSEpicsToPlc`_ + * `ST_StatePMPSPlcToEpics`_ + * `ST_StatePlcToEpics`_ + + +FB_PositionStatePMPS_Base +^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use FB_PositionStatePMPS1D instead'} + FUNCTION_BLOCK FB_PositionStatePMPS_Base + (* + FB_PositionStatePMPS without Arbiter, BPTM, FFO + + This allows me to test most of the code without an arbiter plc setup + *) + VAR_IN_OUT + stMotionStage: ST_MotionStage; + arrStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + VAR_INPUT + bArbiterEnabled: BOOL := TRUE; + {attribute 'pytmc' := ' + pv: MAINT + io: io + '} + bMaintMode: BOOL; + bRequestTransition: BOOL; + setState: INT; + getState: INT; + fStateBoundaryDeadband: LREAL := 0; + tArbiterTimeout: TIME := T#1s; + bMoveOnArbiterTimeout: BOOL := TRUE; + END_VAR + VAR_OUTPUT + bTransitionAuthorized: BOOL; + bForwardAuthorized: BOOL; + bBackwardAuthorized: BOOL; + bArbiterTimeout: BOOL; + END_VAR + VAR + {attribute 'pytmc' := ' + pv: TRANS + io: i + '} + stTransitionDb: ST_DbStateParams; + stTransitionBeam: ST_BeamParams := PMPS_GVL.cst0RateBeam; + stTransitionState: ST_PositionState; + bInit: BOOL := TRUE; + bTransDone: BOOL; + rtTransReq: R_TRIG; + bBPTMDone: BOOL; + rtBPTMDone: R_TRIG; + ftMotorExec: F_TRIG; + rtTransDone: R_TRIG; + rtDoLateFinish: R_TRIG; + tonDone: TON; + stStateReq: ST_PositionState; + mcPower: MC_POWER; + fUpperBound: LREAL; + fLowerBound: LREAL; + nGoalState: INT; + stGoalState: ST_PositionState; + fActPos: LREAL; + fReqPos: LREAL; + bInTransition: BOOL; + stBeamNeeded: ST_BeamParams; + bFwdOk: BOOL; + bBwdOk: BOOL; + tonArbiter: TON; + bLateFinish: BOOL; + bInternalAuth: BOOL; + END_VAR + // This is meant to be subclassed. The parent class body is in the Exec action. + + END_FUNCTION_BLOCK + + ACTION AssertHere: + + END_ACTION + + ACTION ClearAsserts: + + END_ACTION + + ACTION Exec: + // Load the pmps parameters as needed + HandlePmpsDb(); + + // Initialize or reinitialize to the current state value + rtBPTMDone(CLK:=bBPTMDone); + ftMotorExec(CLK:=stMotionStage.bExecute); + tonDone( + IN:=bTransDone, + PT:=T#100ms + ); + IF rtBPTMDone.Q OR ftMotorExec.Q OR tonDone.Q THEN + bInit := TRUE; + END_IF + IF bInit OR nGoalState = 0 OR stMotionStage.bError THEN + bInit R= stMotionStage.bAxisParamsInit; + nGoalState := getState; + stStateReq := GetStateStruct(getState); + bInTransition := FALSE; + rtTransReq(CLK:=FALSE); + bTransitionAuthorized := FALSE; + bArbiterTimeout := FALSE; + END_IF + + // Request transition on rising edge + rtTransReq(CLK:=bRequestTransition); + IF rtTransReq.Q THEN + nGoalState := setState; + stStateReq := GetStateStruct(setState); + bInTransition := TRUE; + bTransDone := FALSE; + ELSE + bTransDone := F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=stStateReq) AND NOT stMotionStage.bBusy; + END_IF + + // Mark late finish if bTransDone -> true before the bptm is done + // This means that we finished the move so fast that the bptm needs to be unstuck via toggling bTransDone + rtTransDone(CLK:=bTransDone); + bLateFinish S= rtTransDone.Q AND NOT bBPTMDone; + + IF bArbiterEnabled THEN + // Handles getting the request to the arbiter and back + HandleBPTM(); + // Handle arbiter timeouts + IF tArbiterTimeout > T#0s THEN + tonArbiter( + IN:=bInTransition AND NOT bInternalAuth, + PT:=tArbiterTimeout, + Q=>bArbiterTimeout); + ELSE + bArbiterTimeout := FALSE; + END_IF + bTransitionAuthorized S= bInternalAuth OR (bArbiterTimeout AND bMoveOnArbiterTimeout); + ELSE + // Clear all of our assertions if we decide to disable the arbiter + ClearAsserts(); + // Do some dummy request handling + bTransitionAuthorized := stMotionStage.bExecute; + bArbiterTimeout := stMotionStage.bExecute; + END_IF + + // Set up MPS virtual limit for moves at and between states + stGoalState := GetStateStruct(nGoalState); + fActPos := stMotionStage.stAxisStatus.fActPosition; + IF stMotionStage.bExecute THEN + fReqPos := stMotionStage.fPosition; + ELSE + fReqPos := fActPos; + END_IF + + // Start with no move authority + bForwardAuthorized := FALSE; + bBackwardAuthorized := FALSE; + + // Check if it would be OK to move without granting auth + bFwdOk := F_PosUnderUpperBound(MAX(fActPos, fReqPos) + ABS(fStateBoundaryDeadband), stGoalState); + bBwdOk := F_PosOverLowerBound(MIN(fActPos, fReqPos) - ABS(fStateBoundaryDeadband), stGoalState); + + // Grant auth during moves based on goal state, current position, and goal position + IF stMotionStage.bExecute AND stGoalState.bValid THEN + bForwardAuthorized := bFwdOk; + bBackwardAuthorized := bBwdOk; + END_IF + + IF bInTransition THEN + // Deny auth during a transition request until transition is authorized + bForwardAuthorized R= NOT bTransitionAuthorized; + bBackwardAuthorized R= NOT bTransitionAuthorized; + // Have the motor wait for permission to start move instead of immediately erroring + stMotionStage.bSafetyReady := bTransitionAuthorized; + ELSE + // If not transitioning, no need to wait for safety: immediately try to move and error if no auth + stMotionStage.bSafetyReady := stMotionStage.bExecute; + // Set an error message override in case this causes an error + IF stMotionStage.bError AND bArbiterEnabled AND NOT bMaintMode THEN + IF fReqPos > fActPos AND NOT bFwdOk THEN + stMotionStage.sCustomErrorMessage := 'Unsafe tweak forward blocked by PMPS'; + ELSIF fReqPos < fActPos AND NOT bBwdOk THEN + stMotionStage.sCustomErrorMessage := 'Unsafe tweak backward blocked by PMPS'; + END_IF + END_IF + END_IF + + IF bArbiterEnabled AND NOT bMaintMode THEN + // Only let us move if the transition is allowed, or if we are moving within a state's bounds + mcPower(Axis:=stMotionStage.Axis, + Enable:=stMotionStage.bAllEnable, + Enable_Positive:=stMotionStage.bAllForwardEnable AND bForwardAuthorized, + Enable_Negative:=stMotionStage.bAllBackwardEnable AND bBackwardAuthorized); + ELSE + mcPower(Axis:=stMotionStage.Axis, + Enable:=stMotionStage.bAllEnable, + Enable_Positive:=stMotionStage.bAllForwardEnable, + Enable_Negative:=stMotionStage.bAllBackwardEnable); + stMotionStage.bSafetyReady := TRUE; + END_IF + + // Raise fast faults as needed + stBeamNeeded := GetBeamFromState(getState); + HandleFFO(); + END_ACTION + + ACTION HandleBPTM: + + END_ACTION + + ACTION HandleFFO: + + END_ACTION + + ACTION HandlePmpsDb: + + END_ACTION + + METHOD GetBeamFromState : ST_BeamParams; + VAR_INPUT + nState: INT; + END_VAR + VAR + stState: ST_PositionState; + END_VAR + stState := GetStateStruct(nState); + GetBeamFromState := stState.stPMPS.stBeamParams; + END_METHOD + + METHOD GetStateCode : INT + VAR_INPUT + nState: INT; + END_VAR + IF nState < 0 OR nState > GeneralConstants.MAX_STATES THEN + GetStateCode := -1; + ELSE + GetStateCode := nState; + END_IF + END_METHOD + + METHOD GetStateStruct : ST_PositionState + VAR_INPUT + nState: INT; + END_VAR + {warning disable C0371} + // Implicit VAR_IN_OUT reference inside a method needs special handling + IF NOT __ISVALIDREF(arrStates) THEN + GetStateStruct := stTransitionState; + RETURN; + END_IF + CASE GetStateCode(nState) OF + -1: GetStateStruct := stTransitionState; + 0: GetStateStruct := stTransitionState; + ELSE + GetStateStruct := arrStates[nState]; + END_CASE + {warning restore C0371} + END_METHOD + + +Related: + * `FB_PositionStatePMPS`_ + * `FB_PositionStatePMPS1D`_ + * `F_AtPositionState`_ + * `F_PosOverLowerBound`_ + * `F_PosUnderUpperBound`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStatePMPS_Test +^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'No longer any reason to use this, all state classes can have unit tests.'} + FUNCTION_BLOCK FB_PositionStatePMPS_Test EXTENDS FB_PositionStatePMPS_Base + (* + Implement position state pmps with no FFO and auto-accept transition after 3s + Use for offline testing of everything except the explicit interface + *) + VAR + tonReq: TON; + END_VAR + Exec(); + + END_FUNCTION_BLOCK + + ACTION HandleBPTM: + // Send the fake BPTM our assertion request by changing stStateReq.stBeamParams + // We expect to recieve bTransitionAuthorized TRUE after some delta T + // We expect bTransitionAuthorized to go FALSE after stMotionStage.bBusy goes FALSE + tonReq( + IN:=bInTransition, + PT:=T#3s); + bTransitionAuthorized := tonReq.Q AND stMotionStage.bExecute; + END_ACTION + + ACTION HandleFFO: + // Skip implementing this for offline testing + // We won't be able to tell if it worked anyway + END_ACTION + + +Related: + * `FB_PositionStatePMPS_Base`_ + + +FB_PositionStatePMPSND_Core +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStatePMPSND_Core + (* + Collection of all core actions shared between all PMPS states FBs + This is used in e.g. + - FB_PositionStatePMPS1D + - FB_PositionStatePMPS2D + - ... etc. + + This handles database reading, BPTM, motor enables, virtual limits, and all FFOS. + *) + VAR_IN_OUT + // All motors to be used in the states move, including blank/uninitialized structs. + astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + // All position states for all motors, including unused/invalid states. + astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Normal EPICS inputs, gathered into a single struct + stEpicsToPlc: ST_StateEpicsToPlc; + // PMPS EPICS inputs, gathered into a single struct + stPMPSEpicsToPlc: ST_StatePMPSEpicsToPlc; + // Normal EPICS outputs, gathered into a single struct + stPlcToEpics: ST_StatePlcToEpics; + // PMPS EPICS outputs, gathered into a single struct + stPMPSPlcToEpics: ST_StatePMPSPlcToEpics; + // The fast fault output to fault to. + fbFFHWO: FB_HardwareFFOutput; + // The arbiter to request beam conditions from. + fbArbiter: FB_Arbiter; + END_VAR + VAR_INPUT + // Set this to TRUE to enable beam parameter checks, or FALSE to disable them. + bEnableBeamParams: BOOL; + // Set this to TRUE to enable position limit checks, or FALSE to disable them. + bEnablePositionLimits: BOOL; + // Set this to the number of motors to be included in astMotionStageMax + nActiveMotorCount: UINT; + // The name of the device for use in the PMPS DB lookup and diagnostic screens. + sDeviceName: STRING; + // The name of the transition state in the PMPS database. + sTransitionKey: STRING; + // The current position index goal, where the motors are supposed to be moving towards. + nCurrGoal: UINT; + // Set this to TRUE to re-read the loaded database immediately (useful for debug) + bReadDBNow: BOOL; + END_VAR + VAR_OUTPUT + // The PMPS database lookup associated with the current position state. + stDbStateParams: ST_DbStateParams; + END_VAR + VAR + fbMotionReadPMPSDB: FB_MotionReadPMPSDBND; + fbMotionBPTM: FB_MotionBPTM; + fbMotionClearAsserts: FB_MotionClearAsserts; + fbStatePMPSEnables: FB_StatePMPSEnablesND; + fbMiscStatesErrorFFO: FB_MiscStatesErrorFFO; + fbPerMotorFFO: FB_PerMotorFFOND; + + eStatePMPSStatus: E_StatePMPSStatus; + END_VAR + IF stPMPSEpicsToPlc.bMaintMode OR NOT stPMPSEpicsToPlc.bArbiterEnabled THEN + eStatePMPSStatus := E_StatePMPSStatus.DISABLED; + ELSIF stPlcToEpics.nGetValue = 0 AND nCurrGoal = 0 THEN + eStatePMPSStatus := E_StatePMPSStatus.UNKNOWN; + ELSIF stPlcToEpics.nGetValue = nCurrGoal THEN + eStatePMPSStatus := E_StatePMPSStatus.AT_STATE; + ELSE + eStatePMPSStatus := E_StatePMPSStatus.TRANSITION; + END_IF + + fbMotionReadPMPSDB( + astPositionState:=astPositionStateMax, + fbFFHWO:=fbFFHWO, + sTransitionKey:=sTransitionKey, + sDeviceName:=sDeviceName, + bReadNow:=bReadDBNow, + astDbStateParams=>, + bError=>, + ); + + fbMotionBPTM( + astMotionStage:=astMotionStageMax, + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + stGoalParams:=fbMotionReadPMPSDB.astDbStateParams[nCurrGoal], + stTransParams:=fbMotionReadPMPSDB.astDbStateParams[0], + nActiveMotorCount:=nActiveMotorCount, + bEnable:=stPMPSEpicsToPlc.bArbiterEnabled AND bEnableBeamParams, + bAtState:=stPlcToEpics.nGetValue = nCurrGoal AND nCurrGoal <> 0, + sDeviceName:=sDeviceName, + bTransitionAuthorized=>, + bDone=>, + bMotorCountError=>, + ); + + fbMotionClearAsserts( + astDbStateParams:=fbMotionReadPMPSDB.astDbStateParams, + fbArbiter:=fbArbiter, + bExecute:=NOT fbMotionBPTM.bEnable, + ); + + fbStatePMPSEnables( + astMotionStage:=astMotionStageMax, + astPositionState:=astPositionStateMax, + fbFFHWO:=fbFFHWO, + bEnable:=bEnablePositionLimits, + nActiveMotorCount:=nActiveMotorCount, + nGoalStateIndex:=nCurrGoal, + sDeviceName:=sDeviceName, + bMaintMode:=stPMPSEpicsToPlc.bMaintMode, + eStatePMPSStatus:=eStatePMPSStatus, + bTransitionAuthorized:=fbMotionBPTM.bTransitionAuthorized, + abEnabled=>, + abForwardEnabled=>, + abBackwardEnabled=>, + abValidGoal=>, + bMotorCountError=>, + ); + + IF bEnableBeamParams THEN + fbMiscStatesErrorFFO.stCurrentBeamReq := fbMotionReadPMPSDB.astDbStateParams[stPlcToEpics.nGetValue].stBeamParams; + ELSE + fbMiscStatesErrorFFO.stCurrentBeamReq := PMPS_GVL.cstFullBeam; + END_IF + fbMiscStatesErrorFFO( + fbArbiter:=fbArbiter, + fbFFHWO:=fbFFHWO, + sDeviceName:=sDeviceName, + bKnownState:=stPlcToEpics.nGetValue > 0, + nTransitionID:=fbMotionReadPMPSDB.astDbStateParams[0].nRequestAssertionID, + ); + + fbPerMotorFFO( + astMotionStage:=astMotionStageMax, + fbFFHWO:=fbFFHWO, + nActiveMotorCount:=nActiveMotorCount, + sDeviceName:=sDeviceName, + bMotorCountError=>, + ); + + stPMPSPlcToEpics.stTransitionDb := fbMotionReadPMPSDB.astDbStateParams[0]; + stDbStateParams := fbMotionReadPMPSDB.astDbStateParams[stPlcToEpics.nGetValue]; + + END_FUNCTION_BLOCK + + +Related: + * `E_StatePMPSStatus`_ + * `FB_MiscStatesErrorFFO`_ + * `FB_MotionBPTM`_ + * `FB_MotionClearAsserts`_ + * `FB_MotionReadPMPSDBND`_ + * `FB_PerMotorFFOND`_ + * `FB_PositionStatePMPS1D`_ + * `FB_PositionStatePMPS2D`_ + * `FB_StatePMPSEnablesND`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + * `ST_StateEpicsToPlc`_ + * `ST_StatePMPSEpicsToPlc`_ + * `ST_StatePMPSPlcToEpics`_ + * `ST_StatePlcToEpics`_ + + +FB_PositionStatePMPSND_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStatePMPSND_Test EXTENDS FB_MotorTestSuite + (* + Sanity checks for the following: + - FB_PositionStatePMPS1D + - FB_PositionStatePMPS2D + - FB_PositionStatePMPS3D + The internals have already been tested, but we need to make sure that + they've been put together at least somewhat sensibly. + This FB will simply use each FB to move and check the results. + In addition to reaching the goals, we need to check the beam assertions + and the pmps limit enables. + *) + VAR + stMotionStage1: ST_MotionStage; + stMotionStage2: ST_MotionStage; + stMotionStage3: ST_MotionStage; + astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astPositionState3: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + afbInternal: ARRAY[1..3] OF ARRAY[1..3] OF FB_PositionStateInternal; + afbMotionStage: ARRAY[1..3] OF FB_MotionStage; + + astBeam: ARRAY[0..3] OF ST_DbStateParams; + + fb_Move1D: FB_PositionStatePMPS1D; + fb_Move2D: FB_PositionStatePMPS2D; + fb_Move3D: FB_PositionStatePMPS3D; + + nTestCounter: UINT; + bOneTestDone: BOOL; + fTestStartPos: LREAL; + tonTimer: TON; + nIter: DINT; + bStatesReady: BOOL; + + eSetPos: E_TestStates; + eGetPos: E_TestStates; + + fbArbiter1D: FB_Arbiter(1); + fbArbiter2D: FB_Arbiter(2); + fbArbiter3D: FB_Arbiter(3); + + fbSubSysIO1D: FB_DummyArbIO; + fbSubSysIO2D: FB_DummyArbIO; + fbSubSysIO3D: FB_DummyArbIO; + + jsonHelper: FB_PMPSJsonTestHelper; + END_VAR + bStatesReady := TRUE; + FOR nIter := 1 TO 3 DO; + astPositionState1[nIter].fPosition := nIter; + astPositionState1[nIter].fDelta := 0.5; + astPositionState1[nIter].fVelocity := 100; + SetGoodState(astPositionState1[nIter]); + astPositionState2[nIter].fPosition := 10 + nIter; + astPositionState2[nIter].fDelta := 0.5; + astPositionState2[nIter].fVelocity := 100; + SetGoodState(astPositionState2[nIter]); + astPositionState3[nIter].fPosition := 20 + nIter; + astPositionState3[nIter].fDelta := 0.5; + astPositionState3[nIter].fVelocity := 100; + SetGoodState(astPositionState3[nIter]); + afbInternal[nIter][1]( + stMotionStage:=stMotionStage1, + stPositionState:=astPositionState1[nIter], + ); + afbInternal[nIter][2]( + stMotionStage:=stMotionStage2, + stPositionState:=astPositionState2[nIter], + ); + afbInternal[nIter][3]( + stMotionStage:=stMotionStage3, + stPositionState:=astPositionState3[nIter], + ); + bStatesReady := bStatesReady AND astPositionState1[nIter].bUpdated; + bStatesReady := bStatesReady AND astPositionState2[nIter].bUpdated; + bStatesReady := bStatesReady AND astPositionState3[nIter].bUpdated; + END_FOR + SetEnablesPMPS(stMotionStage1); + SetEnablesPMPS(stMotionStage2); + SetEnablesPMPS(stMotionStage3); + IF nTestCounter <= 3 THEN + // Startup tests, make sure the motor is enabled so we can inspect MC_Power's output + // Otherwise we can't snoop on the PlcToNc control DWORD since this is all 0's if disabled + // When enabled, some of the other bits go to 1 to represent directional enables + stMotionStage1.nEnableMode := E_StageEnableMode.ALWAYS; + stMotionStage2.nEnableMode := E_StageEnableMode.ALWAYS; + stMotionStage3.nEnableMode := E_StageEnableMode.ALWAYS; + ELSE + // Otherwise, make sure the most complicated mode (and the default) works + stMotionStage1.nEnableMode := E_StageEnableMode.DURING_MOTION; + stMotionStage2.nEnableMode := E_StageEnableMode.DURING_MOTION; + stMotionStage3.nEnableMode := E_StageEnableMode.DURING_MOTION; + END_IF + afbMotionStage[1](stMotionStage:=stMotionStage1); + afbMotionStage[2](stMotionStage:=stMotionStage2); + afbMotionStage[3](stMotionStage:=stMotionStage3); + + astBeam[E_TestStates.Unknown].stBeamParams := PMPS_GVL.cst0RateBeam; + astBeam[E_TestStates.Unknown].nRequestAssertionID := 1; + astBeam[E_TestStates.Unknown].sPmpsState := 'trans'; + astBeam[E_TestStates.OUT].stBeamParams := PMPS_GVL.cstFullBeam; + astBeam[E_TestStates.OUT].nRequestAssertionID := 2; + astBeam[E_TestStates.OUT].sPmpsState := 'out'; + astBeam[E_TestStates.TARGET1].stBeamParams := PMPS_GVL.cstFullBeam; + astBeam[E_TestStates.TARGET1].stBeamParams.nTran := 0.1; + astBeam[E_TestStates.TARGET1].nRequestAssertionID := 3; + astBeam[E_TestStates.TARGET1].sPmpsState := 'target1'; + astBeam[E_TestStates.TARGET2].stBeamParams := PMPS_GVL.cstFullBeam; + astBeam[E_TestStates.TARGET2].stBeamParams.nTran := 0.01; + astBeam[E_TestStates.TARGET2].nRequestAssertionID := 4; + astBeam[E_TestStates.TARGET2].sPmpsState := 'target2'; + + // Assign beam params to states 1 + astPositionState1[E_TestStates.OUT].stPMPS := astBeam[E_TestStates.OUT]; + astPositionState1[E_TestStates.TARGET1].stPMPS := astBeam[E_TestStates.TARGET1]; + astPositionState1[E_TestStates.TARGET2].stPMPS := astBeam[E_TestStates.TARGET2]; + + // Set some names for maybe help in debug + astPositionState1[E_TestStates.OUT].sName := 'OUT'; + astPositionState1[E_TestStates.TARGET1].sName := 'TARGET1'; + astPositionState1[E_TestStates.TARGET2].sName := 'TARGET2'; + astPositionState2[E_TestStates.OUT].sName := 'OUT'; + astPositionState2[E_TestStates.TARGET1].sName := 'TARGET1'; + astPositionState2[E_TestStates.TARGET2].sName := 'TARGET2'; + astPositionState3[E_TestStates.OUT].sName := 'OUT'; + astPositionState3[E_TestStates.TARGET1].sName := 'TARGET1'; + astPositionState3[E_TestStates.TARGET2].sName := 'TARGET2'; + + // Load a fake json doc to be consumed by our FB + jsonHelper( + astBeamParams:=astBeam, + bExecute:=TRUE, + sDevName:='test', + ); + + IF bStatesReady AND nTestCounter = 0 THEN + // Don't run any tests until the states are ready + nTestCounter := 1; + END_IF + + TestStartup1D(1); + TestStartup2D(2); + TestStartup3D(3); + Test1D(4, E_TestStates.OUT); + Test1D(5, E_TestStates.TARGET1); + Test1D(6, E_TestStates.TARGET2); + Test2D(7, E_TestStates.OUT); + Test2D(8, E_TestStates.TARGET1); + Test2D(9, E_TestStates.TARGET2); + Test3D(10, E_TestStates.OUT); + Test3D(11, E_TestStates.TARGET1); + Test3D(12, E_TestStates.TARGET2); + + IF bOneTestDone THEN + bOneTestDone := FALSE; + nTestCounter := nTestCounter + 1; + tonTimer(IN:=FALSE); + END_IF + // Use this timer to time out any tests that stall + tonTimer( + IN:=bStatesReady, + PT:=T#5s, + ); + + END_FUNCTION_BLOCK + + METHOD AssertMotionLims: BOOL + VAR_IN_OUT + stMotionStage: ST_MotionStage; + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + VAR_INPUT + eState: E_TestStates; + sID: STRING; + END_VAR + VAR + nExpected: DWORD; + END_VAR + IF F_AtPositionState(stMotionStage, astPositionState[eState]) THEN + // Both allowed + nExpected := 2#111; + ELSIF stMotionStage.stAxisStatus.fActPosition < astPositionState[eState].fPosition THEN + // Only + allowed + nExpected := 2#011; + ELSE + // Only - allowed + nExpected := 2#101; + END_IF + + IF stMotionStage.Axis.PlcToNc.ControlDWord > 0 THEN + AssertEquals_DWORD( + Expected:=nExpected, + Actual:=stMotionStage.Axis.PlcToNc.ControlDWord, + Message:=CONCAT('Wrong control dword in test ', sID), + ); + AssertMotionLims := TRUE; + END_IF + END_METHOD + + METHOD Test1D + VAR_INPUT + nTestID: UINT; + eState: E_TestStates; + END_VAR + VAR_INST + fbFFHWO: FB_HardwareFFOutput; + bInit: BOOL; + bLimAsserted: BOOL; + END_VAR + TEST(CONCAT('Test1D_state', UINT_TO_STRING(eState))); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + IF NOT bInit THEN + eSetPos := eState; + END_IF + + fbSubSysIO1D( + LA:=fbArbiter1D, + FFO:=fbFFHWO, + ); + + fb_Move1D( + stMotionStage:=stMotionStage1, + astPositionState:=astPositionState1, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter1D, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + bReadDBNow:=NOT bInit, + sDeviceName:='test', + sTransitionKey:='trans', + ); + + // When ready: check that directonal enables are correct + bLimAsserted S= AssertMotionLims(stMotionStage1, astPositionState1, eState, CONCAT('1D mot 1 state ', UINT_TO_STRING(eState))); + + + IF NOT bInit THEN + bInit := TRUE; + END_IF + + IF tonTimer.Q OR fb_Move1D.stPlcToEpics.bDone THEN + AssertTrue( + bLimAsserted, + 'Skipped limit assert test', + ); + AssertTrue( + Condition:=fb_Move1D.stPlcToEpics.bDone, + Message:='Done should be True after move', + ); + AssertFalse( + Condition:=fb_Move1D.stPlcToEpics.bBusy, + Message:='Busy should be False after move', + ); + AssertFalse( + Condition:=fb_Move1D.stPlcToEpics.bError, + Message:='Error should be False after move', + ); + AssertEquals_UINT( + Expected:=eState, + Actual:=eGetPos, + Message:='Did not get to the input state', + ); + AssertEquals_LREAL( + Expected:=astPositionState1[eState].fPosition, + Actual:=stMotionStage1.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position', + ); + AssertTrue( + fbArbiter1D.CheckRequestInPool(astBeam[eState].nRequestAssertionID), + 'Destination bp should have been in the arbiter', + ); + fb_Move1D.stEpicsToPlc.bReset := TRUE; + fb_Move1D( + stMotionStage:=stMotionStage1, + astPositionState:=astPositionState1, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter1D, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + ); + bInit := FALSE; + bLimAsserted := FALSE; + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD Test2D + VAR_INPUT + nTestID: UINT; + eState: E_TestStates; + END_VAR + VAR_INST + fbFFHWO: FB_HardwareFFOutput; + bInit: BOOL; + bLimAsserted1: BOOL; + bLimAsserted2: BOOL; + END_VAR + TEST(CONCAT('Test2D_state', UINT_TO_STRING(eState))); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + IF NOT bInit THEN + eSetPos := eState; + END_IF + + fbSubSysIO2D( + LA:=fbArbiter2D, + FFO:=fbFFHWO, + ); + + fb_Move2D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter2D, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + bReadDBNow:=NOT bInit, + sDeviceName:='test', + sTransitionKey:='trans', + ); + + // When ready: check that directonal enables are correct + bLimAsserted1 S= AssertMotionLims(stMotionStage1, astPositionState1, eState, CONCAT('2D mot 1 state ', UINT_TO_STRING(eState))); + bLimAsserted2 S= AssertMotionLims(stMotionStage2, astPositionState2, eState, CONCAT('2D mot 2 state ', UINT_TO_STRING(eState))); + + IF NOT bInit THEN + bInit := TRUE; + END_IF + + IF tonTimer.Q OR fb_Move2D.stPlcToEpics.bDone THEN + AssertTrue( + bLimAsserted1 AND bLimAsserted2, + 'Skipped limit assert test', + ); + AssertTrue( + Condition:=fb_Move2D.stPlcToEpics.bDone, + Message:='Done should be True after move', + ); + AssertFalse( + Condition:=fb_Move2D.stPlcToEpics.bBusy, + Message:='Busy should be False after move', + ); + AssertFalse( + Condition:=fb_Move2D.stPlcToEpics.bError, + Message:='Error should be False after move', + ); + AssertEquals_UINT( + Expected:=eState, + Actual:=eGetPos, + Message:='Did not get to the input state', + ); + AssertEquals_LREAL( + Expected:=astPositionState1[eState].fPosition, + Actual:=stMotionStage1.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position', + ); + AssertEquals_LREAL( + Expected:=astPositionState2[eState].fPosition, + Actual:=stMotionStage2.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position', + ); + AssertTrue( + fbArbiter2D.CheckRequestInPool(astBeam[eState].nRequestAssertionID), + 'Destination bp should have been in the arbiter', + ); + fb_Move2D.stEpicsToPlc.bReset := TRUE; + fb_Move2D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter2D, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + ); + bInit := FALSE; + bLimAsserted1 := FALSE; + bLimAsserted2 := FALSE; + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD Test3D + VAR_INPUT + nTestID: UINT; + eState: E_TestStates; + END_VAR + VAR_INST + fbFFHWO: FB_HardwareFFOutput; + bInit: BOOL; + bLimAsserted1: BOOL; + bLimAsserted2: BOOL; + bLimAsserted3: BOOL; + END_VAR + TEST(CONCAT('Test3D_state', UINT_TO_STRING(eState))); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + IF NOT bInit THEN + eSetPos := eState; + END_IF + + fbSubSysIO3D( + LA:=fbArbiter3D, + FFO:=fbFFHWO, + ); + + fb_Move3D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + stMotionStage3:=stMotionStage3, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + astPositionState3:=astPositionState3, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter3D, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + bReadDBNow:=NOT bInit, + sDeviceName:='test', + sTransitionKey:='trans', + ); + + // When ready: check that directonal enables are correct + bLimAsserted1 S= AssertMotionLims(stMotionStage1, astPositionState1, eState, CONCAT('3D mot 1 state ', UINT_TO_STRING(eState))); + bLimAsserted2 S= AssertMotionLims(stMotionStage2, astPositionState2, eState, CONCAT('3D mot 2 state ', UINT_TO_STRING(eState))); + bLimAsserted3 S= AssertMotionLims(stMotionStage3, astPositionState3, eState, CONCAT('3D mot 3 state ', UINT_TO_STRING(eState))); + + IF NOT bInit THEN + bInit := TRUE; + END_IF + + IF tonTimer.Q OR fb_Move3D.stPlcToEpics.bDone THEN + AssertTrue( + bLimAsserted1 AND bLimAsserted2 AND bLimAsserted3, + 'Skipped limit assert test', + ); + AssertTrue( + Condition:=fb_Move3D.stPlcToEpics.bDone, + Message:='Done should be True after move', + ); + AssertFalse( + Condition:=fb_Move3D.stPlcToEpics.bBusy, + Message:='Busy should be False after move', + ); + AssertFalse( + Condition:=fb_Move3D.stPlcToEpics.bError, + Message:='Error should be False after move', + ); + AssertEquals_UINT( + Expected:=eState, + Actual:=eGetPos, + Message:='Did not get to the input state', + ); + AssertEquals_LREAL( + Expected:=astPositionState1[eState].fPosition, + Actual:=stMotionStage1.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position', + ); + AssertEquals_LREAL( + Expected:=astPositionState2[eState].fPosition, + Actual:=stMotionStage2.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position', + ); + AssertEquals_LREAL( + Expected:=astPositionState3[eState].fPosition, + Actual:=stMotionStage3.stAxisStatus.fActPosition, + Delta:=0.1, + Message:='Did not get to the input state position', + ); + AssertTrue( + fbArbiter3D.CheckRequestInPool(astBeam[eState].nRequestAssertionID), + 'Destination bp should have been in the arbiter', + ); + fb_Move3D.stEpicsToPlc.bReset := TRUE; + fb_Move3D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + stMotionStage3:=stMotionStage3, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + astPositionState3:=astPositionState3, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter3D, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + ); + bInit := FALSE; + bLimAsserted1 := FALSE; + bLimAsserted2 := FALSE; + bLimAsserted3 := FALSE; + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestStartup1D + (* + - On startup, there should be no move request + - In this case, we start in an unknown state since (0, 0, 0) is not matching any state for any motor + - Movement should be free but the transition assertion must be active + *) + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbFFHWO: FB_HardwareFFOutput; + bInit: BOOL; + END_VAR + TEST('TestStartup1D'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + fb_Move1D( + stMotionStage:=stMotionStage1, + astPositionState:=astPositionState1, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter1D, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + bReadDBNow:=NOT bInit, + sDeviceName:='test', + sTransitionKey:='trans', + ); + + bInit := TRUE; + + // We sit in this fb for some timeout number of seconds on purpose, not an error + IF tonTimer.Q THEN + // We should neither be busy nor done (we didn't do anything) + AssertFalse( + Condition:=fb_Move1D.stPlcToEpics.bDone, + Message:='Done should be False with no move', + ); + AssertFalse( + Condition:=fb_Move1D.stPlcToEpics.bBusy, + Message:='Busy should be False with no move', + ); + // We should still be at 0,0,0 + AssertEquals_LREAL( + Expected:=0, + Actual:=stMotionStage1.stAxisStatus.fActPosition, + Delta:=0.0001, + Message:='Why did we move? motor1 should have default position', + ); + // We should be able to move both directions, which is control word 7 (2#111) + AssertEquals_DWORD( + Expected:=2#111, + Actual:=stMotionStage1.Axis.PlcToNc.ControlDWord, + Message:='Expected full +/- enables', + ); + AssertTrue( + fbArbiter1D.CheckRequestInPool(astBeam[E_TestStates.Unknown].nRequestAssertionID), + 'Transition assertion ID not in pool', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestStartup2D + (* + - On startup, there should be no move request + - Starting from (0, 0, 0) all motors should only be allowed to move + + *) + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbFFHWO: FB_HardwareFFOutput; + bInit: BOOL; + END_VAR + TEST('TestStartup2D'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + fb_Move2D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter2D, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + bReadDBNow:=NOT bInit, + sDeviceName:='test', + sTransitionKey:='trans', + ); + + bInit := TRUE; + + // We sit in this fb for some timeout number of seconds on purpose, not an error + IF tonTimer.Q THEN + // We should neither be busy nor done (we didn't do anything) + AssertFalse( + Condition:=fb_Move2D.stPlcToEpics.bDone, + Message:='Done should be False with no move', + ); + AssertFalse( + Condition:=fb_Move2D.stPlcToEpics.bBusy, + Message:='Busy should be False with no move', + ); + // We should still be at 0,0,0 + AssertEquals_LREAL( + Expected:=0, + Actual:=stMotionStage1.stAxisStatus.fActPosition, + Delta:=0.0001, + Message:='Why did we move? motor1 should have default position', + ); + AssertEquals_LREAL( + Expected:=0, + Actual:=stMotionStage2.stAxisStatus.fActPosition, + Delta:=0.0001, + Message:='Why did we move? motor2 should have default position', + ); + // We should be able to move both directions, which is control word 7 (2#111) + AssertEquals_DWORD( + Expected:=2#111, + Actual:=stMotionStage1.Axis.PlcToNc.ControlDWord, + Message:='Expected full +/- enables', + ); + AssertEquals_DWORD( + Expected:=2#111, + Actual:=stMotionStage2.Axis.PlcToNc.ControlDWord, + Message:='Expected full +/- enables', + ); + AssertTrue( + fbArbiter2D.CheckRequestInPool(astBeam[E_TestStates.Unknown].nRequestAssertionID), + 'Transition assertion ID not in pool', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestStartup3D + (* + - On startup, there should be no move request + - Starting from (0, 0, 0) all motors should only be allowed to move + + *) + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbFFHWO: FB_HardwareFFOutput; + bInit: BOOL; + END_VAR + TEST('TestStartup3D'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + fb_Move3D( + stMotionStage1:=stMotionStage1, + stMotionStage2:=stMotionStage2, + stMotionStage3:=stMotionStage3, + astPositionState1:=astPositionState1, + astPositionState2:=astPositionState2, + astPositionState3:=astPositionState3, + eEnumSet:=eSetPos, + eEnumGet:=eGetPos, + fbFFHWO:=fbFFHWO, + fbArbiter:=fbArbiter3D, + bEnableMotion:=TRUE, + bEnableBeamParams:=TRUE, + bEnablePositionLimits:=TRUE, + bReadDBNow:=NOT bInit, + sDeviceName:='test', + sTransitionKey:='trans', + ); + + bInit := TRUE; + + // We sit in this fb for some timeout number of seconds on purpose, not an error + IF tonTimer.Q THEN + // We should neither be busy nor done (we didn't do anything) + AssertFalse( + Condition:=fb_Move3D.stPlcToEpics.bDone, + Message:='Done should be False with no move', + ); + AssertFalse( + Condition:=fb_Move3D.stPlcToEpics.bBusy, + Message:='Busy should be False with no move', + ); + // We should still be at 0,0,0 + AssertEquals_LREAL( + Expected:=0, + Actual:=stMotionStage1.stAxisStatus.fActPosition, + Delta:=0.0001, + Message:='Why did we move? motor1 should have default position', + ); + AssertEquals_LREAL( + Expected:=0, + Actual:=stMotionStage2.stAxisStatus.fActPosition, + Delta:=0.0001, + Message:='Why did we move? motor2 should have default position', + ); + AssertEquals_LREAL( + Expected:=0, + Actual:=stMotionStage3.stAxisStatus.fActPosition, + Delta:=0.0001, + Message:='Why did we move? motor3 should have default position', + ); + // We should be able to move both directions, which is control word 7 (2#111) + AssertEquals_DWORD( + Expected:=2#111, + Actual:=stMotionStage1.Axis.PlcToNc.ControlDWord, + Message:='Expected full +/- enables', + ); + AssertEquals_DWORD( + Expected:=2#111, + Actual:=stMotionStage2.Axis.PlcToNc.ControlDWord, + Message:='Expected full +/- enables', + ); + AssertEquals_DWORD( + Expected:=2#111, + Actual:=stMotionStage3.Axis.PlcToNc.ControlDWord, + Message:='Expected full +/- enables', + ); + AssertTrue( + fbArbiter3D.CheckRequestInPool(astBeam[E_TestStates.Unknown].nRequestAssertionID), + 'Transition assertion ID not in pool', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + +Related: + * `E_StageEnableMode`_ + * `E_TestStates`_ + * `FB_MotionStage`_ + * `FB_MotorTestSuite`_ + * `FB_PMPSJsonTestHelper`_ + * `FB_PositionStateInternal`_ + * `FB_PositionStatePMPS1D`_ + * `FB_PositionStatePMPS2D`_ + * `FB_PositionStatePMPS3D`_ + * `F_AtPositionState`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateRead +^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateRead + (* + This function block tells us what state a single motor is at. + In the case of multiple valid overlapping states, one will be picked arbitrarily, + but we can see a full description of which overlapping states are present using the abAtPosition array. + + This will only run properly if FB_PositionStateInternal has been called on each position state to initialize it. + *) + VAR_IN_OUT + // The motor to check the state of + stMotionStage: ST_MotionStage; + // The allowed states for this motor + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + VAR_OUTPUT + // TRUE if we're standing still at a known state, or moving within the bounds of a state to another location in the bounds. + bKnownState: BOOL; + // TRUE if we're moving to some other state or to another non-state position. + bMovingState: BOOL; + // If we're at a known state, this will be the index in the astPositionState array that matches the state. Otherwise, this will be 0, which is below the bounds of the array, so it cannot be confused with a valid output. + nPositionIndex: UINT; + // A copy of the details of the current position state, for convenience. This may be a moving state or an unknown state as a placeholder if we are not at a known state. + stCurrentPosition: ST_PositionState; + // A full description of whether we're at each of our states. This is used in 2D, 3D, etc. to clarify cases where states may overlap in 1D. + abAtPosition: ARRAY[1..GeneralConstants.MAX_STATES] OF BOOL; + END_VAR + VAR + nIter: UINT; + END_VAR + bKnownState := FALSE; + bMovingState := FALSE; + + FOR nIter := 1 TO GeneralConstants.MAX_STATES DO + IF astPositionState[nIter].bValid THEN + MOTION_GVL.nMaxStates := MAX(MOTION_GVL.nMaxStates, nIter); + END_IF + IF F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=astPositionState[nIter]) THEN + bKnownState := TRUE; + nPositionIndex := nIter; + stCurrentPosition := astPositionState[nIter]; + abAtPosition[nIter] := TRUE; + ELSE + abAtPosition[nIter] := FALSE; + END_IF + END_FOR + + IF NOT bKnownState THEN + nPositionIndex := 0; + stCurrentPosition.fPosition := stMotionStage.stAxisStatus.fActPosition; + stCurrentPosition.fDelta := 0; + stCurrentPosition.bMoveOk := FALSE; + stCurrentPosition.bValid := FALSE; + stCurrentPosition.bUseRawCounts := FALSE; + + bMovingState := stMotionStage.bExecute; + IF bMovingState THEN + stCurrentPosition.sName := 'Moving'; + stCurrentPosition.fVelocity := stMotionStage.fVelocity; + stCurrentPosition.fAccel := stMotionStage.fAcceleration; + ELSE + stCurrentPosition.sName := 'Unknown'; + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `FB_PositionStateInternal`_ + * `F_AtPositionState`_ + * `MOTION_GVL`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateRead_Test +^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateRead_Test EXTENDS TcUnit.FB_TestSuite + (* + Test that FB_PositionStateRead works exactly how it should + according to its API during normal and failure states. + *) + VAR + stMotionStage: ST_MotionStage; + fbMotionStage: FB_MotionStage; + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + afbInternal: ARRAY[1..3] OF FB_PositionStateInternal; + stDummyPos: ST_PositionState; + fbTestMove: FB_TestHelperSetAndMove; + fbRead: FB_PositionStateRead; + + nTestCounter: UINT; + bOneTestDone: BOOL; + fTestStartPos: LREAL; + tonTimer: TON; + nIter: DINT; + bStatesReady: BOOL; + END_VAR + astPositionState[1].sName := 'UNO'; + astPositionState[1].fPosition := 10; + astPositionState[1].fDelta := 1; + astPositionState[1].bValid := TRUE; + astPositionState[1].bUseRawCounts := FALSE; + + astPositionState[2].sName := 'DOS'; + astPositionState[2].fPosition := 20; + astPositionState[2].fDelta := 1; + astPositionState[2].bValid := FALSE; + astPositionState[2].bUseRawCounts := FALSE; + + astPositionState[3].sName := 'TRES'; + astPositionState[3].fPosition := 30; + astPositionState[3].fDelta := 1; + astPositionState[3].bValid := TRUE; + astPositionState[3].bUseRawCounts := FALSE; + + astPositionState[4].sName := 'QUATRO'; + astPositionState[4].fPosition := 30; + astPositionState[4].fDelta := 1; + astPositionState[4].bValid := FALSE; + astPositionState[4].bUseRawCounts := FALSE; + + bStatesReady := TRUE; + FOR nIter := 1 TO 4 DO + afbInternal[nIter]( + stMotionStage:=stMotionStage, + stPositionState:=astPositionState[nIter], + ); + bStatesReady := bStatesReady AND astPositionState[nIter].bUpdated; + END_FOR + fbMotionStage(stMotionStage:=stMotionStage); + + // At position 1 check + TestStaticPosition( + nTestIndex:=0, + sTestName:='AtPos1', + fPosition:=astPositionState[1].fPosition + 0.2 * astPositionState[1].fDelta, + bKnownState:=TRUE, + bMovingState:=FALSE, + nPositionIndex:=1, + stCurrentPosition:=astPositionState[1], + ); + // Outside the deltas check + TestStaticPosition( + nTestIndex:=1, + sTestName:='OutsidePos1Delta', + fPosition:=astPositionState[1].fPosition + 2 * astPositionState[1].fDelta, + bKnownState:=FALSE, + bMovingState:=FALSE, + nPositionIndex:=0, + stCurrentPosition:=stDummyPos, + ); + // At invalid state 2 check + TestStaticPosition( + nTestIndex:=2, + sTestName:='AtInvalidPos', + fPosition:=astPositionState[2].fPosition, + bKnownState:=FALSE, + bMovingState:=FALSE, + nPositionIndex:=0, + stCurrentPosition:=stDummyPos, + ); + // At position 3 check + TestStaticPosition( + nTestIndex:=3, + sTestName:='AtPos3', + fPosition:=astPositionState[3].fPosition - 0.5 * astPositionState[3].fDelta, + bKnownState:=TRUE, + bMovingState:=FALSE, + nPositionIndex:=3, + stCurrentPosition:=astPositionState[3], + ); + // At position 3 and moving within bounds check + TestMovingPosition( + nTestIndex:=4, + sTestName:='MovingAt3', + fStartPosition:=astPositionState[3].fPosition, + fGoalPosition:=astPositionState[3].fPosition + 0.9 * astPositionState[3].fDelta, + fVelocity:=0.001, + bKnownState:=TRUE, + bMovingState:=FALSE, + nPositionIndex:=3, + stCurrentPosition:=astPositionState[3], + ); + // At position 3 and moving away check + TestMovingPosition( + nTestIndex:=5, + sTestName:='MovingFrom3', + fStartPosition:=astPositionState[3].fPosition, + fGoalPosition:=astPositionState[3].fPosition + 100 * astPositionState[3].fDelta, + fVelocity:=0.001, + bKnownState:=FALSE, + bMovingState:=TRUE, + nPositionIndex:=0, + stCurrentPosition:=stDummyPos, + ); + TestDupe(nTestIndex:=6); + + IF bOneTestDone THEN + bOneTestDone := FALSE; + nTestCounter := nTestCounter + 1; + fbTestMove( + stMotionStage:=stMotionStage, + bExecute:=FALSE, + ); + END_IF + + END_FUNCTION_BLOCK + + METHOD PRIVATE Asserts + VAR_INPUT + tTimeout: TIME; + bKnownState: BOOL; + bMovingState: BOOL; + nPositionIndex: DINT; + stCurrentPosition: ST_PositionState; + END_VAR + VAR + abExpected: ARRAY[1..GeneralConstants.MAX_STATES] OF BOOL; + END_VAR + fbRead( + stMotionStage:=stMotionStage, + astPositionState:=astPositionstate, + ); + + AssertEquals_BOOL( + Expected:=FALSE, + Actual:=fbTestMove.tElapsed > tTimeout, + Message:='Test timed out', + ); + AssertEquals_BOOL( + Expected:=bKnownState, + Actual:=fbRead.bKnownState, + Message:='Incorrect bKnownState', + ); + AssertEquals_BOOL( + Expected:=bMovingState, + Actual:=fbRead.bMovingState, + Message:='Incorrect bMovingState', + ); + AssertEquals_DINT( + Expected:=nPositionIndex, + Actual:=fbRead.nPositionIndex, + Message:='Incorrect nPositionIndex', + ); + IF nPositionIndex > 0 THEN + IF nPositionIndex <= GeneralConstants.MAX_STATES THEN + abExpected[nPositionIndex] := TRUE; + END_IF + END_IF + AssertArrayEquals_BOOL( + Expecteds:=abExpected, + Actuals:=fbRead.abAtPosition, + Message:='Wrong at position array', + ); + + IF bKnownState THEN + AssertEquals_STRING( + Expected:=stCurrentPosition.sName, + Actual:=fbRead.stCurrentPosition.sName, + Message:='Did not provide correct current position struct', + ); + END_IF + END_METHOD + + METHOD TestDupe + VAR_INPUT + nTestIndex: DINT; + END_VAR + VAR + abExpected: ARRAY[1..GeneralConstants.MAX_STATES] OF BOOL; + END_VAR + TEST('TestDupe'); + IF nTestIndex <> nTestCounter THEN + RETURN; + END_IF + + // In this test, and only in this test, we must make sure state 4 is valid + astPositionState[4].bValid := TRUE; + + fbTestMove( + stMotionStage:=stMotionStage, + bExecute:=TRUE, + fStartPosition:=astPositionState[4].fPosition, + fGoalPosition:=astPositionState[4].fPosition, + ); + abExpected[3] := TRUE; + abExpected[4] := TRUE; + + IF fbTestMove.tElapsed > T#1s OR (fbTestMove.bSetDone AND bStatesReady) THEN + fbRead( + stMotionStage:=stMotionStage, + astPositionState:=astPositionstate, + ); + AssertEquals_BOOL( + Expected:=FALSE, + Actual:=fbTestMove.tElapsed > T#1s, + Message:='Test timed out', + ); + AssertEquals_BOOL( + Expected:=TRUE, + Actual:=fbRead.bKnownState, + Message:='Incorrect bKnownState', + ); + AssertArrayEquals_BOOL( + Expecteds:=abExpected, + Actuals:=fbRead.abAtPosition, + Message:='Wrong at position array', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD PRIVATE TestMovingPosition + VAR_INPUT + nTestIndex: UINT; + sTestName: STRING; + fStartPosition: LREAL; + fGoalPosition: LREAL; + fVelocity: LREAL; + bKnownState: BOOL; + bMovingState: BOOL; + nPositionIndex: DINT; + stCurrentPosition: ST_PositionState; + END_VAR + TEST(sTestName); + IF nTestIndex <> nTestCounter THEN + RETURN; + END_IF + + fbTestMove( + stMotionStage:=stMotionStage, + bExecute:=TRUE, + fStartPosition:=fStartPosition, + fGoalPosition:=fGoalPosition, + fVelocity:=0.001, + bHWEnable:=TRUE, + ); + + IF fbTestMove.tElapsed > T#5s OR (fbTestMove.bMotionStarted AND bStatesReady) THEN + Asserts( + tTimeout:=T#5s, + bKnownState:=bKnownState, + bMovingState:=bMovingState, + nPositionIndex:=nPositionIndex, + stCurrentPosition:=stCurrentPosition, + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD PRIVATE TestStaticPosition + VAR_INPUT + nTestIndex: UINT; + sTestName: STRING; + fPosition: LREAL; + bKnownState: BOOL; + bMovingState: BOOL; + nPositionIndex: DINT; + stCurrentPosition: ST_PositionState; + END_VAR + TEST(sTestName); + IF nTestIndex <> nTestCounter THEN + RETURN; + END_IF + + fbTestMove( + stMotionStage:=stMotionStage, + bExecute:=TRUE, + fStartPosition:=fPosition, + fGoalPosition:=fPosition, + ); + + IF fbTestMove.tElapsed > T#1s OR (fbTestMove.bSetDone AND bStatesReady) THEN + Asserts( + tTimeout:=T#1s, + bKnownState:=bKnownState, + bMovingState:=bMovingState, + nPositionIndex:=nPositionIndex, + stCurrentPosition:=stCurrentPosition, + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + +Related: + * `FB_MotionStage`_ + * `FB_PositionStateInternal`_ + * `FB_PositionStateRead`_ + * `FB_TestHelperSetAndMove`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateReadND +^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateReadND + (* + Function block to get the combined N-dimensional state of a group of motors. + It is a building block not meant for use outside of lcls-twintcat-motion. + + Use FB_PositionStateRead1D, FB_PositionStateRead2D, ... etc. instead + *) + VAR_IN_OUT + // The motors with a combined N-dimensional state + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + // Each motor's respective position states along its direction + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + VAR_INPUT + // The number of motors we're actually using + nActiveMotorCount: UINT; + END_VAR + VAR_OUTPUT + // TRUE if we're standing still at a known state. + bKnownState: BOOL; + // TRUE if we're moving, there can be no valid state if we are moving. + bMovingState: BOOL; + // If we're at a known state, this will be the state index along the enclosed states arrays. Otherwise, it will be zero, which is below the bounds of the states array. + nPositionIndex: UINT; + // TRUE if the active motor count was invalid + bMotorCountError: BOOL; + // A full description of whether we're at each of our states. This is used to clarify cases where states may overlap. + abAtPosition: ARRAY[1..GeneralConstants.MAX_STATES] OF BOOL; + END_VAR + VAR + // The individual position state reader function blocks + afbPositionStateRead: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF FB_PositionStateRead; + + nIter: UINT; + nIter2: UINT; + END_VAR + CheckCount(); + IF NOT bMotorCountError THEN + DoStateReads(); + CombineOutputs(); + END_IF + + END_FUNCTION_BLOCK + + ACTION CheckCount: + // Make sure the motor count is valid (positive, nonzero, less or equal to the max) + bMotorCountError S= nActiveMotorCount <= 0; + bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS; + END_ACTION + + ACTION CombineOutputs: + // bKnownState is TRUE if ALL motors have the same known state + bKnownState := TRUE; + FOR nIter := 1 TO nActiveMotorCount DO + bKnownState := bKnownState AND afbPositionStateRead[nIter].bKnownState; + END_FOR + + // bMovingState is TRUE if ANY motor is moving + bMovingState := FALSE; + FOR nIter := 1 TO nActiveMotorCount DO + bMovingState := bMovingState OR afbPositionStateRead[nIter].bMovingState; + END_FOR + + // To account for redundant 1D states, we need to check the full output arrays. + nPositionIndex := 0; + FOR nIter := 1 TO GeneralConstants.MAX_STATES DO + abAtPosition[nIter] := TRUE; + FOR nIter2 := 1 TO nActiveMotorCount DO + abAtPosition[nIter] R= NOT afbPositionStateRead[nIter2].abAtPosition[nIter]; + END_FOR + IF abAtPosition[nIter] THEN + nPositionIndex := nIter; + END_IF + END_FOR + + // Position index 0 means different positions + bKnownState := bKnownState AND nPositionIndex <> 0; + END_ACTION + + ACTION DoStateReads: + MOTION_GVL.nMaxStateMotorCount := MAX(MOTION_GVL.nMaxStateMotorCount, nActiveMotorCount); + FOR nIter := 1 TO nActiveMotorCount DO + afbPositionStateRead[nIter]( + stMotionStage:=astMotionStage[nIter], + astPositionState:=astPositionState[nIter], + ); + END_FOR + END_ACTION + + +Related: + * `FB_PositionStateRead`_ + * `MOTION_GVL`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_PositionStateReadND_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_PositionStateReadND_Test EXTENDS FB_MotorTestSuite + (* + Test that FB_PositionStateReadND can be used to read and summarize + N-dimensional state positions where multiple motors must move in + sync to a shared named state. + *) + VAR + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + afbMotionStage: ARRAY[1..3] OF FB_MotionStage; + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY [1..GeneralConstants.MAX_STATES] OF ST_PositionState; + afbInternal: ARRAY[1..3] OF ARRAY [1..2] OF FB_PositionStateInternal; + + afbTestMove: ARRAY[1..3] OF FB_TestHelperSetAndMove; + fbRead: FB_PositionStateReadND; + bOneAssertDone: BOOL; + nAssertCounter: UINT; + nIter1: UINT; + nIter2: UINT; + nIter3: UINT; + + fbMisRead: FB_PositionStateReadND; + astGoodStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + astGoodStateShape: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY [1..GeneralConstants.MAX_STATES] OF ST_PositionState; + + astSqMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + afbSqMotionStage: ARRAY[1..2] OF FB_MotionStage; + astSquareStates: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY [1..GeneralConstants.MAX_STATES] OF ST_PositionState; + afbSqInternal: ARRAY[1..2] OF ARRAY[1..4] OF FB_PositionStateInternal; + + afbSqTestMove: ARRAY[1..2] OF FB_TestHelperSetAndMove; + fbSqRead: FB_PositionStateReadND; + bSqAssertDone: BOOL; + nSqAssertCounter: UINT; + END_VAR + VAR CONSTANT + NO_STATE: UINT := 0; + OUT_STATE: UINT := 1; + IN_STATE: UINT := 2; + IN_TWEAK: UINT := 3; + AWAY: UINT := 4; + LAST_TEST: UINT := AWAY; + TEST_COUNT: UINT := 5; + END_VAR + PerMotor(1); + PerMotor(2); + PerMotor(3); + SquareSetup(); + + // First check the case of mismatched arrays + TestForgot(); + TestCombos(nAssertCounter); + TestSquare(nSqAssertCounter); + + IF bOneAssertDone THEN + afbTestMove[1]( + stMotionStage:=astMotionStage[1], + bExecute:=FALSE, + ); + afbTestMove[2]( + stMotionStage:=astMotionStage[2], + bExecute:=FALSE, + ); + afbTestMove[3]( + stMotionStage:=astMotionStage[3], + bExecute:=FALSE, + ); + IF afbTestMove[1].bResetDone AND afbTestMove[2].bResetDone AND afbTestMove[3].bResetDone THEN + bOneAssertDone := FALSE; + nAssertCounter := nAssertCounter + 1; + END_IF + END_IF + + IF bSqAssertDone THEN + afbSqTestMove[1]( + stMotionStage:=astMotionStage[1], + bExecute:=FALSE, + ); + afbSqTestMove[2]( + stMotionStage:=astMotionStage[2], + bExecute:=FALSE, + ); + IF afbSqTestMove[1].bResetDone AND afbSqTestMove[2].bResetDone THEN + bSqAssertDone := FALSE; + nSqAssertCounter := nSqAssertCounter + 1; + END_IF + END_IF + + END_FUNCTION_BLOCK + + METHOD PRIVATE DoAssert + VAR_INPUT + nMotorCase1: UINT; + nMotorCase2: UINT; + nMotorCase3: UINT; + bReady1: BOOL; + bReady2: BOOL; + bReady3: BOOL; + END_VAR + VAR + bKnownState: BOOL; + bMovingState: BOOL; + nPositionIndex: DINT; + sTestCase: STRING; + END_VAR + sTestCase := CONCAT(CONCAT(UINT_TO_STRING(nMotorCase1), UINT_TO_STRING(nMotorCase2)), UINT_TO_STRING(nMotorCase3)); + + AssertTrue( + Condition:=bReady1, + Message:=CONCAT('Timeout for motor 1 during test case ', sTestCase), + ); + AssertTrue( + Condition:=bReady2, + Message:=CONCAT('Timeout for motor 2 during test case ', sTestCase), + ); + AssertTrue( + Condition:=bReady3, + Message:=CONCAT('Timeout for motor 3 during test case ', sTestCase), + ); + + // All at OUT or all at IN should be OUT and IN respectively, even if doing a tweak move + // Any other combination is at no state + IF nMotorCase1 = OUT_STATE AND nMotorCase2 = OUT_STATE AND nMotorCase3 = OUT_STATE THEN + bKnownState := TRUE; + nPositionIndex := 1; + ELSIF (nMotorCase1 = IN_STATE OR nMotorCase1 = IN_TWEAK) AND + (nMotorCase2 = IN_STATE OR nMotorCase2 = IN_TWEAK) AND + (nMotorCase3 = IN_STATE OR nMotorCase3 = IN_TWEAK) THEN + bKnownState := TRUE; + nPositionIndex := 2; + END_IF + // In addition, bMovingState must be set if any is moving away from a state + IF nMotorCase1 = AWAY OR nMotorCase2 = AWAY OR nMotorCase3 = AWAY THEN + bMovingState := TRUE; + END_IF + + AssertEquals_BOOL( + Expected:=bKnownState, + Actual:=fbRead.bKnownState, + Message:=CONCAT('Wrong bKnownState for test case ', sTestCase), + ); + AssertEquals_BOOL( + Expected:=bMovingState, + Actual:=fbRead.bMovingState, + Message:=CONCAT('Wrong bMovingState for test case ', sTestCase), + ); + AssertEquals_DINT( + Expected:=nPositionIndex, + Actual:=fbRead.nPositionIndex, + Message:=CONCAT('Wrong nPositionIndex for test case ', sTestCase), + ); + END_METHOD + + METHOD PRIVATE DoMove: BOOL + VAR_INPUT + nMotorIndex: UINT; + nMotorCase: UINT; + END_VAR + VAR + fStartPosition: LREAL; + fGoalPosition: LREAL; + END_VAR + CASE nMotorCase OF + // Somewhere smaller than OUT, static + NO_STATE: + fStartPosition := astPositionState[nMotorIndex][1].fPosition - 10 * astPositionState[nMotorIndex][1].fDelta; + fGoalPosition := fStartPosition; + // Exactly at OUT, static + OUT_STATE: + fStartPosition := astPositionState[nMotorIndex][1].fPosition; + fGoalPosition := fStartPosition; + // Exactly at IN, static + IN_STATE: + fStartPosition := astPositionState[nMotorIndex][2].fPosition; + fGoalPosition := fStartPosition; + // Start at IN, do a small tweak + IN_TWEAK: + fStartPosition := astPositionState[nMotorIndex][2].fPosition; + fGoalPosition := fStartPosition + 0.9 * astPositionState[nMotorIndex][2].fDelta; + // Start at IN, move positive a lot + AWAY: + fStartPosition := astPositionState[nMotorIndex][2].fPosition; + fGoalPosition := fStartPosition + 100 * astPositionState[nMotorIndex][2].fDelta; + END_CASE + + afbTestMove[nMotorIndex]( + stMotionStage:=astMotionStage[nMotorIndex], + bExecute:=TRUE, + fStartPosition:=fStartPosition, + fGoalPosition:=fGoalPosition, + fVelocity:=0.001, + bHWEnable:=TRUE, + ); + + CASE nMotorCase OF + // All static states: report ready when set is done + NO_STATE: + DoMove := afbTestMove[nMotorIndex].bSetDone; + OUT_STATE: + DoMove := afbTestMove[nMotorIndex].bSetDone; + IN_STATE: + DoMove := afbTestMove[nMotorIndex].bSetDone; + // All moving states: report ready when move starts + IN_TWEAK: + DoMove := afbTestMove[nMotorIndex].bMotionStarted; + AWAY: + DoMove := afbTestMove[nMotorIndex].bMotionStarted; + END_CASE + // Universal 5s timeout + DoMove S= afbTestMove[nMotorIndex].tElapsed > T#5s; + END_METHOD + + METHOD PRIVATE DoRead + VAR_INPUT + END_VAR + fbRead( + astMotionStage:=astMotionStage, + astPositionState:=astPositionState, + nActiveMotorCount:=3, + ); + END_METHOD + + METHOD PRIVATE PerMotor : BOOL + VAR_INPUT + nIndex: DINT; + END_VAR + afbMotionStage[nIndex](stMotionStage:=astMotionStage[nIndex]); + + astPositionState[nIndex][1].sName := 'OUT'; + astPositionState[nIndex][1].fPosition := nIndex * 100 + 10; + astPositionState[nIndex][1].fDelta := 1; + astPositionState[nIndex][1].bUseRawCounts := FALSE; + SetGoodState(astPositionState[nIndex][1]); + afbInternal[nIndex][1]( + stMotionStage:=astMotionStage[nIndex], + stPositionState:=astPositionState[nIndex][1], + ); + + astPositionState[nIndex][2].sName := 'IN'; + astPositionState[nIndex][2].fPosition := nIndex * 100 + 20; + astPositionState[nIndex][2].fDelta := 1; + astPositionState[nIndex][2].bUseRawCounts := FALSE; + SetGoodState(astPositionState[nIndex][2]); + afbInternal[nIndex][2]( + stMotionStage:=astMotionStage[nIndex], + stPositionState:=astPositionState[nIndex][2], + ); + END_METHOD + + METHOD SquareSetup + VAR_INPUT + END_VAR + // 2 motors, 4 positions per motor, square geometry + // Motor 1 is X, motor 2 is Y + // Corners at (10,10), (10, 20), (20, 10), (20, 20) + // So motor 1 is either LEFT=10 or RIGHT=20 + // motor 2 is either BOT=10 or TOP=20 + + afbSqMotionStage[1](stMotionStage:=astSqMotionStage[1]); + afbSqMotionStage[2](stMotionStage:=astSqMotionStage[2]); + + astSquareStates[1][1].sName := 'Top Left'; + astSquareStates[1][1].fPosition := 10; + astSquareStates[1][1].fDelta := 1; + SetGoodState(astSquareStates[1][1]); + afbSqInternal[1][1]( + stMotionStage:=astMotionStage[1], + stPositionState:=astSquareStates[1][1], + ); + + astSquareStates[1][2].sName := 'Top Right'; + astSquareStates[1][2].fPosition := 20; + astSquareStates[1][2].fDelta := 1; + SetGoodState(astSquareStates[1][2]); + afbSqInternal[1][2]( + stMotionStage:=astMotionStage[1], + stPositionState:=astSquareStates[1][2], + ); + + astSquareStates[1][3].sName := 'Bot Left'; + astSquareStates[1][3].fPosition := 10; + astSquareStates[1][3].fDelta := 1; + SetGoodState(astSquareStates[1][3]); + afbSqInternal[1][3]( + stMotionStage:=astMotionStage[1], + stPositionState:=astSquareStates[1][3], + ); + + astSquareStates[1][4].sName := 'Bot Right'; + astSquareStates[1][4].fPosition := 20; + astSquareStates[1][4].fDelta := 1; + SetGoodState(astSquareStates[1][4]); + afbSqInternal[1][4]( + stMotionStage:=astMotionStage[1], + stPositionState:=astSquareStates[1][4], + ); + + astSquareStates[2][1].sName := 'Top Left'; + astSquareStates[2][1].fPosition := 20; + astSquareStates[2][1].fDelta := 1; + SetGoodState(astSquareStates[2][1]); + afbSqInternal[2][1]( + stMotionStage:=astMotionStage[1], + stPositionState:=astSquareStates[2][1], + ); + + astSquareStates[2][2].sName := 'Top Right'; + astSquareStates[2][2].fPosition := 20; + astSquareStates[2][2].fDelta := 1; + SetGoodState(astSquareStates[2][2]); + afbSqInternal[2][2]( + stMotionStage:=astMotionStage[1], + stPositionState:=astSquareStates[2][2], + ); + + astSquareStates[2][3].sName := 'Bot Left'; + astSquareStates[2][3].fPosition := 10; + astSquareStates[2][3].fDelta := 1; + SetGoodState(astSquareStates[2][3]); + afbSqInternal[2][3]( + stMotionStage:=astMotionStage[1], + stPositionState:=astSquareStates[2][3], + ); + + astSquareStates[2][4].sName := 'Bot Right'; + astSquareStates[2][4].fPosition := 10; + astSquareStates[2][4].fDelta := 1; + SetGoodState(astSquareStates[2][4]); + afbSqInternal[2][4]( + stMotionStage:=astMotionStage[1], + stPositionState:=astSquareStates[2][4], + ); + END_METHOD + + METHOD PRIVATE TestCombos + VAR_INPUT + nAssertID: UINT; + END_VAR + VAR + nMotor1Case: UINT; + nMotor2Case: UINT; + nMotor3Case: UINT; + bReady1: BOOL; + bReady2: BOOL; + bReady3: BOOL; + END_VAR + VAR_INST + tonTimeout: TON; + END_VAR + // This should be one big test case with 125 asserts + TEST('TestAllCombos'); + + nMotor1Case := nAssertID MOD TEST_COUNT; + nMotor2Case := LREAL_TO_UINT(FLOOR(nAssertID / TEST_COUNT)) MOD TEST_COUNT; + nMotor3Case := LREAL_TO_UINT(FLOOR(nAssertID / TEST_COUNT / TEST_COUNT)) MOD TEST_COUNT; + + bReady1 := DoMove(1, nMotor1Case); + bReady2 := DoMove(2, nMotor2Case); + bReady3 := DoMove(3, nMotor3Case); + + // There is a 5s timeout at a lower level, but that timeout could fail + tonTimeout( + IN:=TRUE, + PT:=T#7s, + ); + + IF tonTimeout.Q OR (bReady1 AND bReady2 AND bReady3) THEN + DoRead(); + DoAssert(nMotor1Case, nMotor2Case, nMotor3Case, bReady1, bReady2, bReady3); + bOneAssertDone := TRUE; + // The final assert case marks test as finished + IF tonTimeout.Q OR (nMotor1Case = LAST_TEST AND nMotor2Case = LAST_TEST AND nMotor3Case = LAST_TEST) THEN + // 11 extra tests + // 1 from TestForgot + // 10 (2*5) from TestSquare + AssertEquals_UINT( + Expected:=6 * TEST_COUNT * TEST_COUNT * TEST_COUNT + 11, + Actual:=AssertResults.TotalAsserts, + Message:='Some of the asserts were not run', + ); + AssertFalse( + tonTimeout.Q, + 'Level 2 timeout in test', + ); + TEST_FINISHED(); + END_IF + tonTimeout(IN:=FALSE); + END_IF + END_METHOD + + METHOD PRIVATE TestForgot + VAR + END_VAR + TEST('ForgotCount'); + + fbMisRead( + astMotionStage:=astGoodStage, + astPositionState:=astGoodStateShape, + ); + + AssertTrue( + Condition:=fbMisRead.bMotorCountError, + Message:='Failed to notice missing count', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TestSquare + VAR_INPUT + nAssertID: UINT; + END_VAR + VAR + fMotor1Pos: LREAL; + fMotor2Pos: LREAL; + nGoal: UINT; + END_VAR + VAR_INST + tonTimeout: TON; + END_VAR + // We'll do 5 tests, one at each square point and one more in the middle + Test('TestSquare'); + IF nAssertID > 4 THEN + RETURN; + END_IF + + IF nAssertID = 0 THEN + fMotor1Pos := 10; + fMotor2Pos := 10; + nGoal := 3; + ELSIF nAssertID = 1 THEN + fMotor1Pos := 20; + fMotor2Pos := 10; + nGoal := 4; + ELSIF nAssertID = 2 THEN + fMotor1Pos := 10; + fMotor2Pos := 20; + nGoal := 1; + ELSIF nAssertID = 3 THEN + fMotor1Pos := 20; + fMotor2Pos := 20; + nGoal := 2; + ELSIF nAssertID = 4 THEN + fMotor1Pos := 15; + fMotor2Pos := 15; + nGoal := 0; + END_IF + + afbSqTestMove[1]( + stMotionStage:=astSqMotionStage[1], + bExecute:=TRUE, + fStartPosition:=fMotor1Pos, + fGoalPosition:=fMotor1Pos, + ); + afbSqTestMove[2]( + stMotionStage:=astSqMotionStage[2], + bExecute:=TRUE, + fStartPosition:=fMotor2Pos, + fGoalPosition:=fMotor2Pos, + ); + + tonTimeout( + IN:=TRUE, + PT:=T#5s, + ); + + IF tonTimeout.Q OR afbSqTestMove[1].bSetDone AND afbSqTestMove[1].bSetDone THEN + fbSqRead( + astMotionStage:=astSqMotionStage, + astPositionState:=astSquareStates, + nActiveMotorCount:=2, + ); + AssertFalse( + tonTimeout.Q, + CONCAT('Timeout in square test ', UINT_TO_STRING(nAssertID)), + ); + AssertEquals_UINT( + Expected:=nGoal, + Actual:=fbSqRead.nPositionIndex, + Message:=CONCAT('Wrong read in square test ', UINT_TO_STRING(nAssertID)), + ); + + bSqAssertDone := TRUE; + IF nAssertID = 4 THEN + TEST_FINISHED(); + END_IF + tonTimeout(IN:=FALSE); + END_IF + END_METHOD + + +Related: + * `FB_MotionStage`_ + * `FB_MotorTestSuite`_ + * `FB_PositionStateInternal`_ + * `FB_PositionStateReadND`_ + * `FB_TestHelperSetAndMove`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_RawCountConverter +^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_RawCountConverter + (* + Utility function block for converting raw counts to EGU and back + *) + VAR_INPUT + // Parameters to check against + stParameters: ST_AxisParameterSet; + // Optional count to convert to a real position + nCountCheck: UDINT; + // Optional position to convert to encoder counts + fPosCheck: LREAL; + END_VAR + VAR_OUTPUT + // If converting position, the number of counts + nCountGet: UDINT; + // If converting counts, the position + fPosGet: LREAL; + // True during a parameter get/calc + bBusy: BOOL; + // True after a successful get/calc + bDone: BOOL; + // True if the calculation errored + bError: BOOL; + END_VAR + IF stParameters.fEncScaleFactorInternal <> 0 THEN + nCountGet := LREAL_TO_UDINT((fPosCheck - stParameters.fEncOffset) / stParameters.fEncScaleFactorInternal); + fPosGet := nCountCheck * stParameters.fEncScaleFactorInternal + stParameters.fEncOffset; + END_IF + + END_FUNCTION_BLOCK + + + + +FB_ReadFloatParameter +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_ReadFloatParameter + VAR_INPUT + bExecute: BOOL; + ///16#4000=Axisdata, 16#5000=Encoderdata, 16#6000=Controldata, 16#7000=Drivedata + nDeviceGroup: UDINT; + nIndexOffset: UDINT; + END_VAR + VAR_OUTPUT + nData: LREAL; + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR + nState: UINT; + fbADSREAD: ADSREAD; + END_VAR + (*Sequence to read parameter in Nc*) + CASE nState OF + 0: (*Start sequence. Wait until bExecute is TRUE*) + IF bExecute THEN + bBusy:=TRUE; + bError:=FALSE; + nErrorId:=0; + nState:=10; + END_IF + + 10: (*Read parameter in Nc*) + fbADSREAD( + PORT:=500, + IDXGRP:=nDeviceGroup+Axis.NcToPlc.AxisId, + IDXOFFS:=nIndexOffset, + LEN:=SIZEOF(nData), + DESTADDR:=ADR(nData), + READ:=TRUE); + + (*Wait until it's done or if an error occurs*) + IF NOT fbADSREAD.ERR THEN + IF NOT fbADSREAD.BUSY THEN + fbADSREAD(READ:=FALSE); + nState:=20; + END_IF + ELSE + nErrorId:=fbADSREAD.ERRID; + nState:=999; + END_IF + + 20: (*Sequense is done. Waits until bExecute is FALSE*) + bBusy:=FALSE; + bDone:=TRUE; + IF NOT bExecute THEN + bDone:=FALSE; + nState:=0; + END_IF + + 999: (*Error in sequence*) + bError:=TRUE; + bBusy:=FALSE; + bDone:=FALSE; + fbADSREAD(READ:=FALSE); + IF NOT bExecute THEN + nState:=0; + END_IF + + END_CASE + + END_FUNCTION_BLOCK + + + + +FB_ReadParameterInNc_v1_00 +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + ///######################################################### + ///Function block to read parameter in Nc. + /// + /// Library: + /// Tc2_MC2.lib + /// Tc2_System.lib + /// + /// Global Variables: + /// + /// Data types: + /// + /// External functions: + /// + /// History: + /// 2014-02-05 v1.00 NB Release code. + /// + /// Known bugs: + /// + /// + /// + ///########################################################### + FUNCTION_BLOCK FB_ReadParameterInNc_v1_00 + VAR_INPUT + bExecute: BOOL; + ///16#4000=Axisdata, 16#5000=Encoderdata, 16#6000=Controldata, 16#7000=Drivedata + nDeviceGroup: UDINT; + nIndexOffset: UDINT; + END_VAR + VAR_OUTPUT + nData: DWORD; + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR + nState: UINT; + fbADSREAD: ADSREAD; + END_VAR + (*Sequence to read parameter in Nc*) + CASE nState OF + 0: (*Start sequence. Wait until bExecute is TRUE*) + IF bExecute THEN + bBusy:=TRUE; + bError:=FALSE; + nErrorId:=0; + nState:=10; + END_IF + + 10: (*Read parameter in Nc*) + fbADSREAD( + PORT:=500, + IDXGRP:=nDeviceGroup+Axis.NcToPlc.AxisId, + IDXOFFS:=nIndexOffset, + LEN:=SIZEOF(nData), + DESTADDR:=ADR(nData), + READ:=TRUE); + + (*Wait until it's done or if an error occurs*) + IF NOT fbADSREAD.ERR THEN + IF NOT fbADSREAD.BUSY THEN + fbADSREAD(READ:=FALSE); + nState:=20; + END_IF + ELSE + nErrorId:=fbADSREAD.ERRID; + nState:=999; + END_IF + + 20: (*Sequense is done. Waits until bExecute is FALSE*) + bBusy:=FALSE; + bDone:=TRUE; + IF NOT bExecute THEN + bDone:=FALSE; + nState:=0; + END_IF + + 999: (*Error in sequence*) + bError:=TRUE; + bBusy:=FALSE; + bDone:=FALSE; + fbADSREAD(READ:=FALSE); + IF NOT bExecute THEN + nState:=0; + END_IF + + END_CASE + + END_FUNCTION_BLOCK + + + + +FB_SetEnables +^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_SetEnables + // Update the all enable booleans based on the booleans that make them up + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + stMotionStage.bAllForwardEnable := stMotionStage.bLimitForwardEnable AND (stMotionStage.bGantryForwardEnable OR NOT stMotionStage.bGantryAxis) AND stMotionStage.stEPSForwardEnable.bEPS_OK; + stMotionStage.bAllBackwardEnable := stMotionStage.bLimitBackwardEnable AND (stMotionStage.bGantryBackwardEnable OR NOT stMotionStage.bGantryAxis) AND stMotionStage.stEPSBackwardEnable.bEPS_OK; + + stMotionStage.bAllEnable := stMotionStage.bEnable AND stMotionStage.bHardwareEnable AND stMotionStage.stEPSPowerEnable.bEPS_OK; + stMotionStage.bAllEnable R= NOT stMotionStage.bUserEnable; + + END_FUNCTION_BLOCK + + +Related: + * `ST_MotionStage`_ + + +FB_Standard_PMPSDB +^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_Standard_PMPSDB + (* + This FB should be run on every motion PLC to encapsulate the pmps file reader. + It is pre-instantiated at MOTION_GVL.fbStandardPMPSDB + *) + VAR_IN_OUT + // The fast fault output to fault to. + io_fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + // If TRUE, FB will run. Reads when enable goes TRUE. + bEnable: BOOL; + // E.g. lfe-motion + sPlcName: STRING; + {attribute 'pytmc' := ' + pv: REFRESH + io: io + '} + // Set to TRUE to cause an extra read. + bRefresh: BOOL; + // Directory where the DB is stored. + sDirectory: STRING := '/Hard Disk/ftp/PMPS/'; + END_VAR + VAR_OUTPUT + {attribute 'pytmc' := ' + pv: LAST_REFRESH + io: i + '} + nLastRefreshTime: DINT; + bReadPmpsDb: BOOL; + END_VAR + VAR + bExecute: BOOL; + rtEnable: R_TRIG; + rtRefresh: R_TRIG; + ftBusy: F_TRIG; + + // Time tracking liften from Arbiter PLCs + fbTime : FB_LocalSystemTime := ( bEnable := TRUE, dwCycle := 1 ); + fbTime_to_UTC: FB_TzSpecificLocalTimeToSystemTime; + fbGetTimeZone: FB_GetTimeZoneInformation; + END_VAR + IF NOT bEnable THEN + RETURN; + END_IF + + rtEnable(CLK:=bEnable); + rtRefresh(CLK:=bRefresh); + bRefresh := FALSE; + + IF rtEnable.Q OR rtRefresh.Q THEN + // Make sure file reader gets a rising edge + MOTION_GVL.fbPmpsFileReader( + io_fbFFHWO:=io_fbFFHWO, + bExecute:=FALSE, + ); + bExecute := TRUE; + END_IF + + MOTION_GVL.fbPmpsFileReader( + io_fbFFHWO:=io_fbFFHWO, + bExecute:=bExecute, + sSrcPathName:=CONCAT(CONCAT(sDirectory, sPlcName), '.json'), + sPLCName:=sPLCName, + PMPS_jsonDoc=>PMPS_GVL.BP_jsonDoc, + ); + + ftBusy(CLK:=MOTION_GVL.fbPmpsFileReader.bBusy); + IF ftBusy.Q THEN + bReadPmpsDb := TRUE; + ELSE + bReadPmpsDb := FALSE; + END_IF + + + // Lifted from Arbiter PLCs: keep track of the time + fbTime(sNetID:=''); + fbGetTimeZone(sNetID:='', bExecute:=TRUE, tTimeout:=T#10S); + fbTime_to_UTC(in:= fbTime.systemTime , tzInfo:=fbGetTimeZone.tzInfo); + + // Update the refresh time on successful read + IF ftBusy.Q AND NOT MOTION_GVL.fbPmpsFileReader.bError THEN + nLastRefreshTime := TO_DINT(TO_DT(SystemTime_TO_DT(fbTime_to_UTC.out))); + END_IF + + bExecute R= ftBusy.Q; + + END_FUNCTION_BLOCK + + +Related: + * `MOTION_GVL`_ + + +FB_StatePMPSEnables +^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_StatePMPSEnables + (* + Function block to set virtual limit enables using MC_POWER for single dimensional state movers. + It is a building block not meant for use outside of lcls-twintcat-motion. + + Each motor has a virtual "allowed" range of motion based on its goal position. + When not at the goal, the motor can only move toward the goal. + When at the goal, the motor can move within the position's delta. + + With no goals or other strange states, the motor is permitted to move in either direction + to help restore it to a known position. + *) + VAR_IN_OUT + // The motor with a position state. + stMotionStage: ST_MotionStage; + // All possible position states for this motor. + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Hardware output to fault to if there is a problem. + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + // If TRUE, do the limits as normal. If FALSE, allow all moves regardless of the limits defined here. + bEnable: BOOL; + // The state that the motor is moving to. + nGoalStateIndex: UINT; + // The overal PMPS FB state + eStatePMPSStatus: E_StatePMPSStatus; + // Connect to the BPTM + bTransitionAuthorized: BOOL; + END_VAR + VAR_OUTPUT + // The enable state we send to MC_Power. This is a pass-through from stMotionStage. + bEnabled: BOOL; + // The forward enable state we send to MC_Power. This may be a pass-through or an override to FALSE. + bForwardEnabled: BOOL; + // The backwards enable state we send to MC_Power. This may be a pass-through or an override to FALSE. + bBackwardEnabled: BOOL; + // TRUE if there is a valid goal position and FALSE otherwise. This makes a fast fault if FALSE. + bValidGoal: BOOL; + END_VAR + VAR + mc_power: MC_POWER; + nPrevStateIndex: DINT; + fLowerPos: LREAL; + fUpperPos: LREAL; + ffNoGoal: FB_FastFault; + END_VAR + GetBounds(); + SetEnables(); + ApplyEnables(); + RunFastFaults(); + + END_FUNCTION_BLOCK + + ACTION ApplyEnables: + (* + This action takes runs MC_POWER appropriately + given the motor's own enables and the results of this FB's checks. + *) + bEnabled := stMotionStage.bAllEnable; + bForwardEnabled := bForwardEnabled AND stMotionStage.bAllForwardEnable; + bBackwardEnabled := bBackwardEnabled AND stMotionStage.bAllBackwardEnable; + + CASE eStatePMPSStatus OF + E_StatePMPSStatus.UNKNOWN: + stMotionStage.bSafetyReady := FALSE; + E_StatePMPSStatus.TRANSITION: + stMotionStage.bSafetyReady := bTransitionAuthorized; + bForwardEnabled R= NOT bTransitionAuthorized; + bBackwardEnabled R= NOT bTransitionAuthorized; + E_StatePMPSStatus.AT_STATE: + stMotionStage.bSafetyReady := stMotionStage.bExecute; + E_StatePMPSStatus.DISABLED: + stMotionStage.bSafetyReady := TRUE; + END_CASE + + mc_power( + Axis:=stMotionStage.Axis, + Enable:=bEnabled, + Enable_Positive:=bForwardEnabled, + Enable_Negative:=bBackwardEnabled, + ); + END_ACTION + + ACTION GetBounds: + (* + This action sets fLowerPos and fUpperPos based on our goal position. + *) + IF nGoalStateIndex > 0 AND nGoalStateIndex <= GeneralConstants.MAX_STATES THEN + IF astPositionState[nGoalStateIndex].bValid AND astPositionState[nGoalStateIndex].bUpdated THEN + bValidGoal := TRUE; + fLowerPos := astPositionState[nGoalStateIndex].fPosition - ABS(astPositionState[nGoalStateIndex].fDelta); + fUpperPos := astPositionState[nGoalStateIndex].fPosition + ABS(astPositionState[nGoalStateIndex].fDelta); + ELSE + bValidGoal := FALSE; + END_IF + ELSE + bValidGoal := FALSE; + END_IF + END_ACTION + + ACTION RunFastFaults: + ffNoGoal( + i_xOK:=bValidGoal, + i_xAutoReset:=TRUE, + i_DevName:=stMotionStage.sName, + i_Desc:='Invalid goal position in state move', + i_TypeCode:=E_MotionFFType.INVALID_GOAL, + io_fbFFHWO:=fbFFHWO, + ); + END_ACTION + + ACTION SetEnables: + (* + This action sets bForwardEnable and bBackwardEnable based on + the current position and the calculated bounds. + *) + IF bValidGoal AND bEnable THEN + bForwardEnabled := stMotionStage.stAxisStatus.fActPosition < fUpperPos; + bBackwardEnabled := stMotionStage.stAxisStatus.fActPosition > fLowerPos; + ELSE + // Either invalid state with a fault or FB not enabled + bForwardEnabled := TRUE; + bBackwardEnabled := TRUE; + END_IF + END_ACTION + + +Related: + * `E_MotionFFType`_ + * `E_StatePMPSStatus`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_StatePMPSEnables_Test +^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_StatePMPSEnables_Test EXTENDS FB_MotorTestSuite + (* + Tests for FB_StatePMPSEnables + + This function block ensures that: + - When not at our goal state, we cannot move away from our goal state + - When at our goal state, we must stay within the state bounds + - When at our goal state, we still obey other constraints like limit switches + + We also include a super basic real move test with our simulator motor to make sure the enables are set properly. + *) + VAR + stMotionStage: ST_MotionStage; + fbMotionStage: FB_MotionStage; + astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + fbInternal1: FB_PositionStateInternal; + fbInternal2: FB_PositionStateInternal; + nInvalidState: UINT := 2; + nGoalState: UINT := 4; + nNotUpdatedState: UINT := 6; + + bInit: BOOL; + nTestCounter: UINT; + bOneTestDone: BOOL; + fTestStartPos: LREAL; + tonTimer: TON; + bStatesReady: BOOL; + END_VAR + astPositionState[nGoalState].fPosition := 10; + astPositionState[nGoalState].fDelta := 1; + SetGoodState(astPositionState[nGoalState]); + astPositionState[nInvalidState].fPosition := 20; + astPositionState[nInvalidState].fDelta := 1; + astPositionState[nNotUpdatedState].fPosition := 20; + astPositionState[nNotUpdatedState].fDelta := 1; + SetGoodState(astPositionState[nNotUpdatedState]); + fbInternal1( + stMotionStage:=stMotionStage, + stPositionState:=astPositionState[nGoalState], + ); + fbInternal2( + stMotionStage:=stMotionStage, + stPositionState:=astPositionState[nInvalidState], + ); + fbMotionStage(stMotionStage:=stMotionStage); + bStatesReady:=astPositionState[nGoalState].bUpdated AND astPositionState[nInvalidState].bUpdated; + + IF bStatesReady AND nTestCounter = 0 THEN + // Don't run any tests until the states are ready + nTestCounter := 1; + END_IF + + TestInvalid(1); + TestNotUpdated(2); + TestBelow(3); + TestAbove(4); + TestAt(5); + TestDisabled(6); + TestLimits(7); + TestMoveTo(8); + TestMoveAt(9); + + IF bOneTestDone THEN + bOneTestDone := FALSE; + nTestCounter := nTestCounter + 1; + tonTimer(IN:=FALSE); + END_IF + // Use this timer to time out any tests that stall + tonTimer( + IN:=bStatesReady, + PT:=T#5s, + ); + + END_FUNCTION_BLOCK + + METHOD TestAbove + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbStateEnables: FB_StatePMPSEnables; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbMove: FB_TestHelperSetAndMove; + + bInit: BOOL; + END_VAR + TEST('TestAbove'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + SetEnablesPMPS(stMotionStage); + + // Set position to be above the goal's range + fbMove( + stMotionStage:=stMotionStage, + bExecute:=bInit, + fStartPosition:=astPositionState[nGoalState].fPosition + 100 * astPositionState[nGoalState].fDelta, + fGoalPosition:=astPositionState[nGoalState].fPosition + 100 * astPositionState[nGoalState].fDelta, + fVelocity:=1, + bHWEnable:=FALSE, + ); + bInit := TRUE; + // Run our FB + fbStateEnables( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=TRUE, + nGoalStateIndex:=nGoalState, + ); + fbFFHWO.EvaluateOutput(); + // If we've set the position OR ran out of time to set the position, check the asserts + IF tonTimer.Q OR fbMove.bSetDone THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + AssertEquals_LREAL( + Expected:=fbMove.fStartPosition, + Actual:=fbMove.fActPosition, + Delta:=0.0001, + Message:='Position was not set correctly', + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Fast fault in normal situation', + ); + AssertFalse( + fbStateEnables.bForwardEnabled, + 'Forward enabled when above goal', + ); + AssertTrue( + fbStateEnables.bBackwardEnabled, + 'Backward disabled when above goal', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestAt + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbStateEnables: FB_StatePMPSEnables; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbMove: FB_TestHelperSetAndMove; + + bInit: BOOL; + END_VAR + TEST('TestAt'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + SetEnablesPMPS(stMotionStage); + + // Set position to be at the goal state + fbMove( + stMotionStage:=stMotionStage, + bExecute:=bInit, + fStartPosition:=astPositionState[nGoalState].fPosition, + fGoalPosition:=astPositionState[nGoalState].fPosition, + fVelocity:=1, + bHWEnable:=FALSE, + ); + bInit := TRUE; + // Run our FB + fbStateEnables( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=TRUE, + nGoalStateIndex:=nGoalState, + ); + fbFFHWO.EvaluateOutput(); + // If we've set the position OR ran out of time to set the position, check the asserts + IF tonTimer.Q OR fbMove.bSetDone THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + AssertEquals_LREAL( + Expected:=fbMove.fStartPosition, + Actual:=fbMove.fActPosition, + Delta:=0.0001, + Message:='Position was not set correctly', + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Fast fault in normal situation', + ); + AssertTrue( + fbStateEnables.bForwardEnabled, + 'Forward disabled when at goal', + ); + AssertTrue( + fbStateEnables.bBackwardEnabled, + 'Backward disabled when at goal', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestBelow + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbStateEnables: FB_StatePMPSEnables; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbMove: FB_TestHelperSetAndMove; + + bInit: BOOL; + END_VAR + TEST('TestBelow'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + SetEnablesPMPS(stMotionStage); + + // Set position to be below the goal's range + fbMove( + stMotionStage:=stMotionStage, + bExecute:=bInit, + fStartPosition:=astPositionState[nGoalState].fPosition - 100 * astPositionState[nGoalState].fDelta, + fGoalPosition:=astPositionState[nGoalState].fPosition - 100 * astPositionState[nGoalState].fDelta, + fVelocity:=1, + bHWEnable:=FALSE, + ); + bInit := TRUE; + // Run our FB + fbStateEnables( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=bInit, + nGoalStateIndex:=nGoalState, + ); + + fbFFHWO.EvaluateOutput(); + // If we've set the position OR ran out of time to set the position, check the asserts + IF tonTimer.Q OR fbMove.bSetDone THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + AssertEquals_LREAL( + Expected:=fbMove.fStartPosition, + Actual:=fbMove.fActPosition, + Delta:=0.0001, + Message:='Position was not set correctly', + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Fast fault in normal situation', + ); + AssertFalse( + fbStateEnables.bBackwardEnabled, + 'Backward enabled when below goal', + ); + AssertTrue( + fbStateEnables.bForwardEnabled, + 'Forward disabled when below goal', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestDisabled + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbStateEnables: FB_StatePMPSEnables; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbMove: FB_TestHelperSetAndMove; + + bInit: BOOL; + END_VAR + TEST('TestDisabled'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + SetEnablesPMPS(stMotionStage); + + // Set position to be below the goal's range + fbMove( + stMotionStage:=stMotionStage, + bExecute:=bInit, + fStartPosition:=astPositionState[nGoalState].fPosition - 100 * astPositionState[nGoalState].fDelta, + fGoalPosition:=astPositionState[nGoalState].fPosition - 100 * astPositionState[nGoalState].fDelta, + fVelocity:=1, + bHWEnable:=FALSE, + ); + bInit := TRUE; + // Run our FB + fbStateEnables( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=FALSE, + nGoalStateIndex:=nGoalState, + ); + + fbFFHWO.EvaluateOutput(); + // If we've set the position OR ran out of time to set the position, check the asserts + IF tonTimer.Q OR fbMove.bSetDone THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + AssertEquals_LREAL( + Expected:=fbMove.fStartPosition, + Actual:=fbMove.fActPosition, + Delta:=0.0001, + Message:='Position was not set correctly', + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Fast fault in normal situation', + ); + AssertTrue( + fbStateEnables.bBackwardEnabled, + 'Backward disabled when fb is supposed to be disabled', + ); + AssertTrue( + fbStateEnables.bForwardEnabled, + 'Forward disabled when fb is supposed to be disabled', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestInvalid + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbStateEnables: FB_StatePMPSEnables; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestInvalid'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + SetEnablesPMPS(stMotionStage); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Faulted prior to test', + ); + // The invalid state should give us a fault + fbStateEnables( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=TRUE, + nGoalStateIndex:=nInvalidState, + ); + fbFFHWO.EvaluateOutput(); + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Invalid state did not fault', + ); + + bOneTestDone := TRUE; + TEST_FINISHED(); + END_METHOD + + METHOD TestLimits + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbStateEnables: FB_StatePMPSEnables; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbMove: FB_TestHelperSetAndMove; + + bInit: BOOL; + END_VAR + TEST('TestLimits'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + SetEnablesPMPS(stMotionStage); + // Kill the limit switches for this test + stMotionStage.bLimitForwardEnable := FALSE; + stMotionStage.bLimitBackwardEnable := FALSE; + + // Set position to be at the goal state + fbMove( + stMotionStage:=stMotionStage, + bExecute:=bInit, + fStartPosition:=astPositionState[nGoalState].fPosition, + fGoalPosition:=astPositionState[nGoalState].fPosition, + fVelocity:=1, + bHWEnable:=FALSE, + ); + bInit := TRUE; + + // Run our FB + fbStateEnables( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=TRUE, + nGoalStateIndex:=nGoalState, + ); + fbFFHWO.EvaluateOutput(); + // If we've set the position OR ran out of time to set the position, check the asserts + IF tonTimer.Q OR fbMove.bSetDone THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + AssertEquals_LREAL( + Expected:=fbMove.fStartPosition, + Actual:=fbMove.fActPosition, + Delta:=0.0001, + Message:='Position was not set correctly', + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Fast fault in normal situation', + ); + AssertFalse( + fbStateEnables.bForwardEnabled, + 'Forward enabled with limit hit', + ); + AssertFalse( + fbStateEnables.bBackwardEnabled, + 'Backward enabled with limit hit', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestMoveAt + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbStateEnables: FB_StatePMPSEnables; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbMove: FB_TestHelperSetAndMove; + + bInit: BOOL; + END_VAR + TEST('TestMoveAt'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + SetEnablesPMPS(stMotionStage); + + // Run our FB which should enable the real move + fbStateEnables( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=bInit, + nGoalStateIndex:=nGoalState, + eStatePMPSStatus:=E_StatePMPSStatus.AT_STATE, + bTransitionAuthorized:=FALSE, + ); + + // Set position to be below the goal's range, and move to the goal + fbMove( + stMotionStage:=stMotionStage, + bExecute:=bInit, + fStartPosition:=astPositionState[nGoalState].fPosition - astPositionState[nGoalState].fDelta / 2, + fGoalPosition:=astPositionState[nGoalState].fPosition + astPositionState[nGoalState].fDelta / 2, + fVelocity:=5, + bHWEnable:=FALSE, + ); + bInit := TRUE; + + fbFFHWO.EvaluateOutput(); + + // If we've reached the position OR ran out of time to set the position, check the asserts + IF tonTimer.Q OR fbMove.bMoveDone THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + AssertEquals_LREAL( + Expected:=astPositionState[nGoalState].fPosition + astPositionState[nGoalState].fDelta / 2, + Actual:=fbMove.fActPosition, + Delta:=0.0001, + Message:='Did not reach the goal position', + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Fast fault in normal situation', + ); + AssertTrue( + fbStateEnables.bBackwardEnabled, + 'Backward disabled when at goal', + ); + AssertTrue( + fbStateEnables.bForwardEnabled, + 'Forward disabled when at goal', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestMoveTo + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbStateEnables: FB_StatePMPSEnables; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + fbMove: FB_TestHelperSetAndMove; + + bInit: BOOL; + END_VAR + TEST('TestMoveTo'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + SetEnablesPMPS(stMotionStage); + + // Run our FB which should enable the real move + fbStateEnables( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=bInit, + nGoalStateIndex:=nGoalState, + eStatePMPSStatus:=E_StatePMPSStatus.TRANSITION, + bTransitionAuthorized:=TRUE, + ); + + // Set position to be below the goal's range, and move to the goal + fbMove( + stMotionStage:=stMotionStage, + bExecute:=bInit, + fStartPosition:=astPositionState[nGoalState].fPosition - 10, + fGoalPosition:=astPositionState[nGoalState].fPosition, + fVelocity:=5, + bHWEnable:=FALSE, + ); + bInit := TRUE; + + fbFFHWO.EvaluateOutput(); + + // If we've reached the position OR ran out of time to set the position, check the asserts + IF tonTimer.Q OR fbMove.bMoveDone THEN + AssertFalse( + tonTimer.Q, + 'Timeout in test', + ); + AssertEquals_LREAL( + Expected:=astPositionState[nGoalState].fPosition, + Actual:=fbMove.fActPosition, + Delta:=0.0001, + Message:='Did not reach the goal position', + ); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Fast fault in normal situation', + ); + AssertTrue( + fbStateEnables.bBackwardEnabled, + 'Backward disabled when at goal', + ); + AssertTrue( + fbStateEnables.bForwardEnabled, + 'Forward disabled when at goal', + ); + bOneTestDone := TRUE; + TEST_FINISHED(); + END_IF + END_METHOD + + METHOD TestNotUpdated + VAR_INPUT + nTestID: UINT; + END_VAR + VAR_INST + fbStateEnables: FB_StatePMPSEnables; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestNotUpdated'); + IF nTestCounter <> nTestID THEN + RETURN; + END_IF + + SetEnablesPMPS(stMotionStage); + + fbFFHWO.EvaluateOutput(); + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Faulted prior to test', + ); + // The invalid state should give us a fault + fbStateEnables( + stMotionStage:=stMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=TRUE, + nGoalStateIndex:=nNotUpdatedState, + ); + fbFFHWO.EvaluateOutput(); + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Not updated state did not fault', + ); + + bOneTestDone := TRUE; + TEST_FINISHED(); + END_METHOD + + +Related: + * `E_StatePMPSStatus`_ + * `FB_MotionStage`_ + * `FB_MotorTestSuite`_ + * `FB_PositionStateInternal`_ + * `FB_StatePMPSEnables`_ + * `FB_TestHelperSetAndMove`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_StatePMPSEnablesND +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_StatePMPSEnablesND + (* + Function block to set virtual limit enables using MC_POWER for multidimensional state movers. + It is a building block not meant for use outside of lcls-twintcat-motion. + + Each motor has a virtual "allowed" range of motion based on its goal position. + Motors can move toward their goal delta ranges or within them, but not away from these ranges. + *) + VAR_IN_OUT + // The motors with a combined N-dimensional state + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + // Each motor's respective position states along its direction + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + // Hardware output to fault to if there is a problem. + fbFFHWO: FB_HardwareFFOutput; + END_VAR + VAR_INPUT + // Whether or not to do anything + bEnable: BOOL; + // The number of motors we're actually using + nActiveMotorCount: UINT; + // The state that the motors are moving to, along dimension 2 of the position state array. This may be the same as the current state. + nGoalStateIndex: UINT; + // A name to use for this state mover in the case of fast faults. + sDeviceName: STRING; + // Set to TRUE to put motors into maintenance mode. This allows us to freely move the motors at the cost of a fast fault. + bMaintMode: BOOL; + // The overal PMPS FB state + eStatePMPSStatus: E_StatePMPSStatus; + // Connect from bptm bTransitionAuthorized + bTransitionAuthorized: BOOL; + END_VAR + VAR_OUTPUT + // Per-motor enable state we send to MC_Power. This is a pass-through from stMotionStage. + abEnabled: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF BOOL; + // Per-motor forward enable state we send to MC_Power. This may be a pass-through or an override to FALSE. + abForwardEnabled: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF BOOL; + // Per-motor backwards enable state we send to MC_Power. This may be a pass-through or an override to FALSE. + abBackwardEnabled: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF BOOL; + // Per-motor TRUE if there is a valid goal position and FALSE otherwise. This makes a fast fault if FALSE. + abValidGoal: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF BOOL; + // Set to TRUE if the arrays have mismatched sizing. For this FB, this means the motor won't ever get an enable. + bMotorCountError: BOOL; + END_VAR + VAR + // The individual state limit function blocks + afbStateEnables: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF FB_StatePMPSEnables; + ffMaint: FB_FastFault; + ffProgrammerError: FB_FastFault; + nIter: DINT; + END_VAR + CheckCount(); + IF NOT bMotorCountError THEN + DoLimits(); + END_IF + RunFastFaults(); + + END_FUNCTION_BLOCK + + ACTION CheckCount: + // Make sure the motor count is valid (positive, nonzero, less or equal to the max) + bMotorCountError S= nActiveMotorCount <= 0; + bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS; + END_ACTION + + ACTION DoLimits: + FOR nIter := 1 TO nActiveMotorCount DO + afbStateEnables[nIter]( + stMotionStage:=astMotionStage[nIter], + astPositionState:=astPositionState[nIter], + fbFFHWO:=fbFFHWO, + bEnable:=bEnable AND NOT bMaintMode, + nGoalStateIndex:=nGoalStateIndex, + eStatePMPSStatus:=eStatePMPSStatus, + bTransitionAuthorized:=bTransitionAuthorized, + bEnabled=>abEnabled[nIter], + bForwardEnabled=>abForwardEnabled[nIter], + bBackwardEnabled=>abBackwardEnabled[nIter], + bValidGoal=>abValidGoal[nIter], + ); + END_FOR + END_ACTION + + ACTION RunFastFaults: + ffMaint( + i_xOK := NOT bMaintMode, + i_xAutoReset := TRUE, + i_DevName := sDeviceName, + i_Desc := 'Device is in maintenance mode', + i_TypeCode := E_MotionFFType.MAINT_MODE, + io_fbFFHWO := fbFFHWO, + ); + + ffProgrammerError( + i_xOK:=NOT bMotorCountError, + i_xAutoReset:=TRUE, + i_DevName:=sDeviceName, + i_Desc:='Programmer error picking motor count', + i_TypeCode:=E_MotionFFType.INTERNAL_ERROR, + io_fbFFHWO:=fbFFHWO, + ); + END_ACTION + + +Related: + * `E_MotionFFType`_ + * `E_StatePMPSStatus`_ + * `FB_StatePMPSEnables`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_StatePMPSEnablesND_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_StatePMPSEnablesND_Test EXTENDS FB_MotorTestSuite + (* + Unit tests for FB_StatePMPSEnablesND + I'm confident that FB_StatePMPSEnables was tested in FB_StatePMPSEnables_Test + There will be one core functionality check + Then, the rest will be about the ND feature adds. + Full checks: + - Core motors not at goal can't move away check + - bMaintMode = no move restrictions for all motors. + - bMaintMode = fast fault + - Wrong count = fast fault + *) + VAR + astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage; + astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + afbInternal: ARRAY[1..2] OF FB_PositionStateInternal; + nIter: UINT; + END_VAR + // Spoof motor enables + FOR nIter := 1 TO 3 DO + astMotionStage[nIter].bAllEnable := TRUE; + astMotionStage[nIter].bAllForwardEnable := TRUE; + astMotionStage[nIter].bAllBackwardEnable := TRUE; + END_FOR + // Note: the fake motors show as position = 0, so they will be over/under the goals here + astPositionState[1][1].fPosition := 10; + astPositionState[1][1].fDelta := 1; + afbInternal[1]( + stMotionStage:=astMotionStage[1], + stPositionState:=astPositionState[1][1], + ); + SetGoodState(astPositionState[1][1]); + + astPositionState[2][1].fPosition := -10; + astPositionState[2][1].fDelta := 1; + afbInternal[2]( + stMotionStage:=astMotionStage[2], + stPositionState:=astPositionState[2][1], + ); + SetGoodState(astPositionState[2][1]); + + TestUnderOverGoals(); + TestMaint(); + TestCount(); + + END_FUNCTION_BLOCK + + METHOD TestCount + VAR_INST + fbEnables: FB_StatePMPSEnablesND; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestCount'); + + fbFFHWO.EvaluateOutput(); + // No faults please + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Had faults prior to test', + ); + fbEnables( + astMotionStage:=astMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + nGoalStateIndex:=1, + sDeviceName:='TestUnderOverGoals', + bMaintMode:=FALSE, + ); + fbFFHWO.EvaluateOutput(); + // Must fault with bad count + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Had no fault with bad count', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TestMaint + VAR_INST + fbEnables: FB_StatePMPSEnablesND; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestMaint'); + + fbFFHWO.EvaluateOutput(); + // No faults please + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Had faults prior to test', + ); + fbEnables( + astMotionStage:=astMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + nActiveMotorCount:=2, + nGoalStateIndex:=1, + sDeviceName:='TestUnderOverGoals', + bMaintMode:=TRUE, + ); + fbFFHWO.EvaluateOutput(); + // Must fault in maint mode + AssertFalse( + fbFFHWO.q_xFastFaultOut, + 'Had no fault in maintenance mode', + ); + // All overrides should be relaxed + AssertTrue( + fbEnables.abForwardEnabled[1], + 'In maintenance mode, we should be able to move anywhere', + ); + AssertTrue( + fbEnables.abBackwardEnabled[1], + 'In maintenance mode, we should be able to move anywhere', + ); + AssertTrue( + fbEnables.abForwardEnabled[1], + 'In maintenance mode, we should be able to move anywhere', + ); + AssertTrue( + fbEnables.abBackwardEnabled[1], + 'In maintenance mode, we should be able to move anywhere', + ); + + TEST_FINISHED(); + END_METHOD + + METHOD TestUnderOverGoals + VAR_INST + fbEnables: FB_StatePMPSEnablesND; + fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE); + END_VAR + TEST('TestUnderOverGoals'); + + IF NOT astPositionState[1][1].bUpdated OR NOT astPositionState[2][1].bUpdated THEN + // Cannot run this test until the one-time-setup runs + RETURN; + END_IF + + fbEnables( + astMotionStage:=astMotionStage, + astPositionState:=astPositionState, + fbFFHWO:=fbFFHWO, + bEnable:=TRUE, + nActiveMotorCount:=2, + nGoalStateIndex:=1, + sDeviceName:='TestUnderOverGoals', + bMaintMode:=FALSE, + ); + fbFFHWO.EvaluateOutput(); + // No faults please + AssertTrue( + fbFFHWO.q_xFastFaultOut, + 'Had faults in normal situation', + ); + // All core enables are true + AssertTrue( + astMotionStage[1].bAllForwardEnable, + 'Core enables should be TRUE', + ); + AssertTrue( + astMotionStage[1].bAllBackwardEnable, + 'Core enables should be TRUE', + ); + AssertTrue( + astMotionStage[2].bAllForwardEnable, + 'Core enables should be TRUE', + ); + AssertTrue( + astMotionStage[2].bAllBackwardEnable, + 'Core enables should be TRUE', + ); + // But the overrides force us to move toward the goal + // Motor 1 is below the goal, Motor 2 is above the goal + AssertTrue( + fbEnables.abForwardEnabled[1], + 'Motor 1 should be able to move up to the goal', + ); + AssertFalse( + fbEnables.abBackwardEnabled[1], + 'Motor 1 should not be able to move down away from the goal', + ); + AssertFalse( + fbEnables.abForwardEnabled[2], + 'Motor 2 should not be able to move up away from the goal', + ); + AssertTrue( + fbEnables.abBackwardEnabled[2], + 'Motor 2 should be able to move down to the goal', + ); + + TEST_FINISHED(); + END_METHOD + + +Related: + * `FB_MotorTestSuite`_ + * `FB_PositionStateInternal`_ + * `FB_StatePMPSEnables`_ + * `FB_StatePMPSEnablesND`_ + * `FB_StatePMPSEnables_Test`_ + * `MotionConstants`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_StatePTPMove +^^^^^^^^^^^^^^^ + +:: + + {attribute 'obsolete' := 'Use FB_PositionStateMove instead'} + FUNCTION_BLOCK FB_StatePTPMove + // Do not use, this is deprecated + VAR_INPUT + {attribute 'pytmc' := ' + pv: + '} + stPositionState: ST_PositionState; + + {attribute 'pytmc' := ' + pv: GO + io: io + field: ZNAM False + field: ONAM True + '} + bExecute: BOOL; + + bMoveOk: BOOL; + END_VAR + VAR_IN_OUT + stMotionStage: ST_MotionStage; + END_VAR + VAR_OUTPUT + {attribute 'pytmc' := ' + pv: AT_STATE + io: input + field: ZNAM False + field: ONAM True + '} + bAtState: BOOL; + + {attribute 'pytmc' := ' + pv: DMOV + io: input + field: ZNAM False + field: ONAM True + '} + bDone: BOOL; + + {attribute 'pytmc' := ' + pv: BUSY + io: input + field: ZNAM False + field: ONAM True + '} + bBusy: BOOL; + + {attribute 'pytmc' := ' + pv: ERR + io: input + field: ZNAM False + field: ONAM True + '} + bError: BOOL; + + {attribute 'pytmc' := ' + pv: ERRMSG + io: input + '} + sError: STRING; + END_VAR + VAR + bExecTrig: R_TRIG; + bExecEnd: F_TRIG; + fActPosition: LREAL; + fLowPos: LREAL; + fHighPos: LREAL; + END_VAR + bExecTrig(CLK:=bExecute); + IF bExecTrig.Q AND bMoveOk THEN + IF NOT stMotionStage.bBusy AND NOT stMotionStage.bError THEN + stMotionStage.bExecute := TRUE; + stMotionStage.nCommand := E_EpicsMotorCmd.MOVE_ABSOLUTE; + stMotionStage.fPosition := stPositionState.fPosition; + stMotionStage.fVelocity := stPositionState.fVelocity; + stMotionStage.fAcceleration := stPositionState.fAccel; + stMotionStage.fDeceleration := stPositionState.fDecel; + bDone := FALSE; + bBusy := TRUE; + END_IF + END_IF + bError := stMotionStage.bError; + sError := stMotionStage.sErrorMessage; + + fActPosition := stMotionStage.stAxisStatus.fActPosition; + fLowPos := stPositionState.fPosition - stPositionState.fDelta; + fHighPos := stPositionState.fPosition + stPositionState.fDelta; + IF (fLowPos < fActPosition) AND (fHighPos > fActPosition) THEN + bAtState := TRUE; + IF NOT stMotionStage.bBusy THEN + bDone := TRUE; + bBusy := FALSE; + bExecute := FALSE; + END_IF + ELSE + bAtState := FALSE; + END_IF + + bExecEnd(CLK:=bExecute); + IF bExecEnd.Q AND bBusy THEN + stMotionStage.bExecute := FALSE; + END_IF + + IF NOT stMotionStage.bExecute OR NOT bExecute THEN + bDone := TRUE; + bBusy := FALSE; + bExecute := FALSE; + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `E_EpicsMotorCmd`_ + * `FB_PositionStateMove`_ + * `ST_MotionStage`_ + * `ST_PositionState`_ + + +FB_StateSetupHelper +^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_StateSetupHelper + (* + This is a helper for setting up large numbers of ST_PositionState instances. + + This is typically verbose to do by hand in the normal ways and can be error-prone. + + Calling with bSetDefault:=TRUE will set the default values to all the values + from the input stPositionState. Note that the other args will be ignored in this case. + This must be done at least once. If you forget to do this, there will be a warning and + bValid will be set to FALSE, making it so we cannot move to that state. + + Calling without bSetDefault or with it set to FALSE will apply values to the + input stPositionState with the following priority order: + + 1. The value used in the function block call + 2. The value from the template stPositionState used in the most recent + call with bSetDefault:=TRUE + 3. The original default value as defined on ST_PositionState + + For ease of use, to enable EPICS writes if unlocked, and to avoid repeated + self-overwrites in the encoder count use case, this function block will not + reapply the values to the same state again after the state has been fully + initialized by the states function blocks, as determined by the bUpdated struct + member. If you want to force the function block to reapply every cycle you can + set bForceUpdate to TRUE, but it is not recommended. Without this feature, + you would be required to wrap this function block in a guard to make sure it + was only called once per state, which is fairly annoying. + + Example expected usage: + VAR + fbStateSetup: FB_StateSetupHelper; + stDefault: ST_PositionState := ( + fDelta := 0.5, + fVelocity := 10, + bMoveOk := TRUE, + bValid := TRUE + ); + astStates1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astStates2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + astStates2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState; + END_VAR + + fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE); + + fbStateSetup(stPositionState:=astStates1[1], sName:='OUT', fPosition:=10); + fbStateSetup(stPositionState:=astStates1[2], sName:='YAG', fPosition:=20); + fbStateSetup(stPositionState:=astStates1[3], sName:='TT', fPosition:=30); + + fbStateSetup(stPositionState:=astStates2[1], sName:='OUT', fPosition:=-30); + fbStateSetup(stPositionState:=astStates2[2], sName:='YAG', fPosition:=35); + fbStateSetup(stPositionState:=astStates2[3], sName:='TT', fPosition:=70); + + fbStateSetup(stPositionState:=astStates3[1], sName:='OUT', fPosition:=0.4, fDelta:=0.1); + fbStateSetup(stPositionState:=astStates3[2], sName:='YAG', fPosition:=2.3, fDelta:=0.1); + fbStateSetup(stPositionState:=astStates3[3], sName:='TT', fPosition:=5.6, fDelta:=0.1; + *) + VAR_IN_OUT + stPositionState: ST_PositionState; + END_VAR + VAR_INPUT + bSetDefault: BOOL; + bForceUpdate: BOOL; + sName: STRING; + fPosition: LREAL; + nEncoderCount: UDINT; + fDelta: LREAL; + fVelocity: LREAL; + fAccel: LREAL; + fDecel: LREAL; + bMoveOk: BOOL; + bLocked: BOOL; + bValid: BOOL; + bUseRawCounts: BOOL; + sPmpsState: STRING; + END_VAR + VAR + stDefault: ST_PositionState; + fbWarning: FB_LogMessage; + bHasDefault: BOOL; + bHasWarned: BOOL; + sJson: STRING; + END_VAR + IF bSetDefault THEN + bSetDefault := FALSE; + bHasDefault := TRUE; + stDefault := stPositionState; + ELSIF bForceUpdate OR NOT stPositionState.bUpdated THEN + stPositionState.sName := sName; + stPositionState.fPosition := fPosition; + stPositionState.nEncoderCount := nEncoderCount; + stPositionState.fDelta := fDelta; + stPositionState.fVelocity := fVelocity; + stPositionState.fAccel := fAccel; + stPositionState.fDecel := fDecel; + stPositionState.bMoveOk := bMoveOk; + stPositionState.bLocked := bLocked; + stPositionState.bValid := bValid; + stPositionState.bUseRawCounts := bUseRawCounts; + stPositionState.stPMPS.sPmpsState := sPmpsState; + IF NOT bHasDefault THEN + stPositionState.bValid := FALSE; + IF NOT bHasWarned THEN + bHasWarned := TRUE; + sJson := CONCAT(CONCAT(CONCAT(CONCAT('{"sName": "', sName), '", "sPmpsState": "'), sPmpsState), '"}'); + fbWarning( + sMsg:=CONCAT('Did not initialize any defaults in FB_StateSetupHelper! Some states are disabled, check your code! ', sJson), + eSevr:=TcEventSeverity.Warning, + eSubSystem:=E_Subsystem.MOTION, + sJson:=sJson, + ); + END_IF + END_IF + END_IF + + // Overwrite the input args so that unset args are the defaults in the next call + sName := stDefault.sName; + fPosition := stDefault.fPosition; + nEncoderCount := stDefault.nEncoderCount; + fDelta := stDefault.fDelta; + fVelocity := stDefault.fVelocity; + fAccel := stDefault.fAccel; + fDecel := stDefault.fDecel; + bMoveOk := stDefault.bMoveOk; + bLocked := stDefault.bLocked; + bValid := stDefault.bValid; + bUseRawCounts := stDefault.bUseRawCounts; + sPmpsState := stDefault.stPMPS.sPmpsState; + + END_FUNCTION_BLOCK + + +Related: + * `ST_PositionState`_ + + +FB_StateSetupHelper_Test +^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_StateSetupHelper_Test EXTENDS FB_TestSuite + VAR + astStates: ARRAY[1..10] OF ST_PositionState; + stDefaultDefault: ST_PositionState; + END_VAR + TestNormalCase(); + TestDefaultOnly(); + TestManyOverrides(); + TestNoDefault(); + TestOnlyOnce(); + + END_FUNCTION_BLOCK + + METHOD TestDefaultOnly + VAR + fbStateSetup: FB_StateSetupHelper; + stDefault: ST_PositionState := ( + sName := 'DEFAULT', + fPosition := 100, + nEncoderCount := 200, + fDelta := 0.5, + fVelocity := 10, + fAccel := 12, + fDecel := 24, + bMoveOk := TRUE, + bLocked := TRUE, + bValid := TRUE, + bUseRawCounts := TRUE + ); + stOriginal: ST_PositionState; + stTarget: ST_PositionState; + END_VAR + TEST('TestDefaultOnly'); + + // Add a pmps key + stDefault.stPMPS.sPmpsState := 'KEY'; + // Cache the defaults to use as the check in case stDefault gets mutated by a bug + stOriginal := stDefault; + // Apply only defaults + fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE); + fbStateSetup(stPositionState:=stTarget); + // Check everything + AssertEquals_STRING(stOriginal.sName, stTarget.sName, 'Wrong sName'); + AssertEquals_LREAL(stOriginal.fPosition, stTarget.fPosition, 0, 'Wrong fPosition'); + AssertEquals_UDINT(stOriginal.nEncoderCount, stTarget.nEncoderCount, 'Wrong nEncoderCount'); + AssertEquals_LREAL(stOriginal.fDelta, stTarget.fDelta, 0, 'Wrong fDelta'); + AssertEquals_LREAL(stOriginal.fVelocity, stTarget.fVelocity, 0, 'Wrong fVelocity'); + AssertEquals_LREAL(stOriginal.fAccel, stTarget.fAccel, 0, 'Wrong fAccel'); + AssertEquals_LREAL(stOriginal.fDecel, stTarget.fDecel, 0, 'Wrong fDecel'); + AssertEquals_BOOL(stOriginal.bMoveOk, stTarget.bMoveOk, 'Wrong bMoveOk'); + AssertEquals_BOOL(stOriginal.bLocked, stTarget.bLocked, 'Wrong bLocked'); + AssertEquals_BOOL(stOriginal.bValid, stTarget.bValid, 'Wrong bValid'); + AssertEquals_BOOL(stOriginal.bUseRawCounts, stTarget.bUseRawCounts, 'Wrong bUseRawCounts'); + AssertEquals_STRING(stOriginal.stPMPS.sPmpsState, stTarget.stPMPS.sPmpsState, 'Wrong sPmpsState'); + + TEST_FINISHED(); + END_METHOD + + METHOD TestManyOverrides + VAR + fbStateSetup: FB_StateSetupHelper; + stDefault: ST_PositionState := ( + sName := 'POTATO', + fPosition := 23, + fDelta := 0.5, + fVelocity := 10 + ); + stOne: ST_PositionState; + stTwo: ST_PositionState; + END_VAR + TEST('TestManyOverrides'); + // This is the case where the defaults are always overriden + + fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE); + fbStateSetup(stPositionState:=stOne, sName:='ONE', fPosition:=10, fDelta:=0.1, fVelocity:=20); + fbStateSetup(stPositionState:=stTWO, sName:='TWO', fPosition:=30, fDelta:=0.23, fVelocity:=4); + + // Check Everything + AssertEquals_STRING('ONE', stOne.sName, 'Wrong sName in state 1'); + AssertEquals_LREAL(10, stOne.fPosition, 0, 'Wrong fPosition in state 1'); + AssertEquals_UDINT(stDefaultDefault.nEncoderCount, stOne.nEncoderCount, 'Wrong nEncoderCount in state 1'); + AssertEquals_LREAL(0.1, stOne.fDelta, 0, 'Wrong fDelta in state 1'); + AssertEquals_LREAL(20, stOne.fVelocity, 0, 'Wrong fVelocity in state 1'); + AssertEquals_LREAL(stDefaultDefault.fAccel, stOne.fAccel, 0, 'Wrong fAccel in state 1'); + AssertEquals_LREAL(stDefaultDefault.fDecel, stOne.fDecel, 0, 'Wrong fDecel in state 1'); + AssertEquals_BOOL(stDefaultDefault.bMoveOk, stOne.bMoveOk, 'Wrong bMoveOk in state 1'); + AssertEquals_BOOL(stDefaultDefault.bLocked, stOne.bLocked, 'Wrong bLocked in state 1'); + AssertEquals_BOOL(stDefaultDefault.bValid, stOne.bValid, 'Wrong bValid in state 1'); + AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, stOne.bUseRawCounts, 'Wrong bUseRawCounts in state 1'); + AssertEquals_STRING(stDefaultDefault.stPMPS.sPmpsState, stOne.stPMPS.sPmpsState, 'Wrong sPmpsState in state 1'); + + AssertEquals_STRING('TWO', stTwo.sName, 'Wrong sName in state 2'); + AssertEquals_LREAL(30, stTwo.fPosition, 0, 'Wrong fPosition in state 2'); + AssertEquals_UDINT(stDefaultDefault.nEncoderCount, stTwo.nEncoderCount, 'Wrong nEncoderCount in state 2'); + AssertEquals_LREAL(0.23, stTwo.fDelta, 0, 'Wrong fDelta in state 2'); + AssertEquals_LREAL(4, stTwo.fVelocity, 0, 'Wrong fVelocity in state 2'); + AssertEquals_LREAL(stDefaultDefault.fAccel, stTwo.fAccel, 0, 'Wrong fAccel in state 2'); + AssertEquals_LREAL(stDefaultDefault.fDecel, stTwo.fDecel, 0, 'Wrong fDecel in state 2'); + AssertEquals_BOOL(stDefaultDefault.bMoveOk, stTwo.bMoveOk, 'Wrong bMoveOk in state 2'); + AssertEquals_BOOL(stDefaultDefault.bLocked, stTwo.bLocked, 'Wrong bLocked in state 2'); + AssertEquals_BOOL(stDefaultDefault.bValid, stTwo.bValid, 'Wrong bValid in state 2'); + AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, stTwo.bUseRawCounts, 'Wrong bUseRawCounts in state 2'); + AssertEquals_STRING(stDefaultDefault.stPMPS.sPmpsState, stTwo.stPMPS.sPmpsState, 'Wrong sPmpsState in state 2'); + + TEST_FINISHED(); + END_METHOD + + METHOD TestNoDefault + VAR + fbStateSetup: FB_StateSetupHelper; + stTarget: ST_PositionState; + END_VAR + TEST('TestNoDefault'); + // No default = invalid state + warning log message + + fbStateSetup(stPositionState:=stTarget, sName:='TestNoDefault', sPmpsState:='TestPMPS', bValid:=TRUE); + // Only bValid matters, it must not be valid! + AssertFalse(stTarget.bValid, 'bValid should be FALSE with no default set.'); + + TEST_FINISHED(); + END_METHOD + + METHOD TestNormalCase + VAR + fbStateSetup: FB_StateSetupHelper; + stDefault: ST_PositionState; + END_VAR + VAR CONSTANT + cDelta: LREAL := 0.5; + cVelocity: LREAL := 10; + cMoveOk: BOOL := TRUE; + cValid: BOOL := TRUE; + END_VAR + TEST('TestNormalCase'); + // Mimic what I might do in a real project + + stDefault.fDelta := cDelta; + stDefault.fVelocity := cVelocity; + stDefault.bMoveOk := cMoveOk; + stDefault.bValid := cValid; + + fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE); + fbStateSetup(stPositionState:=astStates[1], sName:='OUT', fPosition:=10, sPmpsState:='FAKE_OUT'); + fbStateSetup(stPositionState:=astStates[2], sName:='YAG', fPosition:=20, sPmpsState:='FAKE_YAG'); + fbStateSetup(stPositionState:=astStates[3], sName:='TT', fPosition:=30, sPmpsState:='FAKE_TT'); + + // Check everything + AssertEquals_STRING('OUT', astStates[1].sName, 'Wrong sName in state 1'); + AssertEquals_LREAL(10, astStates[1].fPosition, 0, 'Wrong fPosition in state 1'); + AssertEquals_UDINT(stDefaultDefault.nEncoderCount, astStates[1].nEncoderCount, 'Wrong nEncoderCount in state 1'); + AssertEquals_LREAL(cDelta, astStates[1].fDelta, 0, 'Wrong fDelta in state 1'); + AssertEquals_LREAL(cVelocity, astStates[1].fVelocity, 0, 'Wrong fVelocity in state 1'); + AssertEquals_LREAL(stDefaultDefault.fAccel, astStates[1].fAccel, 0, 'Wrong fAccel in state 1'); + AssertEquals_LREAL(stDefaultDefault.fDecel, astStates[1].fDecel, 0, 'Wrong fDecel in state 1'); + AssertEquals_BOOL(cMoveOk, astStates[1].bMoveOk, 'Wrong bMoveOk in state 1'); + AssertEquals_BOOL(stDefaultDefault.bLocked, astStates[1].bLocked, 'Wrong bLocked in state 1'); + AssertEquals_BOOL(cValid, astStates[1].bValid, 'Wrong bValid in state 1'); + AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, astStates[1].bUseRawCounts, 'Wrong bUseRawCounts in state 1'); + AssertEquals_STRING('FAKE_OUT', astStates[1].stPMPS.sPmpsState, 'Wrong sPmpsState in state 1'); + + AssertEquals_STRING('YAG', astStates[2].sName, 'Wrong sName in state 2'); + AssertEquals_LREAL(20, astStates[2].fPosition, 0, 'Wrong fPosition in state 2'); + AssertEquals_UDINT(stDefaultDefault.nEncoderCount, astStates[2].nEncoderCount, 'Wrong nEncoderCount in state 2'); + AssertEquals_LREAL(cDelta, astStates[2].fDelta, 0, 'Wrong fDelta in state 2'); + AssertEquals_LREAL(cVelocity, astStates[2].fVelocity, 0, 'Wrong fVelocity in state 2'); + AssertEquals_LREAL(stDefaultDefault.fAccel, astStates[2].fAccel, 0, 'Wrong fAccel in state 2'); + AssertEquals_LREAL(stDefaultDefault.fDecel, astStates[2].fDecel, 0, 'Wrong fDecel in state 2'); + AssertEquals_BOOL(cMoveOk, astStates[2].bMoveOk, 'Wrong bMoveOk in state 2'); + AssertEquals_BOOL(stDefaultDefault.bLocked, astStates[2].bLocked, 'Wrong bLocked in state 2'); + AssertEquals_BOOL(cValid, astStates[2].bValid, 'Wrong bValid in state 2'); + AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, astStates[2].bUseRawCounts, 'Wrong bUseRawCounts in state 2'); + AssertEquals_STRING('FAKE_YAG', astStates[2].stPMPS.sPmpsState, 'Wrong sPmpsState in state 2'); + + AssertEquals_STRING('TT', astStates[3].sName, 'Wrong sName in state 3'); + AssertEquals_LREAL(30, astStates[3].fPosition, 0, 'Wrong fPosition in state 3'); + AssertEquals_UDINT(stDefaultDefault.nEncoderCount, astStates[3].nEncoderCount, 'Wrong nEncoderCount in state 3'); + AssertEquals_LREAL(cDelta, astStates[3].fDelta, 0, 'Wrong fDelta in state 3'); + AssertEquals_LREAL(cVelocity, astStates[3].fVelocity, 0, 'Wrong fVelocity in state 3'); + AssertEquals_LREAL(stDefaultDefault.fAccel, astStates[3].fAccel, 0, 'Wrong fAccel in state 3'); + AssertEquals_LREAL(stDefaultDefault.fDecel, astStates[3].fDecel, 0, 'Wrong fDecel in state 3'); + AssertEquals_BOOL(cMoveOk, astStates[3].bMoveOk, 'Wrong bMoveOk in state 3'); + AssertEquals_BOOL(stDefaultDefault.bLocked, astStates[3].bLocked, 'Wrong bLocked in state 3'); + AssertEquals_BOOL(cValid, astStates[3].bValid, 'Wrong bValid in state 3'); + AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, astStates[3].bUseRawCounts, 'Wrong bUseRawCounts in state 3'); + AssertEquals_STRING('FAKE_TT', astStates[3].stPMPS.sPmpsState, 'Wrong sPmpsState in state 3'); + + TEST_FINISHED(); + END_METHOD + + METHOD TestOnlyOnce + VAR + fbStateSetup: FB_StateSetupHelper; + stDefault: ST_PositionState; + stTarget: ST_PositionState; + END_VAR + TEST('TestOnlyOnce'); + + // Required call, even though we don't need anything here + fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE); + // Start with no position + AssertEquals_LREAL(stTarget.fPosition, 0, 0, 'Start position sanity check failed'); + // Apply a new position + fbStateSetup(stPositionState:=stTarget, fPosition:=10); + AssertEquals_LREAL(stTarget.fPosition, 10, 0, 'Basic set position failed'); + // Simulate the position state being used and updated via EPICS or otherwise + stTarget.bUpdated := TRUE; // Set by FB_PositionStateInternal + stTarget.fPosition := 12; // Someone tweaked the value in EPICS + // Run through the state setup again + fbStateSetup(stPositionState:=stTarget, fPosition:=10); + // But we should still be at position 12 + AssertEquals_LREAL(stTarget.fPosition, 12, 0, 'FB_StateSetupHelper ran twice!'); + // Unless we override the behavior + fbStateSetup(stPositionState:=stTarget, bForceUpdate:=TRUE, fPosition:=10); + AssertEquals_LREAL(stTarget.fPosition, 10, 0, 'bForceUpdate failed'); + + TEST_FINISHED(); + END_METHOD + + +Related: + * `FB_PositionStateInternal`_ + * `FB_StateSetupHelper`_ + * `ST_PositionState`_ + + +FB_StatesInputHandler +^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_StatesInputHandler + (* + Handle the state enum EPICS input for any of the ND state function blocks. + + The desired behavior is: + - Trigger a move to a new state when the enum PV is written to + - Interrupt an ongoing move with a new one if the enum changes mid-move + - Stop the move if the enum is set to an invalid value + *) + VAR_IN_OUT + // The user's inputs from EPICS. This is an IN_OUT variable because we will write values back to this to help us detect when the same value is re-caput + stUserInput: ST_StateEpicsToPlc; + END_VAR + VAR_INPUT + // The bBusy boolean from the motion FB + bMoveBusy: BOOL; + // The starting state number to seed nCurrGoal with + nStartingState: UINT; + END_VAR + VAR_OUTPUT + // The goal index to input to the motion FB. This will be clamped to the range 0..GeneralConstants.MAX_STATES + nCurrGoal: UINT; + // The bExecute boolean to input to the motion FB + bExecMove: BOOL; + // The bReset boolean to input to the motion FB + bResetMove: BOOL; + END_VAR + VAR + nState: UINT; + bInit: BOOL; + nQueuedGoal: UINT; + bNewMove: BOOL; + END_VAR + VAR CONSTANT + IDLE: UINT := 0; + GOING: UINT := 1; + WAIT_STOP: UINT := 2; + END_VAR + bResetMove := stUserInput.bReset; + IF bResetMove OR NOT bInit THEN + bInit := TRUE; + stUserInput.nSetValue := 0; + nCurrGoal := nStartingState; + bExecMove := FALSE; + nState := IDLE; + bNewMove := FALSE; + END_IF + + IF stUserInput.nSetValue <> 0 THEN + nQueuedGoal := stUserInput.nSetValue; + bNewMove := TRUE; + END_IF + + CASE nState OF + IDLE: + IF bNewMove AND nQueuedGoal > 0 AND nQueuedGoal <= GeneralConstants.MAX_STATES THEN + // New request, currently idle -> ask for a move + nCurrGoal := nQueuedGoal; + bExecMove := TRUE; + bNewMove := FALSE; + ELSIF bMoveBusy THEN + // We're moving but used to be idle -> switch to GOING + nState := GOING; + END_IF + GOING: + IF bNewMove THEN + // New request, currently moving -> ask for a stop + nState := WAIT_STOP; + bExecMove := FALSE; + ELSIF NOT bMoveBusy THEN + nState := IDLE; + nQueuedGoal := 0; + bExecMove := FALSE; + END_IF + WAIT_STOP: + IF NOT bMoveBusy THEN + nState := IDLE; + END_IF + END_CASE + + // Help us detect if there is an EPICS put before the next cycle + stUserInput.nSetValue := 0; + stUserInput.bReset := FALSE; + + END_FUNCTION_BLOCK + + +Related: + * `ST_StateEpicsToPlc`_ + + +FB_TerminalError +^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_TerminalError + + VAR_INPUT + En : BOOL; + iTerminal_ID : INT; + bWcState : BOOL; + uiInfoData_State : UINT; + pErrorSystem : POINTER TO ST_ErrorSystem; //Pointer to the error system + END_VAR + + VAR_OUTPUT + EnO : BOOL; + bError : BOOL := FALSE; + END_VAR + + VAR + iStateError : UINT; + iOtherError : UINT; + ErrorData : DUT_TerminalError; + nErrSysCNT : UINT; + + //testing + bStateChanged : BOOL; //Indicate if state change happened + uiInfoData_State_Prev : UINT := 16#8; //Previous value of Infodata.State + bWcState_Prev : BOOL := FALSE; //Previous state of WcState + + //FB-s + + END_VAR + (* + Currently: + + Problem: + + TODO: + + *) + + //Connect EN to EnO + EnO:=En; + + //Check if pointer is OK + IF pErrorSystem=0 THEN RETURN; END_IF + + //Any difference from normal state creates an error + IF En AND (bWcState OR uiInfoData_State<>16#8) THEN + bError:=TRUE; + ELSE + bError:=FALSE; + END_IF + + //Change detection + IF uiInfoData_State <> uiInfoData_State_Prev OR bWcState <> bWcState_Prev THEN + bStateChanged := TRUE; + ELSE + bStateChanged := FALSE; + END_IF + + //Update previous values + uiInfoData_State_Prev := uiInfoData_State; + bWcState_Prev := bWcState; + + //Decision tree + IF bStateChanged THEN + IF bError THEN + IF ErrorData.ErrorState = DUT_ErrorState.Active THEN + //Close active error + //Read system time + ErrorData.nDateTimeOff := Tc2_EtherCAT.F_GetActualDcTime64(); + ErrorData.sDateTimeOff := Tc2_EtherCat.DCTIME64_TO_STRING(ErrorData.nDateTimeOff); + ErrorData.ErrorState := DUT_ErrorState.Inactive; + //Write Off-time to Error System + FOR nErrSysCNT := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO + IF pErrorSystem^.aErrorData[nErrSysCNT].Error_ID = ErrorData.Error_ID THEN + pErrorSystem^.aErrorData[nErrSysCNT].nDateTimeOff := ErrorData.nDateTimeOff; + pErrorSystem^.aErrorData[nErrSysCNT].sDateTimeOff := ErrorData.sDateTimeOff; + pErrorSystem^.aErrorData[nErrSysCNT].ErrorState := DUT_ErrorState.Inactive; + EXIT; + END_IF + END_FOR + + //Clear ErrorData + MEMSET(ADR(ErrorData), 0, SIZEOF(ErrorData)); + END_IF + + //Open a new error + ErrorData.ErrorState := DUT_ErrorState.Active; //Set Error State + ErrorData.nDateTimeOn := Tc2_EtherCAT.F_GetActualDcTime64(); //Get system time + ErrorData.sDateTimeOn := Tc2_EtherCat.DCTIME64_TO_STRING(ErrorData.nDateTimeOn); //Convert to string + ErrorData.iTerminalID := iTerminal_ID; //Terminal_ID + ErrorData.bWcState := bWcState; //WcState bit + ErrorData.uiInfoDataState := uiInfoData_State; //uiInfoData_State + + //Error message according to uiInfoData_State and WcState + iStateError := (uiInfoData_State AND 16#000F); //Mask for operation state + iOtherError := (uiInfoData_State AND 16#00F0); //Mask for the other 3 kind of errors + //Error messages according to the least significant digit + CASE iStateError OF + 16#0001 : ErrorData.sErrorMessage := 'Slave in INIT state; '; + 16#0002 : ErrorData.sErrorMessage := 'Slave in PREOP state; '; + 16#0003 : ErrorData.sErrorMessage := 'Slave in BOOT state; '; + 16#0004 : ErrorData.sErrorMessage := 'Slave in SAFEOP state; '; + 16#0008 : ; //Normal operation state + ELSE + ErrorData.sErrorMessage := 'Undefined State of operation; '; //I hope we will never see this message + ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, UINT_TO_STRING(iStateError)); + ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, ' '); + END_CASE + + //Error messages according to the second least significant digit + CASE iOtherError OF + 16#0000 : ; //No error case + 16#0010 : ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Slave signals error; '); + 16#0020 : ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Invalid vendorID/productCode read; '); + 16#0040 : ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Initialisation error occured; '); + ELSE + ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Undefined Error ID: '); + ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, UINT_TO_STRING(iOtherError)); + ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, ' '); + END_CASE + + //Errormessage according to WcState bit + IF bWcState THEN + ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Invalid Data;'); + END_IF + + //Check for overflow + IF pErrorSystem^.nNoErrors = GVL_ErrorSystem.cSizeOfErrorData THEN + pErrorSystem^.nNoOverflows := pErrorSystem^.nNoOverflows+1; + END_IF + + //Write Error Data into Error System + ErrorData.Error_ID := pErrorSystem^.lNextErrorID ; + MEMMOVE( ADR(pErrorSystem^.aErrorData[1]), ADR(pErrorSystem^.aErrorData[0]), (GVL_ErrorSystem.cSizeOfErrorData-1) * SIZEOF(DUT_TerminalError)); + pErrorSystem^.aErrorData[0] := ErrorData; + pErrorSystem^.lNextErrorID := pErrorSystem^.lNextErrorID+1; + + ELSE + //Close Active Error + //Read system time + ErrorData.nDateTimeOff := Tc2_EtherCAT.F_GetActualDcTime64(); + ErrorData.sDateTimeOff := Tc2_EtherCat.DCTIME64_TO_STRING(ErrorData.nDateTimeOff); + ErrorData.ErrorState := DUT_ErrorState.Inactive; + + //Write Off time to Error System + FOR nErrSysCNT := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO + IF pErrorSystem^.aErrorData[nErrSysCNT].Error_ID = ErrorData.Error_ID THEN + pErrorSystem^.aErrorData[nErrSysCNT].nDateTimeOff := ErrorData.nDateTimeOff; + pErrorSystem^.aErrorData[nErrSysCNT].sDateTimeOff := ErrorData.sDateTimeOff; + pErrorSystem^.aErrorData[nErrSysCNT].ErrorState := DUT_ErrorState.Inactive; + EXIT; + END_IF + END_FOR + + //Clear ErrorData + MEMSET(ADR(ErrorData), 0, SIZEOF(ErrorData)); + END_IF + END_IF + + END_FUNCTION_BLOCK + + +Related: + * `DUT_ErrorState`_ + * `DUT_TerminalError`_ + * `GVL_ErrorSystem`_ + * `ST_ErrorSystem`_ + + +FB_TestHelperSetAndMove +^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_TestHelperSetAndMove + (* + Set an stMotionStage to a start position, then cause a move. + On rising edge of bExecute, errors are cleared, the user enable is set to FALSE, and the position is set. + After the position is set, user enable is re-introduced and a move begins. + + The progress of this function block for the purposes of a unit test can be monitored via the outputs. + + The motion stage should have its own FB_MotionStage or some stand-in for it running on outside of the FB. + + This is, in itself, tested in FB_TestHelperSetAndMove_Test. + *) + VAR_IN_OUT + // The motion state to test with + stMotionStage: ST_MotionStage; + END_VAR + VAR_INPUT + // Begin on rising edge, stop on falling edge. + bExecute: BOOL; + // The position to set the motor to + fStartPosition: LREAL; + // The goal to move the motor towards + fGoalPosition: LREAL; + // The velocity to move at + fVelocity: LREAL; + // If TRUE, we'll set all the hardware enable signals. Leave this as FALSE if your testing involves any of the hardware enables. + bHWEnable: BOOL; + END_VAR + VAR_OUTPUT + // Goes to TRUE once the motor has no errors and is deactivated. + bResetDone: BOOL; + // Goes to TRUE once the set position completes. + bSetDone: BOOL; + // Goes to TRUE once the motor begins moving. + bMotionStarted: BOOL; + // Goes to TRUE once the motor reaches its destination. + bMoveDone: BOOL; + // If bBusy is FALSE, the function block is ready for a new request. Goes to TRUE after bExecute rises and back to FALSE after bMoveDone or bError rises. Also goes to FALSE after the motor stops following bExecute being dropped to FALSE. + bBusy: BOOL; + // Goes to TRUE in case of an error from FB_MotionRequest + bError: BOOL; + // Counts up from bExecute's rising trigger. Can be used to implement a timeout. + tElapsed: TIME; + // Current motor position in case you're looking for it + fActPosition: LREAL; + // Goes to TRUE if we're trying to stop a move. We'll stop an in-progress move when bExecute goes to FALSE, and we'll make sure the motor fully stops before responding to the next bExecute rising edge. + bStoppingMotor: BOOL; + END_VAR + VAR + fbMoveRequest: FB_MotionRequest; + mcSetPos: MC_SetPosition; + tonTimeout: TON; + rtExec: R_TRIG; + ftExec: F_TRIG; + bExecQueued: BOOL; + nLatchError: UDINT; + END_VAR + tonTimeout( + IN:=bExecute, + PT:=T#1h, + ET=>tElapsed, + ); + rtExec(CLK:=bExecute); + ftExec(CLK:=bExecute); + + // Set the outputs to known values on exec + bResetDone R= rtExec.Q; + bSetDone R= rtExec.Q; + bMotionStarted R= rtExec.Q; + bMoveDone R= rtExec.Q; + bBusy S= rtExec.Q; + bError R= rtExec.Q; + + bExecQueued S= rtExec.Q; + bExecQueued R= ftExec.Q; + bStoppingMotor S= ftExec.Q; + + // Set the hardware enables if asked + IF bHWEnable THEN + stMotionStage.bLimitForwardEnable := TRUE; + stMotionStage.bLimitBackwardEnable := TRUE; + stMotionStage.bHardwareEnable := TRUE; + stMotionStage.bPowerSelf := TRUE; + END_IF + + + // Note that we only reset if it's needed, e.g. the motor has an error or is enabled or moving etc. etc. + bResetDone S= stMotionStage.bError = FALSE AND stMotionStage.bBusy = FALSE AND stMotionStage.bAllEnable = FALSE; + + // All uses of fbMoveRequest are in this IF/ELSE tree + IF bStoppingMotor THEN + // Continue stopping the motor from previous cycles + fbMoveRequest( + stMotionStage:=stMotionStage, + bExecute:=FALSE, + ); + stMotionStage.bExecute := FALSE; + bStoppingMotor R= NOT stMotionStage.Axis.Status.ControlLoopClosed AND NOT fbMoveRequest.bBusy; + ELSIF bExecQueued THEN + // First exec cycle: bring these to FALSE for later use + bExecQueued := FALSE; + stMotionStage.bUserEnable := FALSE; + fbMoveRequest( + stMotionStage:=stMotionStage, + bExecute:=FALSE, + bReset:=FALSE, + ); + ELSIF NOT bResetDone THEN + // Other cycles: reset until we're done resetting + fbMoveRequest( + stMotionStage:=stMotionStage, + bReset:=bExecute, + ); + ELSIF fStartPosition <> fGoalPosition THEN + // Later: do the move + // Important to not enable the motor until the set position is done + stMotionStage.bUserEnable := bSetDone; + fbMoveRequest( + stMotionStage:=stMotionStage, + bExecute:=bSetDone AND bExecute AND NOT bMoveDone AND NOT bError, + bReset:=FALSE, + enumMotionRequest:=E_MotionRequest.INTERRUPT, + fPos:=fGoalPosition, + fVel:=fVelocity, + ); + bMotionStarted S= bSetDone AND fbMoveRequest.bExecute AND stMotionStage.bBusy AND stMotionStage.stAxisStatus.fActPosition <> fStartPosition; + bMoveDone S= bMotionStarted AND stMotionStage.stAxisStatus.fActPosition = fGoalPosition; + END_IF + + // Set the position prior to the move but after the reset. + mcSetPos( + Axis:=stMotionStage.Axis, + Execute:=bResetDone AND bExecute AND NOT bSetDone AND NOT bError, + Position:=fStartPosition, + ); + IF mcSetPos.Done OR mcSetPos.Error THEN + nLatchError := mcSetPos.ErrorID; + END_IF + bSetDone S= mcSetPos.Done AND NOT mcSetPos.Error AND stMotionStage.stAxisStatus.fActPosition = fStartPosition; + + // Any sub-error is an error here + bError := fbMoveRequest.bError OR mcSetPos.Error; + + // Reset bBusy when appropriate + bBusy R= (bMoveDone AND NOT bStoppingMotor) OR bError OR ftExec.Q; + + // Extract the motor position + fActPosition := stMotionStage.stAxisStatus.fActPosition; + + END_FUNCTION_BLOCK + + +Related: + * `E_MotionRequest`_ + * `FB_MotionRequest`_ + * `FB_MotionStage`_ + * `FB_TestHelperSetAndMove_Test`_ + * `ST_MotionStage`_ + + +FB_TestHelperSetAndMove_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + FUNCTION_BLOCK FB_TestHelperSetAndMove_Test EXTENDS TcUnit.FB_TestSuite + (* + Ensure that the test helper function block works as needed. + Without this, all tests that need motion cannot pass. + *) + VAR + stMotionStage: ST_MotionStage; + fbMotionStage: FB_MotionStage; + fbTestMove: FB_TestHelperSetAndMove; + rtResetDone: R_TRIG; + rtSetDone: R_TRIG; + rtMotionStart: R_TRIG; + rtMoveDone: R_TRIG; + END_VAR + fbMotionStage(stMotionStage:=stMotionstage); + BasicMotion(); + + END_FUNCTION_BLOCK + + METHOD PRIVATE BasicMotion + VAR_INPUT + END_VAR + TEST('BasicMotion'); + + IF NOT fbTestMove.bExecute THEN + stMotionStage.bError := TRUE; + END_IF + fbTestMove( + stMotionStage:=stMotionStage, + bExecute:=TRUE, + fStartPosition:=15.0, + fGoalPosition:=17.0, + fVelocity:=1.0, + bHWEnable:=TRUE, + ); + rtResetDone(CLK:=fbTestMove.bResetDone); + rtSetDone(CLK:=fbTestMove.bSetDone); + rtMotionStart(CLK:=fbTestMove.bMotionStarted); + rtMoveDone(CLK:=fbTestMove.bMoveDone); + IF rtResetDone.Q THEN + AssertFalse( + Condition:=stMotionStage.bError, + Message:='Reset did not clear error', + ); + AssertEquals_LREAL( + Expected:=stMotionStage.stAxisStatus.fActPosition, + Actual:=fbTestMove.fActPosition, + Delta:=0, + Message:='Real position output does not match real position.', + ); + END_IF + IF rtSetDone.Q THEN + AssertEquals_LREAL( + Expected:=fbTestMove.fStartPosition, + Actual:=fbTestMove.fActPosition, + Delta:=0, + Message:='Was not set to start position after set done', + ); + END_IF + IF rtMotionStart.Q THEN + AssertTrue( + Condition:=stMotionStage.bBusy, + Message:='stMotionStage is not busy, but motion is said to have started.', + ); + AssertTrue( + Condition:=fbTestMove.fActPosition > fbTestMove.fStartPosition, + Message:='stMotionStage has not moved, but motion is said to have started.', + ); + END_IF + IF rtMoveDone.Q THEN + AssertEquals_LREAL( + Expected:=fbTestMove.fGoalPosition, + Actual:=fbTestMove.fActPosition, + Delta:=0.001, + Message:='Did not reach destination at move done', + ); + END_IF + IF fbTestMove.bError OR fbTestMove.tElapsed > T#5s OR (fbTestMove.bResetDone AND fbTestMove.bSetDone AND fbTestMove.bMotionStarted AND fbTestMove.bMoveDone) THEN + AssertFalse( + Condition:=fbTestMove.bError, + Message:='Error in fbTestMove', + ); + AssertFalse( + Condition:=fbTestMove.tElapsed > T#5s, + Message:='Timeout in basic motion test', + ); + TEST_FINISHED(); + END_IF + END_METHOD + + +Related: + * `FB_MotionStage`_ + * `FB_TestHelperSetAndMove`_ + * `ST_MotionStage`_ + + +FB_WriteFloatParameter +^^^^^^^^^^^^^^^^^^^^^^ + +:: + + ///######################################################### + ///Function block to write parameter in Nc. + /// + /// Library: + /// Tc2_MC2.lib + /// Tc2_System.lib + /// + /// Global Variables: + /// + /// Data types: + /// + /// External functions: + /// + /// History: + /// 2014-02-05 v1.00 NB Release code. + /// + /// Known bugs: + /// + /// + /// + ///########################################################### + FUNCTION_BLOCK FB_WriteFloatParameter + VAR_INPUT + bExecute: BOOL; + ///16#4000=Axisdata, 16#5000=Encoderdata, 16#6000=Controldata, 16#7000=Drivedata + nDeviceGroup: UDINT; + nIndexOffset: UDINT; + nData: LREAL; + END_VAR + VAR_OUTPUT + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR + nState: UINT; + fbADSWRITE: ADSWRITE; + END_VAR + (*Sequence to write parameter in Nc*) + CASE nState OF + 0: (*Start sequence. Wait until bExecute is TRUE*) + IF bExecute THEN + bBusy:=TRUE; + bError:=FALSE; + nErrorId:=0; + nState:=10; + END_IF + + 10: (*Write parameter in Nc*) + fbADSWRITE( + PORT:=500, + IDXGRP:=nDeviceGroup+Axis.NcToPlc.AxisId, + IDXOFFS:=nIndexOffset, + LEN:=SIZEOF(nData), + SRCADDR:=ADR(nData), + WRITE:=TRUE); + + (*Wait until it's done or if an error occurs*) + IF NOT fbADSWRITE.ERR THEN + IF NOT fbADSWRITE.BUSY THEN + fbADSWRITE(WRITE:=FALSE); + nState:=20; + END_IF + ELSE + nErrorId:=fbADSWRITE.ERRID; + nState:=999; + END_IF + + 20: (*Sequense is done. Waits until bExecute is FALSE*) + bBusy:=FALSE; + bDone:=TRUE; + IF NOT bExecute THEN + bDone:=FALSE; + nState:=0; + END_IF + + 999: (*Error in sequence*) + bError:=TRUE; + bBusy:=FALSE; + bDone:=FALSE; + fbADSWRITE(WRITE:=FALSE); + IF NOT bExecute THEN + nState:=0; + END_IF + + END_CASE + + END_FUNCTION_BLOCK + + + + +FB_WriteParameterInNc_v1_00 +^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +:: + + ///######################################################### + ///Function block to write parameter in Nc. + /// + /// Library: + /// Tc2_MC2.lib + /// Tc2_System.lib + /// + /// Global Variables: + /// + /// Data types: + /// + /// External functions: + /// + /// History: + /// 2014-02-05 v1.00 NB Release code. + /// + /// Known bugs: + /// + /// + /// + ///########################################################### + FUNCTION_BLOCK FB_WriteParameterInNc_v1_00 + VAR_INPUT + bExecute: BOOL; + ///16#4000=Axisdata, 16#5000=Encoderdata, 16#6000=Controldata, 16#7000=Drivedata + nDeviceGroup: UDINT; + nIndexOffset: UDINT; + nData: DWORD; + END_VAR + VAR_OUTPUT + bBusy: BOOL; + bDone: BOOL; + bError: BOOL; + nErrorId: UDINT; + END_VAR + VAR_IN_OUT + Axis: AXIS_REF; + END_VAR + VAR + nState: UINT; + fbADSWRITE: ADSWRITE; + END_VAR + (*Sequence to write parameter in Nc*) + CASE nState OF + 0: (*Start sequence. Wait until bExecute is TRUE*) + IF bExecute THEN + bBusy:=TRUE; + bError:=FALSE; + nErrorId:=0; + nState:=10; + END_IF + + 10: (*Write parameter in Nc*) + fbADSWRITE( + PORT:=500, + IDXGRP:=nDeviceGroup+Axis.NcToPlc.AxisId, + IDXOFFS:=nIndexOffset, + LEN:=SIZEOF(nData), + SRCADDR:=ADR(nData), + WRITE:=TRUE); + + (*Wait until it's done or if an error occurs*) + IF NOT fbADSWRITE.ERR THEN + IF NOT fbADSWRITE.BUSY THEN + fbADSWRITE(WRITE:=FALSE); + nState:=20; + END_IF + ELSE + nErrorId:=fbADSWRITE.ERRID; + nState:=999; + END_IF + + 20: (*Sequense is done. Waits until bExecute is FALSE*) + bBusy:=FALSE; + bDone:=TRUE; + IF NOT bExecute THEN + bDone:=FALSE; + nState:=0; + END_IF + + 999: (*Error in sequence*) + bError:=TRUE; + bBusy:=FALSE; + bDone:=FALSE; + fbADSWRITE(WRITE:=FALSE); + IF NOT bExecute THEN + nState:=0; + END_IF + + END_CASE + + END_FUNCTION_BLOCK + + + + +PRG_TEST +^^^^^^^^ + +:: + + PROGRAM PRG_TEST + VAR + fb_TestHelperSetAndMove_Test: FB_TestHelperSetAndMove_Test; + fb_AtPositionState_Test: FB_AtPositionState_Test; + fb_PositionStateRead_Test: FB_PositionStateRead_Test; + fb_PositionStateReadND_Test: FB_PositionStateReadND_Test; + fb_PositionStateMove_Test: FB_PositionStateMove_Test; + fb_PositionStateMoveND_Test: FB_PositionStateMoveND_Test; + fb_PositionStateND_Test: FB_PositionStateND_Test; + fb_NCErrorFFO_Test: FB_NCErrorFFO_Test; + fb_MiscStatesErrorFFO_Test: FB_MiscStatesErrorFFO_Test; + fb_MotionBPTM_Test: FB_MotionBPTM_Test; + fb_MotionClearAsserts_Test: FB_MotionClearAsserts_Test; + fb_StatePMPSEnables_Test: FB_StatePMPSEnables_Test; + fb_MotionReadPMPSDBND_Test: FB_MotionReadPMPSDBND_Test; + fb_PerMotorFFOND_Test: FB_PerMotorFFOND_Test; + fb_StatePMPSEnablesND_Test: FB_StatePMPSEnablesND_Test; + fb_PositionStatePMPSND_Test: FB_PositionStatePMPSND_Test; + fb_StateSetupHelper_Test: FB_StateSetupHelper_Test; + END_VAR + TcUnit.RUN(); + + END_PROGRAM + + +Related: + * `FB_AtPositionState_Test`_ + * `FB_MiscStatesErrorFFO_Test`_ + * `FB_MotionBPTM_Test`_ + * `FB_MotionClearAsserts_Test`_ + * `FB_MotionReadPMPSDBND_Test`_ + * `FB_NCErrorFFO_Test`_ + * `FB_PerMotorFFOND_Test`_ + * `FB_PositionStateMoveND_Test`_ + * `FB_PositionStateMove_Test`_ + * `FB_PositionStateND_Test`_ + * `FB_PositionStatePMPSND_Test`_ + * `FB_PositionStateReadND_Test`_ + * `FB_PositionStateRead_Test`_ + * `FB_StatePMPSEnablesND_Test`_ + * `FB_StatePMPSEnables_Test`_ + * `FB_StateSetupHelper_Test`_ + * `FB_TestHelperSetAndMove_Test`_ + diff --git a/v4.0.3/_sources/lcls-twincat-motion_Library_summary.rst.txt b/v4.0.3/_sources/lcls-twincat-motion_Library_summary.rst.txt new file mode 100644 index 00000000..1f10125f --- /dev/null +++ b/v4.0.3/_sources/lcls-twincat-motion_Library_summary.rst.txt @@ -0,0 +1,54 @@ + +Settings +-------- + +.. list-table:: + :header-rows: 1 + :align: center + + * - Setting + - Value + - Description + * - AMS Net ID + - 172.21.148.148.1.1 + - + * - Target IP address + - 172.21.148.148 + - Based on AMS Net ID by convention + * - AMS Port + - 851 + - + +.. _Library_pragmas: + +Pragmas +------- + +Total pragmas found: 190 +Total linter errors: 0 + + + +Libraries +--------- + +.. csv-table:: + :header: Library, Vendor, Default, Version + :align: center + + LCLS General, SLAC, Unset, Unset + PMPS, SLAC - LCLS, Unset, Unset + Tc2_EtherCAT, Beckhoff Automation GmbH, Unset, Unset + Tc2_Math, Beckhoff Automation GmbH, Unset, Unset + Tc2_MC2, Beckhoff Automation GmbH, Unset, Unset + Tc2_Standard, Beckhoff Automation GmbH, Unset, Unset + Tc2_System, Beckhoff Automation GmbH, Unset, Unset + Tc2_Utilities, Beckhoff Automation GmbH, Unset, Unset + Tc3_JsonXml, Beckhoff Automation GmbH, Unset, Unset + Tc3_Module, Beckhoff Automation GmbH, Unset, Unset + TcUnit, www.tcunit.org, Unset, Unset + +Symbols +------- + + diff --git a/v4.0.3/_sources/lcls-twincat-motion_boxes.rst.txt b/v4.0.3/_sources/lcls-twincat-motion_boxes.rst.txt new file mode 100644 index 00000000..9559c0e2 --- /dev/null +++ b/v4.0.3/_sources/lcls-twincat-motion_boxes.rst.txt @@ -0,0 +1,4 @@ + +Boxes +----- + diff --git a/v4.0.3/_sources/lcls-twincat-motion_ethercat.rst.txt b/v4.0.3/_sources/lcls-twincat-motion_ethercat.rst.txt new file mode 100644 index 00000000..e4b69c7f --- /dev/null +++ b/v4.0.3/_sources/lcls-twincat-motion_ethercat.rst.txt @@ -0,0 +1,3 @@ +Box Hierarchy +------------- + diff --git a/v4.0.3/_sources/lcls-twincat-motion_links.rst.txt b/v4.0.3/_sources/lcls-twincat-motion_links.rst.txt new file mode 100644 index 00000000..87f183a7 --- /dev/null +++ b/v4.0.3/_sources/lcls-twincat-motion_links.rst.txt @@ -0,0 +1,50 @@ + +Links +----- + +.. csv-table:: + :header: Owner A, Item A, Owner B, Item B + :align: center + + InputDst, PRG_TEST.fb_StatePMPSLimits_Test.stMotionStage.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_StatePMPSLimits_Test, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_AtPositionState_Test.stMotionStage.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_AtPositionState_Test, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_NCErrorFFO_Test.stMotionStage.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_NCErrorFFO_Test, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateMoveND_Test.astMotionStage[1].Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateMoveND_Test_1, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateMoveND_Test.astMotionStage[2].Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateMoveND_Test_2, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateMoveND_Test.astMotionStage[3].Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateMoveND_Test_3, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateMove_Test.stMotionStage.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateMove_Test, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateND_Test.stMotionStage1.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateND_Test_1, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateND_Test.stMotionStage2.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateND_Test_2, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateND_Test.stMotionStage3.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateND_Test_3, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStatePMPSND_Test.stMotionStage1.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStatePMPSND_Test_1, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStatePMPSND_Test.stMotionStage2.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStatePMPSND_Test_2, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStatePMPSND_Test.stMotionStage3.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStatePMPSND_Test_3, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateReadND_Test.astMotionStage[1].Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_1, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateReadND_Test.astMotionStage[2].Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_2, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateReadND_Test.astMotionStage[3].Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_3, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateReadND_Test.astSqMotionStage[1].Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_4, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateReadND_Test.astSqMotionStage[2].Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_5, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_PositionStateRead_Test.stMotionStage.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateRead_Test, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_StatePMPSEnables_Test.stMotionStage.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_StatePMPSEnable_Test, Outputs^ToPlc + Library Instance, PlcTask Inputs^PRG_TEST.fb_TestHelperSetAndMove_Test.stMotionStage.Axis.NcToPlc, TINC^NC-Task 1 SAF^Axes^Axis_TestHelperSetAndMove_Test, Outputs^ToPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_AtPositionState_Test.stMotionStage.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_AtPositionState_Test, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_NCErrorFFO_Test.stMotionStage.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_NCErrorFFO_Test, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateMoveND_Test.astMotionStage[1].Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateMoveND_Test_1, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateMoveND_Test.astMotionStage[2].Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateMoveND_Test_2, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateMoveND_Test.astMotionStage[3].Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateMoveND_Test_3, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateMove_Test.stMotionStage.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateMove_Test, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateND_Test.stMotionStage1.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateND_Test_1, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateND_Test.stMotionStage2.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateND_Test_2, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateND_Test.stMotionStage3.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateND_Test_3, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStatePMPSND_Test.stMotionStage1.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStatePMPSND_Test_1, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStatePMPSND_Test.stMotionStage2.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStatePMPSND_Test_2, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStatePMPSND_Test.stMotionStage3.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStatePMPSND_Test_3, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateReadND_Test.astMotionStage[1].Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_1, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateReadND_Test.astMotionStage[2].Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_2, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateReadND_Test.astMotionStage[3].Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_3, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateReadND_Test.astSqMotionStage[1].Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_4, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateReadND_Test.astSqMotionStage[2].Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateReadND_Test_5, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_PositionStateRead_Test.stMotionStage.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_PositionStateRead_Test, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_StatePMPSEnables_Test.stMotionStage.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_StatePMPSEnable_Test, Inputs^FromPlc + Library Instance, PlcTask Outputs^PRG_TEST.fb_TestHelperSetAndMove_Test.stMotionStage.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_TestHelperSetAndMove_Test, Inputs^FromPlc + OutputSrc, PRG_TEST.fb_StatePMPSLimits_Test.stMotionStage.Axis.PlcToNc, TINC^NC-Task 1 SAF^Axes^Axis_StatePMPSLimits_Test, Inputs^FromPlc diff --git a/v4.0.3/_sources/lcls-twincat-motion_nc.rst.txt b/v4.0.3/_sources/lcls-twincat-motion_nc.rst.txt new file mode 100644 index 00000000..aaeeb5a3 --- /dev/null +++ b/v4.0.3/_sources/lcls-twincat-motion_nc.rst.txt @@ -0,0 +1,390 @@ + +NC Settings +----------- + +.. csv-table:: + :header: Axis ID, Name + :align: center + + 3, Axis_PositionStateRead_Test + 4, Axis_AtPositionState_Test + 5, Axis_TestHelperSetAndMove_Test + 6, Axis_PositionStateReadND_Test_1 + 7, Axis_PositionStateReadND_Test_2 + 8, Axis_PositionStateReadND_Test_3 + 9, Axis_PositionStateMove_Test + 10, Axis_PositionStateMoveND_Test_1 + 11, Axis_PositionStateMoveND_Test_2 + 12, Axis_PositionStateMoveND_Test_3 + 13, Axis_PositionStateND_Test_1 + 14, Axis_PositionStateND_Test_2 + 15, Axis_PositionStateND_Test_3 + 16, Axis_NCErrorFFO_Test + 17, Axis_PositionStatePMPSND_Test_1 + 18, Axis_PositionStatePMPSND_Test_2 + 19, Axis_PositionStatePMPSND_Test_3 + 20, Axis_StatePMPSEnable_Test + 21, Axis_PositionStateReadND_Test_4 + 22, Axis_PositionStateReadND_Test_5 + + + +Axis 3: Axis_PositionStateRead_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 3 + Name, Axis_PositionStateRead_Test + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 3 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 4: Axis_AtPositionState_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 4 + Name, Axis_AtPositionState_Test + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 4 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 5: Axis_TestHelperSetAndMove_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 5 + Name, Axis_TestHelperSetAndMove_Test + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 5 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 6: Axis_PositionStateReadND_Test_1 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 6 + Name, Axis_PositionStateReadND_Test_1 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 6 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 7: Axis_PositionStateReadND_Test_2 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 7 + Name, Axis_PositionStateReadND_Test_2 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 7 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 8: Axis_PositionStateReadND_Test_3 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 8 + Name, Axis_PositionStateReadND_Test_3 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 8 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 9: Axis_PositionStateMove_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 9 + Name, Axis_PositionStateMove_Test + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 9 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 10: Axis_PositionStateMoveND_Test_1 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 10 + Name, Axis_PositionStateMoveND_Test_1 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 10 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 11: Axis_PositionStateMoveND_Test_2 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 11 + Name, Axis_PositionStateMoveND_Test_2 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 11 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 12: Axis_PositionStateMoveND_Test_3 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 12 + Name, Axis_PositionStateMoveND_Test_3 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 12 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 13: Axis_PositionStateND_Test_1 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 13 + Name, Axis_PositionStateND_Test_1 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 13 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 14: Axis_PositionStateND_Test_2 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 14 + Name, Axis_PositionStateND_Test_2 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 14 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 15: Axis_PositionStateND_Test_3 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 15 + Name, Axis_PositionStateND_Test_3 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 15 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 16: Axis_NCErrorFFO_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 16 + Name, Axis_NCErrorFFO_Test + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 16 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 17: Axis_PositionStatePMPSND_Test_1 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 17 + Name, Axis_PositionStatePMPSND_Test_1 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 17 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 18: Axis_PositionStatePMPSND_Test_2 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 18 + Name, Axis_PositionStatePMPSND_Test_2 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 18 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 19: Axis_PositionStatePMPSND_Test_3 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 19 + Name, Axis_PositionStatePMPSND_Test_3 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 19 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 20: Axis_StatePMPSEnable_Test +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 20 + Name, Axis_StatePMPSEnable_Test + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 20 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 21: Axis_PositionStateReadND_Test_4 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 21 + Name, Axis_PositionStateReadND_Test_4 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 21 + OtherSettings:AllowMotionCmdToSlave, true + + + +Axis 22: Axis_PositionStateReadND_Test_5 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. csv-table:: + :header: Setting, Value + :align: center + + Axis ID, 22 + Name, Axis_PositionStateReadND_Test_5 + AxisFolder, Unit Test Axes + AxisType, 1 + CreateSymbols, true + Enc:EncType, 1 + Id, 22 + OtherSettings:AllowMotionCmdToSlave, true + + diff --git a/v4.0.3/_sources/lcls-twincat-motion_pragmas.rst.txt b/v4.0.3/_sources/lcls-twincat-motion_pragmas.rst.txt new file mode 100644 index 00000000..45681e8e --- /dev/null +++ b/v4.0.3/_sources/lcls-twincat-motion_pragmas.rst.txt @@ -0,0 +1,21 @@ + +Pragmas +------- + +.. csv-table:: + :header: PLC Name, Total Pragmas, Errors + :align: center + + :ref:`Library `, 190, 0 + + +.. _Library_overview_pragmas: + + +Library +^^^^^^^ + +Total pragmas found: 190 +Total linter errors: 0 + + diff --git a/v4.0.3/_static/_sphinx_javascript_frameworks_compat.js b/v4.0.3/_static/_sphinx_javascript_frameworks_compat.js new file mode 100644 index 00000000..81415803 --- /dev/null +++ b/v4.0.3/_static/_sphinx_javascript_frameworks_compat.js @@ -0,0 +1,123 @@ +/* Compatability shim for jQuery and underscores.js. + * + * Copyright Sphinx contributors + * Released under the two clause BSD licence + */ + +/** + * small helper function to urldecode strings + * + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL + */ +jQuery.urldecode = function(x) { + if (!x) { + return x + } + return decodeURIComponent(x.replace(/\+/g, ' ')); +}; + +/** + * small helper function to urlencode strings + */ +jQuery.urlencode = encodeURIComponent; + +/** + * This function returns the parsed url parameters of the + * current request. Multiple values per key are supported, + * it will always return arrays of strings for the value parts. + */ +jQuery.getQueryParameters = function(s) { + if (typeof s === 'undefined') + s = document.location.search; + var parts = s.substr(s.indexOf('?') + 1).split('&'); + var result = {}; + for (var i = 0; i < parts.length; i++) { + var tmp = parts[i].split('=', 2); + var key = jQuery.urldecode(tmp[0]); + var value = jQuery.urldecode(tmp[1]); + if (key in result) + result[key].push(value); + else + result[key] = [value]; + } + return result; +}; + +/** + * highlight a given string on a jquery object by wrapping it in + * span elements with the given class name. + */ +jQuery.fn.highlightText = function(text, className) { + function highlight(node, addItems) { + if (node.nodeType === 3) { + var val = node.nodeValue; + var pos = val.toLowerCase().indexOf(text); + if (pos >= 0 && + !jQuery(node.parentNode).hasClass(className) && + !jQuery(node.parentNode).hasClass("nohighlight")) { + var span; + var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.className = className; + } + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + node.parentNode.insertBefore(span, node.parentNode.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling)); + node.nodeValue = val.substr(0, pos); + if (isInSVG) { + var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); + var bbox = node.parentElement.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute('class', className); + addItems.push({ + "parent": node.parentNode, + "target": rect}); + } + } + } + else if (!jQuery(node).is("button, select, textarea")) { + jQuery.each(node.childNodes, function() { + highlight(this, addItems); + }); + } + } + var addItems = []; + var result = this.each(function() { + highlight(this, addItems); + }); + for (var i = 0; i < addItems.length; ++i) { + jQuery(addItems[i].parent).before(addItems[i].target); + } + return result; +}; + +/* + * backward compatibility for jQuery.browser + * This will be supported until firefox bug is fixed. + */ +if (!jQuery.browser) { + jQuery.uaMatch = function(ua) { + ua = ua.toLowerCase(); + + var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || + /(webkit)[ \/]([\w.]+)/.exec(ua) || + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || + /(msie) ([\w.]+)/.exec(ua) || + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || + []; + + return { + browser: match[ 1 ] || "", + version: match[ 2 ] || "0" + }; + }; + jQuery.browser = {}; + jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; +} diff --git a/v4.0.3/_static/basic.css b/v4.0.3/_static/basic.css new file mode 100644 index 00000000..30fee9d0 --- /dev/null +++ b/v4.0.3/_static/basic.css @@ -0,0 +1,925 @@ +/* + * basic.css + * ~~~~~~~~~ + * + * Sphinx stylesheet -- basic theme. + * + * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/* -- main layout ----------------------------------------------------------- */ + +div.clearer { + clear: both; +} + +div.section::after { + display: block; + content: ''; + clear: left; +} + +/* -- relbar ---------------------------------------------------------------- */ + +div.related { + width: 100%; + font-size: 90%; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* -- sidebar --------------------------------------------------------------- */ + +div.sphinxsidebarwrapper { + padding: 10px 5px 0 10px; +} + +div.sphinxsidebar { + float: left; + width: 230px; + margin-left: -100%; + font-size: 90%; + word-wrap: break-word; + overflow-wrap : break-word; +} + +div.sphinxsidebar ul { + list-style: none; +} + +div.sphinxsidebar ul ul, +div.sphinxsidebar ul.want-points { + margin-left: 20px; + list-style: square; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar #searchbox form.search { + overflow: hidden; +} + +div.sphinxsidebar #searchbox input[type="text"] { + float: left; + width: 80%; + padding: 0.25em; + box-sizing: border-box; +} + +div.sphinxsidebar #searchbox input[type="submit"] { + float: left; + width: 20%; + border-left: none; + padding: 0.25em; + box-sizing: border-box; +} + + +img { + border: 0; + max-width: 100%; +} + +/* -- search page ----------------------------------------------------------- */ + +ul.search { + margin: 10px 0 0 20px; + padding: 0; +} + +ul.search li { + padding: 5px 0 5px 20px; + background-image: url(file.png); + background-repeat: no-repeat; + background-position: 0 7px; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li p.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* -- index page ------------------------------------------------------------ */ + +table.contentstable { + width: 90%; + margin-left: auto; + margin-right: auto; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +/* -- general index --------------------------------------------------------- */ + +table.indextable { + width: 100%; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable ul { + margin-top: 0; + margin-bottom: 0; + list-style-type: none; +} + +table.indextable > tbody > tr > td > ul { + padding-left: 0em; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +div.modindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +div.genindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +/* -- domain module index --------------------------------------------------- */ + +table.modindextable td { + padding: 2px; + border-collapse: collapse; +} + +/* -- general body styles --------------------------------------------------- */ + +div.body { + min-width: 360px; + max-width: 800px; +} + +div.body p, div.body dd, div.body li, div.body blockquote { + -moz-hyphens: auto; + -ms-hyphens: auto; + -webkit-hyphens: auto; + hyphens: auto; +} + +a.headerlink { + visibility: hidden; +} + +a:visited { + color: #551A8B; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink, +caption:hover > a.headerlink, +p.caption:hover > a.headerlink, +div.code-block-caption:hover > a.headerlink { + visibility: visible; +} + +div.body p.caption { + text-align: inherit; +} + +div.body td { + text-align: left; +} + +.first { + margin-top: 0 !important; +} + +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +img.align-left, figure.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; +} + +img.align-right, figure.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; +} + +img.align-center, figure.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; +} + +img.align-default, figure.align-default, .figure.align-default { + display: block; + margin-left: auto; + margin-right: auto; +} + +.align-left { + text-align: left; +} + +.align-center { + text-align: center; +} + +.align-default { + text-align: center; +} + +.align-right { + text-align: right; +} + +/* -- sidebars -------------------------------------------------------------- */ + +div.sidebar, +aside.sidebar { + margin: 0 0 0.5em 1em; + border: 1px solid #ddb; + padding: 7px; + background-color: #ffe; + width: 40%; + float: right; + clear: right; + overflow-x: auto; +} + +p.sidebar-title { + font-weight: bold; +} + +nav.contents, +aside.topic, +div.admonition, div.topic, blockquote { + clear: left; +} + +/* -- topics ---------------------------------------------------------------- */ + +nav.contents, +aside.topic, +div.topic { + border: 1px solid #ccc; + padding: 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* -- admonitions ----------------------------------------------------------- */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +/* -- content of sidebars/topics/admonitions -------------------------------- */ + +div.sidebar > :last-child, +aside.sidebar > :last-child, +nav.contents > :last-child, +aside.topic > :last-child, +div.topic > :last-child, +div.admonition > :last-child { + margin-bottom: 0; +} + +div.sidebar::after, +aside.sidebar::after, +nav.contents::after, +aside.topic::after, +div.topic::after, +div.admonition::after, +blockquote::after { + display: block; + content: ''; + clear: both; +} + +/* -- tables ---------------------------------------------------------------- */ + +table.docutils { + margin-top: 10px; + margin-bottom: 10px; + border: 0; + border-collapse: collapse; +} + +table.align-center { + margin-left: auto; + margin-right: auto; +} + +table.align-default { + margin-left: auto; + margin-right: auto; +} + +table caption span.caption-number { + font-style: italic; +} + +table caption span.caption-text { +} + +table.docutils td, table.docutils th { + padding: 1px 8px 1px 5px; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +th { + text-align: left; + padding-right: 5px; +} + +table.citation { + border-left: solid 1px gray; + margin-left: 1px; +} + +table.citation td { + border-bottom: none; +} + +th > :first-child, +td > :first-child { + margin-top: 0px; +} + +th > :last-child, +td > :last-child { + margin-bottom: 0px; +} + +/* -- figures --------------------------------------------------------------- */ + +div.figure, figure { + margin: 0.5em; + padding: 0.5em; +} + +div.figure p.caption, figcaption { + padding: 0.3em; +} + +div.figure p.caption span.caption-number, +figcaption span.caption-number { + font-style: italic; +} + +div.figure p.caption span.caption-text, +figcaption span.caption-text { +} + +/* -- field list styles ----------------------------------------------------- */ + +table.field-list td, table.field-list th { + border: 0 !important; +} + +.field-list ul { + margin: 0; + padding-left: 1em; +} + +.field-list p { + margin: 0; +} + +.field-name { + -moz-hyphens: manual; + -ms-hyphens: manual; + -webkit-hyphens: manual; + hyphens: manual; +} + +/* -- hlist styles ---------------------------------------------------------- */ + +table.hlist { + margin: 1em 0; +} + +table.hlist td { + vertical-align: top; +} + +/* -- object description styles --------------------------------------------- */ + +.sig { + font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; +} + +.sig-name, code.descname { + background-color: transparent; + font-weight: bold; +} + +.sig-name { + font-size: 1.1em; +} + +code.descname { + font-size: 1.2em; +} + +.sig-prename, code.descclassname { + background-color: transparent; +} + +.optional { + font-size: 1.3em; +} + +.sig-paren { + font-size: larger; +} + +.sig-param.n { + font-style: italic; +} + +/* C++ specific styling */ + +.sig-inline.c-texpr, +.sig-inline.cpp-texpr { + font-family: unset; +} + +.sig.c .k, .sig.c .kt, +.sig.cpp .k, .sig.cpp .kt { + color: #0033B3; +} + +.sig.c .m, +.sig.cpp .m { + color: #1750EB; +} + +.sig.c .s, .sig.c .sc, +.sig.cpp .s, .sig.cpp .sc { + color: #067D17; +} + + +/* -- other body styles ----------------------------------------------------- */ + +ol.arabic { + list-style: decimal; +} + +ol.loweralpha { + list-style: lower-alpha; +} + +ol.upperalpha { + list-style: upper-alpha; +} + +ol.lowerroman { + list-style: lower-roman; +} + +ol.upperroman { + list-style: upper-roman; +} + +:not(li) > ol > li:first-child > :first-child, +:not(li) > ul > li:first-child > :first-child { + margin-top: 0px; +} + +:not(li) > ol > li:last-child > :last-child, +:not(li) > ul > li:last-child > :last-child { + margin-bottom: 0px; +} + +ol.simple ol p, +ol.simple ul p, +ul.simple ol p, +ul.simple ul p { + margin-top: 0; +} + +ol.simple > li:not(:first-child) > p, +ul.simple > li:not(:first-child) > p { + margin-top: 0; +} + +ol.simple p, +ul.simple p { + margin-bottom: 0; +} + +aside.footnote > span, +div.citation > span { + float: left; +} +aside.footnote > span:last-of-type, +div.citation > span:last-of-type { + padding-right: 0.5em; +} +aside.footnote > p { + margin-left: 2em; +} +div.citation > p { + margin-left: 4em; +} +aside.footnote > p:last-of-type, +div.citation > p:last-of-type { + margin-bottom: 0em; +} +aside.footnote > p:last-of-type:after, +div.citation > p:last-of-type:after { + content: ""; + clear: both; +} + +dl.field-list { + display: grid; + grid-template-columns: fit-content(30%) auto; +} + +dl.field-list > dt { + font-weight: bold; + word-break: break-word; + padding-left: 0.5em; + padding-right: 5px; +} + +dl.field-list > dd { + padding-left: 0.5em; + margin-top: 0em; + margin-left: 0em; + margin-bottom: 0em; +} + +dl { + margin-bottom: 15px; +} + +dd > :first-child { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +.sig dd { + margin-top: 0px; + margin-bottom: 0px; +} + +.sig dl { + margin-top: 0px; + margin-bottom: 0px; +} + +dl > dd:last-child, +dl > dd:last-child > :last-child { + margin-bottom: 0; +} + +dt:target, span.highlighted { + background-color: #fbe54e; +} + +rect.highlighted { + fill: #fbe54e; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +.versionmodified { + font-style: italic; +} + +.system-message { + background-color: #fda; + padding: 5px; + border: 3px solid red; +} + +.footnote:target { + background-color: #ffa; +} + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +.guilabel, .menuselection { + font-family: sans-serif; +} + +.accelerator { + text-decoration: underline; +} + +.classifier { + font-style: oblique; +} + +.classifier:before { + font-style: normal; + margin: 0 0.5em; + content: ":"; + display: inline-block; +} + +abbr, acronym { + border-bottom: dotted 1px; + cursor: help; +} + +.translated { + background-color: rgba(207, 255, 207, 0.2) +} + +.untranslated { + background-color: rgba(255, 207, 207, 0.2) +} + +/* -- code displays --------------------------------------------------------- */ + +pre { + overflow: auto; + overflow-y: hidden; /* fixes display issues on Chrome browsers */ +} + +pre, div[class*="highlight-"] { + clear: both; +} + +span.pre { + -moz-hyphens: none; + -ms-hyphens: none; + -webkit-hyphens: none; + hyphens: none; + white-space: nowrap; +} + +div[class*="highlight-"] { + margin: 1em 0; +} + +td.linenos pre { + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + display: block; +} + +table.highlighttable tbody { + display: block; +} + +table.highlighttable tr { + display: flex; +} + +table.highlighttable td { + margin: 0; + padding: 0; +} + +table.highlighttable td.linenos { + padding-right: 0.5em; +} + +table.highlighttable td.code { + flex: 1; + overflow: hidden; +} + +.highlight .hll { + display: block; +} + +div.highlight pre, +table.highlighttable pre { + margin: 0; +} + +div.code-block-caption + div { + margin-top: 0; +} + +div.code-block-caption { + margin-top: 1em; + padding: 2px 5px; + font-size: small; +} + +div.code-block-caption code { + background-color: transparent; +} + +table.highlighttable td.linenos, +span.linenos, +div.highlight span.gp { /* gp: Generic.Prompt */ + user-select: none; + -webkit-user-select: text; /* Safari fallback only */ + -webkit-user-select: none; /* Chrome/Safari */ + -moz-user-select: none; /* Firefox */ + -ms-user-select: none; /* IE10+ */ +} + +div.code-block-caption span.caption-number { + padding: 0.1em 0.3em; + font-style: italic; +} + +div.code-block-caption span.caption-text { +} + +div.literal-block-wrapper { + margin: 1em 0; +} + +code.xref, a code { + background-color: transparent; + font-weight: bold; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + background-color: transparent; +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: sans-serif; +} + +div.viewcode-block:target { + margin: -1px -10px; + padding: 0 10px; +} + +/* -- math display ---------------------------------------------------------- */ + +img.math { + vertical-align: middle; +} + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} + +span.eqno a.headerlink { + position: absolute; + z-index: 1; +} + +div.math:hover a.headerlink { + visibility: visible; +} + +/* -- printout stylesheet --------------------------------------------------- */ + +@media print { + div.document, + div.documentwrapper, + div.bodywrapper { + margin: 0 !important; + width: 100%; + } + + div.sphinxsidebar, + div.related, + div.footer, + #top-link { + display: none; + } +} \ No newline at end of file diff --git a/v4.0.3/_static/css/badge_only.css b/v4.0.3/_static/css/badge_only.css new file mode 100644 index 00000000..c718cee4 --- /dev/null +++ b/v4.0.3/_static/css/badge_only.css @@ -0,0 +1 @@ +.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}} \ No newline at end of file diff --git a/v4.0.3/_static/css/fonts/Roboto-Slab-Bold.woff b/v4.0.3/_static/css/fonts/Roboto-Slab-Bold.woff new file mode 100644 index 00000000..6cb60000 Binary files /dev/null and b/v4.0.3/_static/css/fonts/Roboto-Slab-Bold.woff differ diff --git a/v4.0.3/_static/css/fonts/Roboto-Slab-Bold.woff2 b/v4.0.3/_static/css/fonts/Roboto-Slab-Bold.woff2 new file mode 100644 index 00000000..7059e231 Binary files /dev/null and b/v4.0.3/_static/css/fonts/Roboto-Slab-Bold.woff2 differ diff --git a/v4.0.3/_static/css/fonts/Roboto-Slab-Regular.woff b/v4.0.3/_static/css/fonts/Roboto-Slab-Regular.woff new file mode 100644 index 00000000..f815f63f Binary files /dev/null and b/v4.0.3/_static/css/fonts/Roboto-Slab-Regular.woff differ diff --git a/v4.0.3/_static/css/fonts/Roboto-Slab-Regular.woff2 b/v4.0.3/_static/css/fonts/Roboto-Slab-Regular.woff2 new file mode 100644 index 00000000..f2c76e5b Binary files /dev/null and b/v4.0.3/_static/css/fonts/Roboto-Slab-Regular.woff2 differ diff --git a/v4.0.3/_static/css/fonts/fontawesome-webfont.eot b/v4.0.3/_static/css/fonts/fontawesome-webfont.eot new file mode 100644 index 00000000..e9f60ca9 Binary files /dev/null and b/v4.0.3/_static/css/fonts/fontawesome-webfont.eot differ diff --git a/v4.0.3/_static/css/fonts/fontawesome-webfont.svg b/v4.0.3/_static/css/fonts/fontawesome-webfont.svg new file mode 100644 index 00000000..855c845e --- /dev/null +++ b/v4.0.3/_static/css/fonts/fontawesome-webfont.svg @@ -0,0 +1,2671 @@ + + + + +Created by FontForge 20120731 at Mon Oct 24 17:37:40 2016 + By ,,, +Copyright Dave Gandy 2016. All rights reserved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/v4.0.3/_static/css/fonts/fontawesome-webfont.ttf b/v4.0.3/_static/css/fonts/fontawesome-webfont.ttf new file mode 100644 index 00000000..35acda2f Binary files /dev/null and b/v4.0.3/_static/css/fonts/fontawesome-webfont.ttf differ diff --git a/v4.0.3/_static/css/fonts/fontawesome-webfont.woff b/v4.0.3/_static/css/fonts/fontawesome-webfont.woff new file mode 100644 index 00000000..400014a4 Binary files /dev/null and b/v4.0.3/_static/css/fonts/fontawesome-webfont.woff differ diff --git a/v4.0.3/_static/css/fonts/fontawesome-webfont.woff2 b/v4.0.3/_static/css/fonts/fontawesome-webfont.woff2 new file mode 100644 index 00000000..4d13fc60 Binary files /dev/null and b/v4.0.3/_static/css/fonts/fontawesome-webfont.woff2 differ diff --git a/v4.0.3/_static/css/fonts/lato-bold-italic.woff b/v4.0.3/_static/css/fonts/lato-bold-italic.woff new file mode 100644 index 00000000..88ad05b9 Binary files /dev/null and b/v4.0.3/_static/css/fonts/lato-bold-italic.woff differ diff --git a/v4.0.3/_static/css/fonts/lato-bold-italic.woff2 b/v4.0.3/_static/css/fonts/lato-bold-italic.woff2 new file mode 100644 index 00000000..c4e3d804 Binary files /dev/null and b/v4.0.3/_static/css/fonts/lato-bold-italic.woff2 differ diff --git a/v4.0.3/_static/css/fonts/lato-bold.woff b/v4.0.3/_static/css/fonts/lato-bold.woff new file mode 100644 index 00000000..c6dff51f Binary files /dev/null and b/v4.0.3/_static/css/fonts/lato-bold.woff differ diff --git a/v4.0.3/_static/css/fonts/lato-bold.woff2 b/v4.0.3/_static/css/fonts/lato-bold.woff2 new file mode 100644 index 00000000..bb195043 Binary files /dev/null and b/v4.0.3/_static/css/fonts/lato-bold.woff2 differ diff --git a/v4.0.3/_static/css/fonts/lato-normal-italic.woff b/v4.0.3/_static/css/fonts/lato-normal-italic.woff new file mode 100644 index 00000000..76114bc0 Binary files /dev/null and b/v4.0.3/_static/css/fonts/lato-normal-italic.woff differ diff --git a/v4.0.3/_static/css/fonts/lato-normal-italic.woff2 b/v4.0.3/_static/css/fonts/lato-normal-italic.woff2 new file mode 100644 index 00000000..3404f37e Binary files /dev/null and b/v4.0.3/_static/css/fonts/lato-normal-italic.woff2 differ diff --git a/v4.0.3/_static/css/fonts/lato-normal.woff b/v4.0.3/_static/css/fonts/lato-normal.woff new file mode 100644 index 00000000..ae1307ff Binary files /dev/null and b/v4.0.3/_static/css/fonts/lato-normal.woff differ diff --git a/v4.0.3/_static/css/fonts/lato-normal.woff2 b/v4.0.3/_static/css/fonts/lato-normal.woff2 new file mode 100644 index 00000000..3bf98433 Binary files /dev/null and b/v4.0.3/_static/css/fonts/lato-normal.woff2 differ diff --git a/v4.0.3/_static/css/theme.css b/v4.0.3/_static/css/theme.css new file mode 100644 index 00000000..19a446a0 --- /dev/null +++ b/v4.0.3/_static/css/theme.css @@ -0,0 +1,4 @@ +html{box-sizing:border-box}*,:after,:before{box-sizing:inherit}article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}[hidden],audio:not([controls]){display:none}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}blockquote{margin:0}dfn{font-style:italic}ins{background:#ff9;text-decoration:none}ins,mark{color:#000}mark{background:#ff0;font-style:italic;font-weight:700}.rst-content code,.rst-content tt,code,kbd,pre,samp{font-family:monospace,serif;_font-family:courier new,monospace;font-size:1em}pre{white-space:pre}q{quotes:none}q:after,q:before{content:"";content:none}small{font-size:85%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}dl,ol,ul{margin:0;padding:0;list-style:none;list-style-image:none}li{list-style:none}dd{margin:0}img{border:0;-ms-interpolation-mode:bicubic;vertical-align:middle;max-width:100%}svg:not(:root){overflow:hidden}figure,form{margin:0}label{cursor:pointer}button,input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}button,input{line-height:normal}button,input[type=button],input[type=reset],input[type=submit]{cursor:pointer;-webkit-appearance:button;*overflow:visible}button[disabled],input[disabled]{cursor:default}input[type=search]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}textarea{resize:vertical}table{border-collapse:collapse;border-spacing:0}td{vertical-align:top}.chromeframe{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}.ir{display:block;border:0;text-indent:-999em;overflow:hidden;background-color:transparent;background-repeat:no-repeat;text-align:left;direction:ltr;*line-height:0}.ir br{display:none}.hidden{display:none!important;visibility:hidden}.visuallyhidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.visuallyhidden.focusable:active,.visuallyhidden.focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}.invisible{visibility:hidden}.relative{position:relative}big,small{font-size:100%}@media print{body,html,section{background:none!important}*{box-shadow:none!important;text-shadow:none!important;filter:none!important;-ms-filter:none!important}a,a:visited{text-decoration:underline}.ir a:after,a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}.rst-content .toctree-wrapper>p.caption,h2,h3,p{orphans:3;widows:3}.rst-content .toctree-wrapper>p.caption,h2,h3{page-break-after:avoid}}.btn,.fa:before,.icon:before,.rst-content .admonition,.rst-content .admonition-title:before,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .code-block-caption .headerlink:before,.rst-content .danger,.rst-content .eqno .headerlink:before,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-alert,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before,input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week],select,textarea{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}/*! + * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome + * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) + */@font-face{font-family:FontAwesome;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713);src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix&v=4.7.0) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#fontawesomeregular) format("svg");font-weight:400;font-style:normal}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14286em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14286em;width:2.14286em;top:.14286em;text-align:center}.fa-li.fa-lg{left:-1.85714em}.fa-border{padding:.2em .25em .15em;border:.08em solid #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa-pull-left.icon,.fa.fa-pull-left,.rst-content .code-block-caption .fa-pull-left.headerlink,.rst-content .eqno .fa-pull-left.headerlink,.rst-content .fa-pull-left.admonition-title,.rst-content code.download span.fa-pull-left:first-child,.rst-content dl dt .fa-pull-left.headerlink,.rst-content h1 .fa-pull-left.headerlink,.rst-content h2 .fa-pull-left.headerlink,.rst-content h3 .fa-pull-left.headerlink,.rst-content h4 .fa-pull-left.headerlink,.rst-content h5 .fa-pull-left.headerlink,.rst-content h6 .fa-pull-left.headerlink,.rst-content p .fa-pull-left.headerlink,.rst-content table>caption .fa-pull-left.headerlink,.rst-content tt.download span.fa-pull-left:first-child,.wy-menu-vertical li.current>a button.fa-pull-left.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-left.toctree-expand,.wy-menu-vertical li button.fa-pull-left.toctree-expand{margin-right:.3em}.fa-pull-right.icon,.fa.fa-pull-right,.rst-content .code-block-caption .fa-pull-right.headerlink,.rst-content .eqno .fa-pull-right.headerlink,.rst-content .fa-pull-right.admonition-title,.rst-content code.download span.fa-pull-right:first-child,.rst-content dl dt .fa-pull-right.headerlink,.rst-content h1 .fa-pull-right.headerlink,.rst-content h2 .fa-pull-right.headerlink,.rst-content h3 .fa-pull-right.headerlink,.rst-content h4 .fa-pull-right.headerlink,.rst-content h5 .fa-pull-right.headerlink,.rst-content h6 .fa-pull-right.headerlink,.rst-content p .fa-pull-right.headerlink,.rst-content table>caption .fa-pull-right.headerlink,.rst-content tt.download span.fa-pull-right:first-child,.wy-menu-vertical li.current>a button.fa-pull-right.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-right.toctree-expand,.wy-menu-vertical li button.fa-pull-right.toctree-expand{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left,.pull-left.icon,.rst-content .code-block-caption .pull-left.headerlink,.rst-content .eqno .pull-left.headerlink,.rst-content .pull-left.admonition-title,.rst-content code.download span.pull-left:first-child,.rst-content dl dt .pull-left.headerlink,.rst-content h1 .pull-left.headerlink,.rst-content h2 .pull-left.headerlink,.rst-content h3 .pull-left.headerlink,.rst-content h4 .pull-left.headerlink,.rst-content h5 .pull-left.headerlink,.rst-content h6 .pull-left.headerlink,.rst-content p .pull-left.headerlink,.rst-content table>caption .pull-left.headerlink,.rst-content tt.download span.pull-left:first-child,.wy-menu-vertical li.current>a button.pull-left.toctree-expand,.wy-menu-vertical li.on a button.pull-left.toctree-expand,.wy-menu-vertical li button.pull-left.toctree-expand{margin-right:.3em}.fa.pull-right,.pull-right.icon,.rst-content .code-block-caption .pull-right.headerlink,.rst-content .eqno .pull-right.headerlink,.rst-content .pull-right.admonition-title,.rst-content code.download span.pull-right:first-child,.rst-content dl dt .pull-right.headerlink,.rst-content h1 .pull-right.headerlink,.rst-content h2 .pull-right.headerlink,.rst-content h3 .pull-right.headerlink,.rst-content h4 .pull-right.headerlink,.rst-content h5 .pull-right.headerlink,.rst-content h6 .pull-right.headerlink,.rst-content p .pull-right.headerlink,.rst-content table>caption .pull-right.headerlink,.rst-content tt.download span.pull-right:first-child,.wy-menu-vertical li.current>a button.pull-right.toctree-expand,.wy-menu-vertical li.on a button.pull-right.toctree-expand,.wy-menu-vertical li button.pull-right.toctree-expand{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);-ms-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scaleY(-1);-ms-transform:scaleY(-1);transform:scaleY(-1)}:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:""}.fa-music:before{content:""}.fa-search:before,.icon-search:before{content:""}.fa-envelope-o:before{content:""}.fa-heart:before{content:""}.fa-star:before{content:""}.fa-star-o:before{content:""}.fa-user:before{content:""}.fa-film:before{content:""}.fa-th-large:before{content:""}.fa-th:before{content:""}.fa-th-list:before{content:""}.fa-check:before{content:""}.fa-close:before,.fa-remove:before,.fa-times:before{content:""}.fa-search-plus:before{content:""}.fa-search-minus:before{content:""}.fa-power-off:before{content:""}.fa-signal:before{content:""}.fa-cog:before,.fa-gear:before{content:""}.fa-trash-o:before{content:""}.fa-home:before,.icon-home:before{content:""}.fa-file-o:before{content:""}.fa-clock-o:before{content:""}.fa-road:before{content:""}.fa-download:before,.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{content:""}.fa-arrow-circle-o-down:before{content:""}.fa-arrow-circle-o-up:before{content:""}.fa-inbox:before{content:""}.fa-play-circle-o:before{content:""}.fa-repeat:before,.fa-rotate-right:before{content:""}.fa-refresh:before{content:""}.fa-list-alt:before{content:""}.fa-lock:before{content:""}.fa-flag:before{content:""}.fa-headphones:before{content:""}.fa-volume-off:before{content:""}.fa-volume-down:before{content:""}.fa-volume-up:before{content:""}.fa-qrcode:before{content:""}.fa-barcode:before{content:""}.fa-tag:before{content:""}.fa-tags:before{content:""}.fa-book:before,.icon-book:before{content:""}.fa-bookmark:before{content:""}.fa-print:before{content:""}.fa-camera:before{content:""}.fa-font:before{content:""}.fa-bold:before{content:""}.fa-italic:before{content:""}.fa-text-height:before{content:""}.fa-text-width:before{content:""}.fa-align-left:before{content:""}.fa-align-center:before{content:""}.fa-align-right:before{content:""}.fa-align-justify:before{content:""}.fa-list:before{content:""}.fa-dedent:before,.fa-outdent:before{content:""}.fa-indent:before{content:""}.fa-video-camera:before{content:""}.fa-image:before,.fa-photo:before,.fa-picture-o:before{content:""}.fa-pencil:before{content:""}.fa-map-marker:before{content:""}.fa-adjust:before{content:""}.fa-tint:before{content:""}.fa-edit:before,.fa-pencil-square-o:before{content:""}.fa-share-square-o:before{content:""}.fa-check-square-o:before{content:""}.fa-arrows:before{content:""}.fa-step-backward:before{content:""}.fa-fast-backward:before{content:""}.fa-backward:before{content:""}.fa-play:before{content:""}.fa-pause:before{content:""}.fa-stop:before{content:""}.fa-forward:before{content:""}.fa-fast-forward:before{content:""}.fa-step-forward:before{content:""}.fa-eject:before{content:""}.fa-chevron-left:before{content:""}.fa-chevron-right:before{content:""}.fa-plus-circle:before{content:""}.fa-minus-circle:before{content:""}.fa-times-circle:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before{content:""}.fa-check-circle:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before{content:""}.fa-question-circle:before{content:""}.fa-info-circle:before{content:""}.fa-crosshairs:before{content:""}.fa-times-circle-o:before{content:""}.fa-check-circle-o:before{content:""}.fa-ban:before{content:""}.fa-arrow-left:before{content:""}.fa-arrow-right:before{content:""}.fa-arrow-up:before{content:""}.fa-arrow-down:before{content:""}.fa-mail-forward:before,.fa-share:before{content:""}.fa-expand:before{content:""}.fa-compress:before{content:""}.fa-plus:before{content:""}.fa-minus:before{content:""}.fa-asterisk:before{content:""}.fa-exclamation-circle:before,.rst-content .admonition-title:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before{content:""}.fa-gift:before{content:""}.fa-leaf:before{content:""}.fa-fire:before,.icon-fire:before{content:""}.fa-eye:before{content:""}.fa-eye-slash:before{content:""}.fa-exclamation-triangle:before,.fa-warning:before{content:""}.fa-plane:before{content:""}.fa-calendar:before{content:""}.fa-random:before{content:""}.fa-comment:before{content:""}.fa-magnet:before{content:""}.fa-chevron-up:before{content:""}.fa-chevron-down:before{content:""}.fa-retweet:before{content:""}.fa-shopping-cart:before{content:""}.fa-folder:before{content:""}.fa-folder-open:before{content:""}.fa-arrows-v:before{content:""}.fa-arrows-h:before{content:""}.fa-bar-chart-o:before,.fa-bar-chart:before{content:""}.fa-twitter-square:before{content:""}.fa-facebook-square:before{content:""}.fa-camera-retro:before{content:""}.fa-key:before{content:""}.fa-cogs:before,.fa-gears:before{content:""}.fa-comments:before{content:""}.fa-thumbs-o-up:before{content:""}.fa-thumbs-o-down:before{content:""}.fa-star-half:before{content:""}.fa-heart-o:before{content:""}.fa-sign-out:before{content:""}.fa-linkedin-square:before{content:""}.fa-thumb-tack:before{content:""}.fa-external-link:before{content:""}.fa-sign-in:before{content:""}.fa-trophy:before{content:""}.fa-github-square:before{content:""}.fa-upload:before{content:""}.fa-lemon-o:before{content:""}.fa-phone:before{content:""}.fa-square-o:before{content:""}.fa-bookmark-o:before{content:""}.fa-phone-square:before{content:""}.fa-twitter:before{content:""}.fa-facebook-f:before,.fa-facebook:before{content:""}.fa-github:before,.icon-github:before{content:""}.fa-unlock:before{content:""}.fa-credit-card:before{content:""}.fa-feed:before,.fa-rss:before{content:""}.fa-hdd-o:before{content:""}.fa-bullhorn:before{content:""}.fa-bell:before{content:""}.fa-certificate:before{content:""}.fa-hand-o-right:before{content:""}.fa-hand-o-left:before{content:""}.fa-hand-o-up:before{content:""}.fa-hand-o-down:before{content:""}.fa-arrow-circle-left:before,.icon-circle-arrow-left:before{content:""}.fa-arrow-circle-right:before,.icon-circle-arrow-right:before{content:""}.fa-arrow-circle-up:before{content:""}.fa-arrow-circle-down:before{content:""}.fa-globe:before{content:""}.fa-wrench:before{content:""}.fa-tasks:before{content:""}.fa-filter:before{content:""}.fa-briefcase:before{content:""}.fa-arrows-alt:before{content:""}.fa-group:before,.fa-users:before{content:""}.fa-chain:before,.fa-link:before,.icon-link:before{content:""}.fa-cloud:before{content:""}.fa-flask:before{content:""}.fa-cut:before,.fa-scissors:before{content:""}.fa-copy:before,.fa-files-o:before{content:""}.fa-paperclip:before{content:""}.fa-floppy-o:before,.fa-save:before{content:""}.fa-square:before{content:""}.fa-bars:before,.fa-navicon:before,.fa-reorder:before{content:""}.fa-list-ul:before{content:""}.fa-list-ol:before{content:""}.fa-strikethrough:before{content:""}.fa-underline:before{content:""}.fa-table:before{content:""}.fa-magic:before{content:""}.fa-truck:before{content:""}.fa-pinterest:before{content:""}.fa-pinterest-square:before{content:""}.fa-google-plus-square:before{content:""}.fa-google-plus:before{content:""}.fa-money:before{content:""}.fa-caret-down:before,.icon-caret-down:before,.wy-dropdown .caret:before{content:""}.fa-caret-up:before{content:""}.fa-caret-left:before{content:""}.fa-caret-right:before{content:""}.fa-columns:before{content:""}.fa-sort:before,.fa-unsorted:before{content:""}.fa-sort-desc:before,.fa-sort-down:before{content:""}.fa-sort-asc:before,.fa-sort-up:before{content:""}.fa-envelope:before{content:""}.fa-linkedin:before{content:""}.fa-rotate-left:before,.fa-undo:before{content:""}.fa-gavel:before,.fa-legal:before{content:""}.fa-dashboard:before,.fa-tachometer:before{content:""}.fa-comment-o:before{content:""}.fa-comments-o:before{content:""}.fa-bolt:before,.fa-flash:before{content:""}.fa-sitemap:before{content:""}.fa-umbrella:before{content:""}.fa-clipboard:before,.fa-paste:before{content:""}.fa-lightbulb-o:before{content:""}.fa-exchange:before{content:""}.fa-cloud-download:before{content:""}.fa-cloud-upload:before{content:""}.fa-user-md:before{content:""}.fa-stethoscope:before{content:""}.fa-suitcase:before{content:""}.fa-bell-o:before{content:""}.fa-coffee:before{content:""}.fa-cutlery:before{content:""}.fa-file-text-o:before{content:""}.fa-building-o:before{content:""}.fa-hospital-o:before{content:""}.fa-ambulance:before{content:""}.fa-medkit:before{content:""}.fa-fighter-jet:before{content:""}.fa-beer:before{content:""}.fa-h-square:before{content:""}.fa-plus-square:before{content:""}.fa-angle-double-left:before{content:""}.fa-angle-double-right:before{content:""}.fa-angle-double-up:before{content:""}.fa-angle-double-down:before{content:""}.fa-angle-left:before{content:""}.fa-angle-right:before{content:""}.fa-angle-up:before{content:""}.fa-angle-down:before{content:""}.fa-desktop:before{content:""}.fa-laptop:before{content:""}.fa-tablet:before{content:""}.fa-mobile-phone:before,.fa-mobile:before{content:""}.fa-circle-o:before{content:""}.fa-quote-left:before{content:""}.fa-quote-right:before{content:""}.fa-spinner:before{content:""}.fa-circle:before{content:""}.fa-mail-reply:before,.fa-reply:before{content:""}.fa-github-alt:before{content:""}.fa-folder-o:before{content:""}.fa-folder-open-o:before{content:""}.fa-smile-o:before{content:""}.fa-frown-o:before{content:""}.fa-meh-o:before{content:""}.fa-gamepad:before{content:""}.fa-keyboard-o:before{content:""}.fa-flag-o:before{content:""}.fa-flag-checkered:before{content:""}.fa-terminal:before{content:""}.fa-code:before{content:""}.fa-mail-reply-all:before,.fa-reply-all:before{content:""}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:""}.fa-location-arrow:before{content:""}.fa-crop:before{content:""}.fa-code-fork:before{content:""}.fa-chain-broken:before,.fa-unlink:before{content:""}.fa-question:before{content:""}.fa-info:before{content:""}.fa-exclamation:before{content:""}.fa-superscript:before{content:""}.fa-subscript:before{content:""}.fa-eraser:before{content:""}.fa-puzzle-piece:before{content:""}.fa-microphone:before{content:""}.fa-microphone-slash:before{content:""}.fa-shield:before{content:""}.fa-calendar-o:before{content:""}.fa-fire-extinguisher:before{content:""}.fa-rocket:before{content:""}.fa-maxcdn:before{content:""}.fa-chevron-circle-left:before{content:""}.fa-chevron-circle-right:before{content:""}.fa-chevron-circle-up:before{content:""}.fa-chevron-circle-down:before{content:""}.fa-html5:before{content:""}.fa-css3:before{content:""}.fa-anchor:before{content:""}.fa-unlock-alt:before{content:""}.fa-bullseye:before{content:""}.fa-ellipsis-h:before{content:""}.fa-ellipsis-v:before{content:""}.fa-rss-square:before{content:""}.fa-play-circle:before{content:""}.fa-ticket:before{content:""}.fa-minus-square:before{content:""}.fa-minus-square-o:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before{content:""}.fa-level-up:before{content:""}.fa-level-down:before{content:""}.fa-check-square:before{content:""}.fa-pencil-square:before{content:""}.fa-external-link-square:before{content:""}.fa-share-square:before{content:""}.fa-compass:before{content:""}.fa-caret-square-o-down:before,.fa-toggle-down:before{content:""}.fa-caret-square-o-up:before,.fa-toggle-up:before{content:""}.fa-caret-square-o-right:before,.fa-toggle-right:before{content:""}.fa-eur:before,.fa-euro:before{content:""}.fa-gbp:before{content:""}.fa-dollar:before,.fa-usd:before{content:""}.fa-inr:before,.fa-rupee:before{content:""}.fa-cny:before,.fa-jpy:before,.fa-rmb:before,.fa-yen:before{content:""}.fa-rouble:before,.fa-rub:before,.fa-ruble:before{content:""}.fa-krw:before,.fa-won:before{content:""}.fa-bitcoin:before,.fa-btc:before{content:""}.fa-file:before{content:""}.fa-file-text:before{content:""}.fa-sort-alpha-asc:before{content:""}.fa-sort-alpha-desc:before{content:""}.fa-sort-amount-asc:before{content:""}.fa-sort-amount-desc:before{content:""}.fa-sort-numeric-asc:before{content:""}.fa-sort-numeric-desc:before{content:""}.fa-thumbs-up:before{content:""}.fa-thumbs-down:before{content:""}.fa-youtube-square:before{content:""}.fa-youtube:before{content:""}.fa-xing:before{content:""}.fa-xing-square:before{content:""}.fa-youtube-play:before{content:""}.fa-dropbox:before{content:""}.fa-stack-overflow:before{content:""}.fa-instagram:before{content:""}.fa-flickr:before{content:""}.fa-adn:before{content:""}.fa-bitbucket:before,.icon-bitbucket:before{content:""}.fa-bitbucket-square:before{content:""}.fa-tumblr:before{content:""}.fa-tumblr-square:before{content:""}.fa-long-arrow-down:before{content:""}.fa-long-arrow-up:before{content:""}.fa-long-arrow-left:before{content:""}.fa-long-arrow-right:before{content:""}.fa-apple:before{content:""}.fa-windows:before{content:""}.fa-android:before{content:""}.fa-linux:before{content:""}.fa-dribbble:before{content:""}.fa-skype:before{content:""}.fa-foursquare:before{content:""}.fa-trello:before{content:""}.fa-female:before{content:""}.fa-male:before{content:""}.fa-gittip:before,.fa-gratipay:before{content:""}.fa-sun-o:before{content:""}.fa-moon-o:before{content:""}.fa-archive:before{content:""}.fa-bug:before{content:""}.fa-vk:before{content:""}.fa-weibo:before{content:""}.fa-renren:before{content:""}.fa-pagelines:before{content:""}.fa-stack-exchange:before{content:""}.fa-arrow-circle-o-right:before{content:""}.fa-arrow-circle-o-left:before{content:""}.fa-caret-square-o-left:before,.fa-toggle-left:before{content:""}.fa-dot-circle-o:before{content:""}.fa-wheelchair:before{content:""}.fa-vimeo-square:before{content:""}.fa-try:before,.fa-turkish-lira:before{content:""}.fa-plus-square-o:before,.wy-menu-vertical li button.toctree-expand:before{content:""}.fa-space-shuttle:before{content:""}.fa-slack:before{content:""}.fa-envelope-square:before{content:""}.fa-wordpress:before{content:""}.fa-openid:before{content:""}.fa-bank:before,.fa-institution:before,.fa-university:before{content:""}.fa-graduation-cap:before,.fa-mortar-board:before{content:""}.fa-yahoo:before{content:""}.fa-google:before{content:""}.fa-reddit:before{content:""}.fa-reddit-square:before{content:""}.fa-stumbleupon-circle:before{content:""}.fa-stumbleupon:before{content:""}.fa-delicious:before{content:""}.fa-digg:before{content:""}.fa-pied-piper-pp:before{content:""}.fa-pied-piper-alt:before{content:""}.fa-drupal:before{content:""}.fa-joomla:before{content:""}.fa-language:before{content:""}.fa-fax:before{content:""}.fa-building:before{content:""}.fa-child:before{content:""}.fa-paw:before{content:""}.fa-spoon:before{content:""}.fa-cube:before{content:""}.fa-cubes:before{content:""}.fa-behance:before{content:""}.fa-behance-square:before{content:""}.fa-steam:before{content:""}.fa-steam-square:before{content:""}.fa-recycle:before{content:""}.fa-automobile:before,.fa-car:before{content:""}.fa-cab:before,.fa-taxi:before{content:""}.fa-tree:before{content:""}.fa-spotify:before{content:""}.fa-deviantart:before{content:""}.fa-soundcloud:before{content:""}.fa-database:before{content:""}.fa-file-pdf-o:before{content:""}.fa-file-word-o:before{content:""}.fa-file-excel-o:before{content:""}.fa-file-powerpoint-o:before{content:""}.fa-file-image-o:before,.fa-file-photo-o:before,.fa-file-picture-o:before{content:""}.fa-file-archive-o:before,.fa-file-zip-o:before{content:""}.fa-file-audio-o:before,.fa-file-sound-o:before{content:""}.fa-file-movie-o:before,.fa-file-video-o:before{content:""}.fa-file-code-o:before{content:""}.fa-vine:before{content:""}.fa-codepen:before{content:""}.fa-jsfiddle:before{content:""}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-ring:before,.fa-life-saver:before,.fa-support:before{content:""}.fa-circle-o-notch:before{content:""}.fa-ra:before,.fa-rebel:before,.fa-resistance:before{content:""}.fa-empire:before,.fa-ge:before{content:""}.fa-git-square:before{content:""}.fa-git:before{content:""}.fa-hacker-news:before,.fa-y-combinator-square:before,.fa-yc-square:before{content:""}.fa-tencent-weibo:before{content:""}.fa-qq:before{content:""}.fa-wechat:before,.fa-weixin:before{content:""}.fa-paper-plane:before,.fa-send:before{content:""}.fa-paper-plane-o:before,.fa-send-o:before{content:""}.fa-history:before{content:""}.fa-circle-thin:before{content:""}.fa-header:before{content:""}.fa-paragraph:before{content:""}.fa-sliders:before{content:""}.fa-share-alt:before{content:""}.fa-share-alt-square:before{content:""}.fa-bomb:before{content:""}.fa-futbol-o:before,.fa-soccer-ball-o:before{content:""}.fa-tty:before{content:""}.fa-binoculars:before{content:""}.fa-plug:before{content:""}.fa-slideshare:before{content:""}.fa-twitch:before{content:""}.fa-yelp:before{content:""}.fa-newspaper-o:before{content:""}.fa-wifi:before{content:""}.fa-calculator:before{content:""}.fa-paypal:before{content:""}.fa-google-wallet:before{content:""}.fa-cc-visa:before{content:""}.fa-cc-mastercard:before{content:""}.fa-cc-discover:before{content:""}.fa-cc-amex:before{content:""}.fa-cc-paypal:before{content:""}.fa-cc-stripe:before{content:""}.fa-bell-slash:before{content:""}.fa-bell-slash-o:before{content:""}.fa-trash:before{content:""}.fa-copyright:before{content:""}.fa-at:before{content:""}.fa-eyedropper:before{content:""}.fa-paint-brush:before{content:""}.fa-birthday-cake:before{content:""}.fa-area-chart:before{content:""}.fa-pie-chart:before{content:""}.fa-line-chart:before{content:""}.fa-lastfm:before{content:""}.fa-lastfm-square:before{content:""}.fa-toggle-off:before{content:""}.fa-toggle-on:before{content:""}.fa-bicycle:before{content:""}.fa-bus:before{content:""}.fa-ioxhost:before{content:""}.fa-angellist:before{content:""}.fa-cc:before{content:""}.fa-ils:before,.fa-shekel:before,.fa-sheqel:before{content:""}.fa-meanpath:before{content:""}.fa-buysellads:before{content:""}.fa-connectdevelop:before{content:""}.fa-dashcube:before{content:""}.fa-forumbee:before{content:""}.fa-leanpub:before{content:""}.fa-sellsy:before{content:""}.fa-shirtsinbulk:before{content:""}.fa-simplybuilt:before{content:""}.fa-skyatlas:before{content:""}.fa-cart-plus:before{content:""}.fa-cart-arrow-down:before{content:""}.fa-diamond:before{content:""}.fa-ship:before{content:""}.fa-user-secret:before{content:""}.fa-motorcycle:before{content:""}.fa-street-view:before{content:""}.fa-heartbeat:before{content:""}.fa-venus:before{content:""}.fa-mars:before{content:""}.fa-mercury:before{content:""}.fa-intersex:before,.fa-transgender:before{content:""}.fa-transgender-alt:before{content:""}.fa-venus-double:before{content:""}.fa-mars-double:before{content:""}.fa-venus-mars:before{content:""}.fa-mars-stroke:before{content:""}.fa-mars-stroke-v:before{content:""}.fa-mars-stroke-h:before{content:""}.fa-neuter:before{content:""}.fa-genderless:before{content:""}.fa-facebook-official:before{content:""}.fa-pinterest-p:before{content:""}.fa-whatsapp:before{content:""}.fa-server:before{content:""}.fa-user-plus:before{content:""}.fa-user-times:before{content:""}.fa-bed:before,.fa-hotel:before{content:""}.fa-viacoin:before{content:""}.fa-train:before{content:""}.fa-subway:before{content:""}.fa-medium:before{content:""}.fa-y-combinator:before,.fa-yc:before{content:""}.fa-optin-monster:before{content:""}.fa-opencart:before{content:""}.fa-expeditedssl:before{content:""}.fa-battery-4:before,.fa-battery-full:before,.fa-battery:before{content:""}.fa-battery-3:before,.fa-battery-three-quarters:before{content:""}.fa-battery-2:before,.fa-battery-half:before{content:""}.fa-battery-1:before,.fa-battery-quarter:before{content:""}.fa-battery-0:before,.fa-battery-empty:before{content:""}.fa-mouse-pointer:before{content:""}.fa-i-cursor:before{content:""}.fa-object-group:before{content:""}.fa-object-ungroup:before{content:""}.fa-sticky-note:before{content:""}.fa-sticky-note-o:before{content:""}.fa-cc-jcb:before{content:""}.fa-cc-diners-club:before{content:""}.fa-clone:before{content:""}.fa-balance-scale:before{content:""}.fa-hourglass-o:before{content:""}.fa-hourglass-1:before,.fa-hourglass-start:before{content:""}.fa-hourglass-2:before,.fa-hourglass-half:before{content:""}.fa-hourglass-3:before,.fa-hourglass-end:before{content:""}.fa-hourglass:before{content:""}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:""}.fa-hand-paper-o:before,.fa-hand-stop-o:before{content:""}.fa-hand-scissors-o:before{content:""}.fa-hand-lizard-o:before{content:""}.fa-hand-spock-o:before{content:""}.fa-hand-pointer-o:before{content:""}.fa-hand-peace-o:before{content:""}.fa-trademark:before{content:""}.fa-registered:before{content:""}.fa-creative-commons:before{content:""}.fa-gg:before{content:""}.fa-gg-circle:before{content:""}.fa-tripadvisor:before{content:""}.fa-odnoklassniki:before{content:""}.fa-odnoklassniki-square:before{content:""}.fa-get-pocket:before{content:""}.fa-wikipedia-w:before{content:""}.fa-safari:before{content:""}.fa-chrome:before{content:""}.fa-firefox:before{content:""}.fa-opera:before{content:""}.fa-internet-explorer:before{content:""}.fa-television:before,.fa-tv:before{content:""}.fa-contao:before{content:""}.fa-500px:before{content:""}.fa-amazon:before{content:""}.fa-calendar-plus-o:before{content:""}.fa-calendar-minus-o:before{content:""}.fa-calendar-times-o:before{content:""}.fa-calendar-check-o:before{content:""}.fa-industry:before{content:""}.fa-map-pin:before{content:""}.fa-map-signs:before{content:""}.fa-map-o:before{content:""}.fa-map:before{content:""}.fa-commenting:before{content:""}.fa-commenting-o:before{content:""}.fa-houzz:before{content:""}.fa-vimeo:before{content:""}.fa-black-tie:before{content:""}.fa-fonticons:before{content:""}.fa-reddit-alien:before{content:""}.fa-edge:before{content:""}.fa-credit-card-alt:before{content:""}.fa-codiepie:before{content:""}.fa-modx:before{content:""}.fa-fort-awesome:before{content:""}.fa-usb:before{content:""}.fa-product-hunt:before{content:""}.fa-mixcloud:before{content:""}.fa-scribd:before{content:""}.fa-pause-circle:before{content:""}.fa-pause-circle-o:before{content:""}.fa-stop-circle:before{content:""}.fa-stop-circle-o:before{content:""}.fa-shopping-bag:before{content:""}.fa-shopping-basket:before{content:""}.fa-hashtag:before{content:""}.fa-bluetooth:before{content:""}.fa-bluetooth-b:before{content:""}.fa-percent:before{content:""}.fa-gitlab:before,.icon-gitlab:before{content:""}.fa-wpbeginner:before{content:""}.fa-wpforms:before{content:""}.fa-envira:before{content:""}.fa-universal-access:before{content:""}.fa-wheelchair-alt:before{content:""}.fa-question-circle-o:before{content:""}.fa-blind:before{content:""}.fa-audio-description:before{content:""}.fa-volume-control-phone:before{content:""}.fa-braille:before{content:""}.fa-assistive-listening-systems:before{content:""}.fa-american-sign-language-interpreting:before,.fa-asl-interpreting:before{content:""}.fa-deaf:before,.fa-deafness:before,.fa-hard-of-hearing:before{content:""}.fa-glide:before{content:""}.fa-glide-g:before{content:""}.fa-sign-language:before,.fa-signing:before{content:""}.fa-low-vision:before{content:""}.fa-viadeo:before{content:""}.fa-viadeo-square:before{content:""}.fa-snapchat:before{content:""}.fa-snapchat-ghost:before{content:""}.fa-snapchat-square:before{content:""}.fa-pied-piper:before{content:""}.fa-first-order:before{content:""}.fa-yoast:before{content:""}.fa-themeisle:before{content:""}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:""}.fa-fa:before,.fa-font-awesome:before{content:""}.fa-handshake-o:before{content:""}.fa-envelope-open:before{content:""}.fa-envelope-open-o:before{content:""}.fa-linode:before{content:""}.fa-address-book:before{content:""}.fa-address-book-o:before{content:""}.fa-address-card:before,.fa-vcard:before{content:""}.fa-address-card-o:before,.fa-vcard-o:before{content:""}.fa-user-circle:before{content:""}.fa-user-circle-o:before{content:""}.fa-user-o:before{content:""}.fa-id-badge:before{content:""}.fa-drivers-license:before,.fa-id-card:before{content:""}.fa-drivers-license-o:before,.fa-id-card-o:before{content:""}.fa-quora:before{content:""}.fa-free-code-camp:before{content:""}.fa-telegram:before{content:""}.fa-thermometer-4:before,.fa-thermometer-full:before,.fa-thermometer:before{content:""}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:""}.fa-thermometer-2:before,.fa-thermometer-half:before{content:""}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:""}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:""}.fa-shower:before{content:""}.fa-bath:before,.fa-bathtub:before,.fa-s15:before{content:""}.fa-podcast:before{content:""}.fa-window-maximize:before{content:""}.fa-window-minimize:before{content:""}.fa-window-restore:before{content:""}.fa-times-rectangle:before,.fa-window-close:before{content:""}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:""}.fa-bandcamp:before{content:""}.fa-grav:before{content:""}.fa-etsy:before{content:""}.fa-imdb:before{content:""}.fa-ravelry:before{content:""}.fa-eercast:before{content:""}.fa-microchip:before{content:""}.fa-snowflake-o:before{content:""}.fa-superpowers:before{content:""}.fa-wpexplorer:before{content:""}.fa-meetup:before{content:""}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-dropdown .caret,.wy-inline-validate.wy-inline-validate-danger .wy-input-context,.wy-inline-validate.wy-inline-validate-info .wy-input-context,.wy-inline-validate.wy-inline-validate-success .wy-input-context,.wy-inline-validate.wy-inline-validate-warning .wy-input-context,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{font-family:inherit}.fa:before,.icon:before,.rst-content .admonition-title:before,.rst-content .code-block-caption .headerlink:before,.rst-content .eqno .headerlink:before,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before{font-family:FontAwesome;display:inline-block;font-style:normal;font-weight:400;line-height:1;text-decoration:inherit}.rst-content .code-block-caption a .headerlink,.rst-content .eqno a .headerlink,.rst-content a .admonition-title,.rst-content code.download a span:first-child,.rst-content dl dt a .headerlink,.rst-content h1 a .headerlink,.rst-content h2 a .headerlink,.rst-content h3 a .headerlink,.rst-content h4 a .headerlink,.rst-content h5 a .headerlink,.rst-content h6 a .headerlink,.rst-content p.caption a .headerlink,.rst-content p a .headerlink,.rst-content table>caption a .headerlink,.rst-content tt.download a span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li a button.toctree-expand,a .fa,a .icon,a .rst-content .admonition-title,a .rst-content .code-block-caption .headerlink,a .rst-content .eqno .headerlink,a .rst-content code.download span:first-child,a .rst-content dl dt .headerlink,a .rst-content h1 .headerlink,a .rst-content h2 .headerlink,a .rst-content h3 .headerlink,a .rst-content h4 .headerlink,a .rst-content h5 .headerlink,a .rst-content h6 .headerlink,a .rst-content p.caption .headerlink,a .rst-content p .headerlink,a .rst-content table>caption .headerlink,a .rst-content tt.download span:first-child,a .wy-menu-vertical li button.toctree-expand{display:inline-block;text-decoration:inherit}.btn .fa,.btn .icon,.btn .rst-content .admonition-title,.btn .rst-content .code-block-caption .headerlink,.btn .rst-content .eqno .headerlink,.btn .rst-content code.download span:first-child,.btn .rst-content dl dt .headerlink,.btn .rst-content h1 .headerlink,.btn .rst-content h2 .headerlink,.btn .rst-content h3 .headerlink,.btn .rst-content h4 .headerlink,.btn .rst-content h5 .headerlink,.btn .rst-content h6 .headerlink,.btn .rst-content p .headerlink,.btn .rst-content table>caption .headerlink,.btn .rst-content tt.download span:first-child,.btn .wy-menu-vertical li.current>a button.toctree-expand,.btn .wy-menu-vertical li.on a button.toctree-expand,.btn .wy-menu-vertical li button.toctree-expand,.nav .fa,.nav .icon,.nav .rst-content .admonition-title,.nav .rst-content .code-block-caption .headerlink,.nav .rst-content .eqno .headerlink,.nav .rst-content code.download span:first-child,.nav .rst-content dl dt .headerlink,.nav .rst-content h1 .headerlink,.nav .rst-content h2 .headerlink,.nav .rst-content h3 .headerlink,.nav .rst-content h4 .headerlink,.nav .rst-content h5 .headerlink,.nav .rst-content h6 .headerlink,.nav .rst-content p .headerlink,.nav .rst-content table>caption .headerlink,.nav .rst-content tt.download span:first-child,.nav .wy-menu-vertical li.current>a button.toctree-expand,.nav .wy-menu-vertical li.on a button.toctree-expand,.nav .wy-menu-vertical li button.toctree-expand,.rst-content .btn .admonition-title,.rst-content .code-block-caption .btn .headerlink,.rst-content .code-block-caption .nav .headerlink,.rst-content .eqno .btn .headerlink,.rst-content .eqno .nav .headerlink,.rst-content .nav .admonition-title,.rst-content code.download .btn span:first-child,.rst-content code.download .nav span:first-child,.rst-content dl dt .btn .headerlink,.rst-content dl dt .nav .headerlink,.rst-content h1 .btn .headerlink,.rst-content h1 .nav .headerlink,.rst-content h2 .btn .headerlink,.rst-content h2 .nav .headerlink,.rst-content h3 .btn .headerlink,.rst-content h3 .nav .headerlink,.rst-content h4 .btn .headerlink,.rst-content h4 .nav .headerlink,.rst-content h5 .btn .headerlink,.rst-content h5 .nav .headerlink,.rst-content h6 .btn .headerlink,.rst-content h6 .nav .headerlink,.rst-content p .btn .headerlink,.rst-content p .nav .headerlink,.rst-content table>caption .btn .headerlink,.rst-content table>caption .nav .headerlink,.rst-content tt.download .btn span:first-child,.rst-content tt.download .nav span:first-child,.wy-menu-vertical li .btn button.toctree-expand,.wy-menu-vertical li.current>a .btn button.toctree-expand,.wy-menu-vertical li.current>a .nav button.toctree-expand,.wy-menu-vertical li .nav button.toctree-expand,.wy-menu-vertical li.on a .btn button.toctree-expand,.wy-menu-vertical li.on a .nav button.toctree-expand{display:inline}.btn .fa-large.icon,.btn .fa.fa-large,.btn .rst-content .code-block-caption .fa-large.headerlink,.btn .rst-content .eqno .fa-large.headerlink,.btn .rst-content .fa-large.admonition-title,.btn .rst-content code.download span.fa-large:first-child,.btn .rst-content dl dt .fa-large.headerlink,.btn .rst-content h1 .fa-large.headerlink,.btn .rst-content h2 .fa-large.headerlink,.btn .rst-content h3 .fa-large.headerlink,.btn .rst-content h4 .fa-large.headerlink,.btn .rst-content h5 .fa-large.headerlink,.btn .rst-content h6 .fa-large.headerlink,.btn .rst-content p .fa-large.headerlink,.btn .rst-content table>caption .fa-large.headerlink,.btn .rst-content tt.download span.fa-large:first-child,.btn .wy-menu-vertical li button.fa-large.toctree-expand,.nav .fa-large.icon,.nav .fa.fa-large,.nav .rst-content .code-block-caption .fa-large.headerlink,.nav .rst-content .eqno .fa-large.headerlink,.nav .rst-content .fa-large.admonition-title,.nav .rst-content code.download span.fa-large:first-child,.nav .rst-content dl dt .fa-large.headerlink,.nav .rst-content h1 .fa-large.headerlink,.nav .rst-content h2 .fa-large.headerlink,.nav .rst-content h3 .fa-large.headerlink,.nav .rst-content h4 .fa-large.headerlink,.nav .rst-content h5 .fa-large.headerlink,.nav .rst-content h6 .fa-large.headerlink,.nav .rst-content p .fa-large.headerlink,.nav .rst-content table>caption .fa-large.headerlink,.nav .rst-content tt.download span.fa-large:first-child,.nav .wy-menu-vertical li button.fa-large.toctree-expand,.rst-content .btn .fa-large.admonition-title,.rst-content .code-block-caption .btn .fa-large.headerlink,.rst-content .code-block-caption .nav .fa-large.headerlink,.rst-content .eqno .btn .fa-large.headerlink,.rst-content .eqno .nav .fa-large.headerlink,.rst-content .nav .fa-large.admonition-title,.rst-content code.download .btn span.fa-large:first-child,.rst-content code.download .nav span.fa-large:first-child,.rst-content dl dt .btn .fa-large.headerlink,.rst-content dl dt .nav .fa-large.headerlink,.rst-content h1 .btn .fa-large.headerlink,.rst-content h1 .nav .fa-large.headerlink,.rst-content h2 .btn .fa-large.headerlink,.rst-content h2 .nav .fa-large.headerlink,.rst-content h3 .btn .fa-large.headerlink,.rst-content h3 .nav .fa-large.headerlink,.rst-content h4 .btn .fa-large.headerlink,.rst-content h4 .nav .fa-large.headerlink,.rst-content h5 .btn .fa-large.headerlink,.rst-content h5 .nav .fa-large.headerlink,.rst-content h6 .btn .fa-large.headerlink,.rst-content h6 .nav .fa-large.headerlink,.rst-content p .btn .fa-large.headerlink,.rst-content p .nav .fa-large.headerlink,.rst-content table>caption .btn .fa-large.headerlink,.rst-content table>caption .nav .fa-large.headerlink,.rst-content tt.download .btn span.fa-large:first-child,.rst-content tt.download .nav span.fa-large:first-child,.wy-menu-vertical li .btn button.fa-large.toctree-expand,.wy-menu-vertical li .nav button.fa-large.toctree-expand{line-height:.9em}.btn .fa-spin.icon,.btn .fa.fa-spin,.btn .rst-content .code-block-caption .fa-spin.headerlink,.btn .rst-content .eqno .fa-spin.headerlink,.btn .rst-content .fa-spin.admonition-title,.btn .rst-content code.download span.fa-spin:first-child,.btn .rst-content dl dt .fa-spin.headerlink,.btn .rst-content h1 .fa-spin.headerlink,.btn .rst-content h2 .fa-spin.headerlink,.btn .rst-content h3 .fa-spin.headerlink,.btn .rst-content h4 .fa-spin.headerlink,.btn .rst-content h5 .fa-spin.headerlink,.btn .rst-content h6 .fa-spin.headerlink,.btn .rst-content p .fa-spin.headerlink,.btn .rst-content table>caption .fa-spin.headerlink,.btn .rst-content tt.download span.fa-spin:first-child,.btn .wy-menu-vertical li button.fa-spin.toctree-expand,.nav .fa-spin.icon,.nav .fa.fa-spin,.nav .rst-content .code-block-caption .fa-spin.headerlink,.nav .rst-content .eqno .fa-spin.headerlink,.nav .rst-content .fa-spin.admonition-title,.nav .rst-content code.download span.fa-spin:first-child,.nav .rst-content dl dt .fa-spin.headerlink,.nav .rst-content h1 .fa-spin.headerlink,.nav .rst-content h2 .fa-spin.headerlink,.nav .rst-content h3 .fa-spin.headerlink,.nav .rst-content h4 .fa-spin.headerlink,.nav .rst-content h5 .fa-spin.headerlink,.nav .rst-content h6 .fa-spin.headerlink,.nav .rst-content p .fa-spin.headerlink,.nav .rst-content table>caption .fa-spin.headerlink,.nav .rst-content tt.download span.fa-spin:first-child,.nav .wy-menu-vertical li button.fa-spin.toctree-expand,.rst-content .btn .fa-spin.admonition-title,.rst-content .code-block-caption .btn .fa-spin.headerlink,.rst-content .code-block-caption .nav .fa-spin.headerlink,.rst-content .eqno .btn .fa-spin.headerlink,.rst-content .eqno .nav .fa-spin.headerlink,.rst-content .nav .fa-spin.admonition-title,.rst-content code.download .btn span.fa-spin:first-child,.rst-content code.download .nav span.fa-spin:first-child,.rst-content dl dt .btn .fa-spin.headerlink,.rst-content dl dt .nav .fa-spin.headerlink,.rst-content h1 .btn .fa-spin.headerlink,.rst-content h1 .nav .fa-spin.headerlink,.rst-content h2 .btn .fa-spin.headerlink,.rst-content h2 .nav .fa-spin.headerlink,.rst-content h3 .btn .fa-spin.headerlink,.rst-content h3 .nav .fa-spin.headerlink,.rst-content h4 .btn .fa-spin.headerlink,.rst-content h4 .nav .fa-spin.headerlink,.rst-content h5 .btn .fa-spin.headerlink,.rst-content h5 .nav .fa-spin.headerlink,.rst-content h6 .btn .fa-spin.headerlink,.rst-content h6 .nav .fa-spin.headerlink,.rst-content p .btn .fa-spin.headerlink,.rst-content p .nav .fa-spin.headerlink,.rst-content table>caption .btn .fa-spin.headerlink,.rst-content table>caption .nav .fa-spin.headerlink,.rst-content tt.download .btn span.fa-spin:first-child,.rst-content tt.download .nav span.fa-spin:first-child,.wy-menu-vertical li .btn button.fa-spin.toctree-expand,.wy-menu-vertical li .nav button.fa-spin.toctree-expand{display:inline-block}.btn.fa:before,.btn.icon:before,.rst-content .btn.admonition-title:before,.rst-content .code-block-caption .btn.headerlink:before,.rst-content .eqno .btn.headerlink:before,.rst-content code.download span.btn:first-child:before,.rst-content dl dt .btn.headerlink:before,.rst-content h1 .btn.headerlink:before,.rst-content h2 .btn.headerlink:before,.rst-content h3 .btn.headerlink:before,.rst-content h4 .btn.headerlink:before,.rst-content h5 .btn.headerlink:before,.rst-content h6 .btn.headerlink:before,.rst-content p .btn.headerlink:before,.rst-content table>caption .btn.headerlink:before,.rst-content tt.download span.btn:first-child:before,.wy-menu-vertical li button.btn.toctree-expand:before{opacity:.5;-webkit-transition:opacity .05s ease-in;-moz-transition:opacity .05s ease-in;transition:opacity .05s ease-in}.btn.fa:hover:before,.btn.icon:hover:before,.rst-content .btn.admonition-title:hover:before,.rst-content .code-block-caption .btn.headerlink:hover:before,.rst-content .eqno .btn.headerlink:hover:before,.rst-content code.download span.btn:first-child:hover:before,.rst-content dl dt .btn.headerlink:hover:before,.rst-content h1 .btn.headerlink:hover:before,.rst-content h2 .btn.headerlink:hover:before,.rst-content h3 .btn.headerlink:hover:before,.rst-content h4 .btn.headerlink:hover:before,.rst-content h5 .btn.headerlink:hover:before,.rst-content h6 .btn.headerlink:hover:before,.rst-content p .btn.headerlink:hover:before,.rst-content table>caption .btn.headerlink:hover:before,.rst-content tt.download span.btn:first-child:hover:before,.wy-menu-vertical li button.btn.toctree-expand:hover:before{opacity:1}.btn-mini .fa:before,.btn-mini .icon:before,.btn-mini .rst-content .admonition-title:before,.btn-mini .rst-content .code-block-caption .headerlink:before,.btn-mini .rst-content .eqno .headerlink:before,.btn-mini .rst-content code.download span:first-child:before,.btn-mini .rst-content dl dt .headerlink:before,.btn-mini .rst-content h1 .headerlink:before,.btn-mini .rst-content h2 .headerlink:before,.btn-mini .rst-content h3 .headerlink:before,.btn-mini .rst-content h4 .headerlink:before,.btn-mini .rst-content h5 .headerlink:before,.btn-mini .rst-content h6 .headerlink:before,.btn-mini .rst-content p .headerlink:before,.btn-mini .rst-content table>caption .headerlink:before,.btn-mini .rst-content tt.download span:first-child:before,.btn-mini .wy-menu-vertical li button.toctree-expand:before,.rst-content .btn-mini .admonition-title:before,.rst-content .code-block-caption .btn-mini .headerlink:before,.rst-content .eqno .btn-mini .headerlink:before,.rst-content code.download .btn-mini span:first-child:before,.rst-content dl dt .btn-mini .headerlink:before,.rst-content h1 .btn-mini .headerlink:before,.rst-content h2 .btn-mini .headerlink:before,.rst-content h3 .btn-mini .headerlink:before,.rst-content h4 .btn-mini .headerlink:before,.rst-content h5 .btn-mini .headerlink:before,.rst-content h6 .btn-mini .headerlink:before,.rst-content p .btn-mini .headerlink:before,.rst-content table>caption .btn-mini .headerlink:before,.rst-content tt.download .btn-mini span:first-child:before,.wy-menu-vertical li .btn-mini button.toctree-expand:before{font-size:14px;vertical-align:-15%}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.wy-alert{padding:12px;line-height:24px;margin-bottom:24px;background:#e7f2fa}.rst-content .admonition-title,.wy-alert-title{font-weight:700;display:block;color:#fff;background:#6ab0de;padding:6px 12px;margin:-12px -12px 12px}.rst-content .danger,.rst-content .error,.rst-content .wy-alert-danger.admonition,.rst-content .wy-alert-danger.admonition-todo,.rst-content .wy-alert-danger.attention,.rst-content .wy-alert-danger.caution,.rst-content .wy-alert-danger.hint,.rst-content .wy-alert-danger.important,.rst-content .wy-alert-danger.note,.rst-content .wy-alert-danger.seealso,.rst-content .wy-alert-danger.tip,.rst-content .wy-alert-danger.warning,.wy-alert.wy-alert-danger{background:#fdf3f2}.rst-content .danger .admonition-title,.rst-content .danger .wy-alert-title,.rst-content .error .admonition-title,.rst-content .error .wy-alert-title,.rst-content .wy-alert-danger.admonition-todo .admonition-title,.rst-content .wy-alert-danger.admonition-todo .wy-alert-title,.rst-content .wy-alert-danger.admonition .admonition-title,.rst-content .wy-alert-danger.admonition .wy-alert-title,.rst-content .wy-alert-danger.attention .admonition-title,.rst-content .wy-alert-danger.attention .wy-alert-title,.rst-content .wy-alert-danger.caution .admonition-title,.rst-content .wy-alert-danger.caution .wy-alert-title,.rst-content .wy-alert-danger.hint .admonition-title,.rst-content .wy-alert-danger.hint .wy-alert-title,.rst-content .wy-alert-danger.important .admonition-title,.rst-content .wy-alert-danger.important .wy-alert-title,.rst-content .wy-alert-danger.note .admonition-title,.rst-content .wy-alert-danger.note .wy-alert-title,.rst-content .wy-alert-danger.seealso .admonition-title,.rst-content .wy-alert-danger.seealso .wy-alert-title,.rst-content .wy-alert-danger.tip .admonition-title,.rst-content .wy-alert-danger.tip .wy-alert-title,.rst-content .wy-alert-danger.warning .admonition-title,.rst-content .wy-alert-danger.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-danger .admonition-title,.wy-alert.wy-alert-danger .rst-content .admonition-title,.wy-alert.wy-alert-danger .wy-alert-title{background:#f29f97}.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .warning,.rst-content .wy-alert-warning.admonition,.rst-content .wy-alert-warning.danger,.rst-content .wy-alert-warning.error,.rst-content .wy-alert-warning.hint,.rst-content .wy-alert-warning.important,.rst-content .wy-alert-warning.note,.rst-content .wy-alert-warning.seealso,.rst-content .wy-alert-warning.tip,.wy-alert.wy-alert-warning{background:#ffedcc}.rst-content .admonition-todo .admonition-title,.rst-content .admonition-todo .wy-alert-title,.rst-content .attention .admonition-title,.rst-content .attention .wy-alert-title,.rst-content .caution .admonition-title,.rst-content .caution .wy-alert-title,.rst-content .warning .admonition-title,.rst-content .warning .wy-alert-title,.rst-content .wy-alert-warning.admonition .admonition-title,.rst-content .wy-alert-warning.admonition .wy-alert-title,.rst-content .wy-alert-warning.danger .admonition-title,.rst-content .wy-alert-warning.danger .wy-alert-title,.rst-content .wy-alert-warning.error .admonition-title,.rst-content .wy-alert-warning.error .wy-alert-title,.rst-content .wy-alert-warning.hint .admonition-title,.rst-content .wy-alert-warning.hint .wy-alert-title,.rst-content .wy-alert-warning.important .admonition-title,.rst-content .wy-alert-warning.important .wy-alert-title,.rst-content .wy-alert-warning.note .admonition-title,.rst-content .wy-alert-warning.note .wy-alert-title,.rst-content .wy-alert-warning.seealso .admonition-title,.rst-content .wy-alert-warning.seealso .wy-alert-title,.rst-content .wy-alert-warning.tip .admonition-title,.rst-content .wy-alert-warning.tip .wy-alert-title,.rst-content .wy-alert.wy-alert-warning .admonition-title,.wy-alert.wy-alert-warning .rst-content .admonition-title,.wy-alert.wy-alert-warning .wy-alert-title{background:#f0b37e}.rst-content .note,.rst-content .seealso,.rst-content .wy-alert-info.admonition,.rst-content .wy-alert-info.admonition-todo,.rst-content .wy-alert-info.attention,.rst-content .wy-alert-info.caution,.rst-content .wy-alert-info.danger,.rst-content .wy-alert-info.error,.rst-content .wy-alert-info.hint,.rst-content .wy-alert-info.important,.rst-content .wy-alert-info.tip,.rst-content .wy-alert-info.warning,.wy-alert.wy-alert-info{background:#e7f2fa}.rst-content .note .admonition-title,.rst-content .note .wy-alert-title,.rst-content .seealso .admonition-title,.rst-content .seealso .wy-alert-title,.rst-content .wy-alert-info.admonition-todo .admonition-title,.rst-content .wy-alert-info.admonition-todo .wy-alert-title,.rst-content .wy-alert-info.admonition .admonition-title,.rst-content .wy-alert-info.admonition .wy-alert-title,.rst-content .wy-alert-info.attention .admonition-title,.rst-content .wy-alert-info.attention .wy-alert-title,.rst-content .wy-alert-info.caution .admonition-title,.rst-content .wy-alert-info.caution .wy-alert-title,.rst-content .wy-alert-info.danger .admonition-title,.rst-content .wy-alert-info.danger .wy-alert-title,.rst-content .wy-alert-info.error .admonition-title,.rst-content .wy-alert-info.error .wy-alert-title,.rst-content .wy-alert-info.hint .admonition-title,.rst-content .wy-alert-info.hint .wy-alert-title,.rst-content .wy-alert-info.important .admonition-title,.rst-content .wy-alert-info.important .wy-alert-title,.rst-content .wy-alert-info.tip .admonition-title,.rst-content .wy-alert-info.tip .wy-alert-title,.rst-content .wy-alert-info.warning .admonition-title,.rst-content .wy-alert-info.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-info .admonition-title,.wy-alert.wy-alert-info .rst-content .admonition-title,.wy-alert.wy-alert-info .wy-alert-title{background:#6ab0de}.rst-content .hint,.rst-content .important,.rst-content .tip,.rst-content .wy-alert-success.admonition,.rst-content .wy-alert-success.admonition-todo,.rst-content .wy-alert-success.attention,.rst-content .wy-alert-success.caution,.rst-content .wy-alert-success.danger,.rst-content .wy-alert-success.error,.rst-content .wy-alert-success.note,.rst-content .wy-alert-success.seealso,.rst-content .wy-alert-success.warning,.wy-alert.wy-alert-success{background:#dbfaf4}.rst-content .hint .admonition-title,.rst-content .hint .wy-alert-title,.rst-content .important .admonition-title,.rst-content .important .wy-alert-title,.rst-content .tip .admonition-title,.rst-content .tip .wy-alert-title,.rst-content .wy-alert-success.admonition-todo .admonition-title,.rst-content .wy-alert-success.admonition-todo .wy-alert-title,.rst-content .wy-alert-success.admonition .admonition-title,.rst-content .wy-alert-success.admonition .wy-alert-title,.rst-content .wy-alert-success.attention .admonition-title,.rst-content .wy-alert-success.attention .wy-alert-title,.rst-content .wy-alert-success.caution .admonition-title,.rst-content .wy-alert-success.caution .wy-alert-title,.rst-content .wy-alert-success.danger .admonition-title,.rst-content .wy-alert-success.danger .wy-alert-title,.rst-content .wy-alert-success.error .admonition-title,.rst-content .wy-alert-success.error .wy-alert-title,.rst-content .wy-alert-success.note .admonition-title,.rst-content .wy-alert-success.note .wy-alert-title,.rst-content .wy-alert-success.seealso .admonition-title,.rst-content .wy-alert-success.seealso .wy-alert-title,.rst-content .wy-alert-success.warning .admonition-title,.rst-content .wy-alert-success.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-success .admonition-title,.wy-alert.wy-alert-success .rst-content .admonition-title,.wy-alert.wy-alert-success .wy-alert-title{background:#1abc9c}.rst-content .wy-alert-neutral.admonition,.rst-content .wy-alert-neutral.admonition-todo,.rst-content .wy-alert-neutral.attention,.rst-content .wy-alert-neutral.caution,.rst-content .wy-alert-neutral.danger,.rst-content .wy-alert-neutral.error,.rst-content .wy-alert-neutral.hint,.rst-content .wy-alert-neutral.important,.rst-content .wy-alert-neutral.note,.rst-content .wy-alert-neutral.seealso,.rst-content .wy-alert-neutral.tip,.rst-content .wy-alert-neutral.warning,.wy-alert.wy-alert-neutral{background:#f3f6f6}.rst-content .wy-alert-neutral.admonition-todo .admonition-title,.rst-content .wy-alert-neutral.admonition-todo .wy-alert-title,.rst-content .wy-alert-neutral.admonition .admonition-title,.rst-content .wy-alert-neutral.admonition .wy-alert-title,.rst-content .wy-alert-neutral.attention .admonition-title,.rst-content .wy-alert-neutral.attention .wy-alert-title,.rst-content .wy-alert-neutral.caution .admonition-title,.rst-content .wy-alert-neutral.caution .wy-alert-title,.rst-content .wy-alert-neutral.danger .admonition-title,.rst-content .wy-alert-neutral.danger .wy-alert-title,.rst-content .wy-alert-neutral.error .admonition-title,.rst-content .wy-alert-neutral.error .wy-alert-title,.rst-content .wy-alert-neutral.hint .admonition-title,.rst-content .wy-alert-neutral.hint .wy-alert-title,.rst-content .wy-alert-neutral.important .admonition-title,.rst-content .wy-alert-neutral.important .wy-alert-title,.rst-content .wy-alert-neutral.note .admonition-title,.rst-content .wy-alert-neutral.note .wy-alert-title,.rst-content .wy-alert-neutral.seealso .admonition-title,.rst-content .wy-alert-neutral.seealso .wy-alert-title,.rst-content .wy-alert-neutral.tip .admonition-title,.rst-content .wy-alert-neutral.tip .wy-alert-title,.rst-content .wy-alert-neutral.warning .admonition-title,.rst-content .wy-alert-neutral.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-neutral .admonition-title,.wy-alert.wy-alert-neutral .rst-content .admonition-title,.wy-alert.wy-alert-neutral .wy-alert-title{color:#404040;background:#e1e4e5}.rst-content .wy-alert-neutral.admonition-todo a,.rst-content .wy-alert-neutral.admonition a,.rst-content .wy-alert-neutral.attention a,.rst-content .wy-alert-neutral.caution a,.rst-content .wy-alert-neutral.danger a,.rst-content .wy-alert-neutral.error a,.rst-content .wy-alert-neutral.hint a,.rst-content .wy-alert-neutral.important a,.rst-content .wy-alert-neutral.note a,.rst-content .wy-alert-neutral.seealso a,.rst-content .wy-alert-neutral.tip a,.rst-content .wy-alert-neutral.warning a,.wy-alert.wy-alert-neutral a{color:#2980b9}.rst-content .admonition-todo p:last-child,.rst-content .admonition p:last-child,.rst-content .attention p:last-child,.rst-content .caution p:last-child,.rst-content .danger p:last-child,.rst-content .error p:last-child,.rst-content .hint p:last-child,.rst-content .important p:last-child,.rst-content .note p:last-child,.rst-content .seealso p:last-child,.rst-content .tip p:last-child,.rst-content .warning p:last-child,.wy-alert p:last-child{margin-bottom:0}.wy-tray-container{position:fixed;bottom:0;left:0;z-index:600}.wy-tray-container li{display:block;width:300px;background:transparent;color:#fff;text-align:center;box-shadow:0 5px 5px 0 rgba(0,0,0,.1);padding:0 24px;min-width:20%;opacity:0;height:0;line-height:56px;overflow:hidden;-webkit-transition:all .3s ease-in;-moz-transition:all .3s ease-in;transition:all .3s ease-in}.wy-tray-container li.wy-tray-item-success{background:#27ae60}.wy-tray-container li.wy-tray-item-info{background:#2980b9}.wy-tray-container li.wy-tray-item-warning{background:#e67e22}.wy-tray-container li.wy-tray-item-danger{background:#e74c3c}.wy-tray-container li.on{opacity:1;height:56px}@media screen and (max-width:768px){.wy-tray-container{bottom:auto;top:0;width:100%}.wy-tray-container li{width:100%}}button{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle;cursor:pointer;line-height:normal;-webkit-appearance:button;*overflow:visible}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}button[disabled]{cursor:default}.btn{display:inline-block;border-radius:2px;line-height:normal;white-space:nowrap;text-align:center;cursor:pointer;font-size:100%;padding:6px 12px 8px;color:#fff;border:1px solid rgba(0,0,0,.1);background-color:#27ae60;text-decoration:none;font-weight:400;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 2px -1px hsla(0,0%,100%,.5),inset 0 -2px 0 0 rgba(0,0,0,.1);outline-none:false;vertical-align:middle;*display:inline;zoom:1;-webkit-user-drag:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-transition:all .1s linear;-moz-transition:all .1s linear;transition:all .1s linear}.btn-hover{background:#2e8ece;color:#fff}.btn:hover{background:#2cc36b;color:#fff}.btn:focus{background:#2cc36b;outline:0}.btn:active{box-shadow:inset 0 -1px 0 0 rgba(0,0,0,.05),inset 0 2px 0 0 rgba(0,0,0,.1);padding:8px 12px 6px}.btn:visited{color:#fff}.btn-disabled,.btn-disabled:active,.btn-disabled:focus,.btn-disabled:hover,.btn:disabled{background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);filter:alpha(opacity=40);opacity:.4;cursor:not-allowed;box-shadow:none}.btn::-moz-focus-inner{padding:0;border:0}.btn-small{font-size:80%}.btn-info{background-color:#2980b9!important}.btn-info:hover{background-color:#2e8ece!important}.btn-neutral{background-color:#f3f6f6!important;color:#404040!important}.btn-neutral:hover{background-color:#e5ebeb!important;color:#404040}.btn-neutral:visited{color:#404040!important}.btn-success{background-color:#27ae60!important}.btn-success:hover{background-color:#295!important}.btn-danger{background-color:#e74c3c!important}.btn-danger:hover{background-color:#ea6153!important}.btn-warning{background-color:#e67e22!important}.btn-warning:hover{background-color:#e98b39!important}.btn-invert{background-color:#222}.btn-invert:hover{background-color:#2f2f2f!important}.btn-link{background-color:transparent!important;color:#2980b9;box-shadow:none;border-color:transparent!important}.btn-link:active,.btn-link:hover{background-color:transparent!important;color:#409ad5!important;box-shadow:none}.btn-link:visited{color:#9b59b6}.wy-btn-group .btn,.wy-control .btn{vertical-align:middle}.wy-btn-group{margin-bottom:24px;*zoom:1}.wy-btn-group:after,.wy-btn-group:before{display:table;content:""}.wy-btn-group:after{clear:both}.wy-dropdown{position:relative;display:inline-block}.wy-dropdown-active .wy-dropdown-menu{display:block}.wy-dropdown-menu{position:absolute;left:0;display:none;float:left;top:100%;min-width:100%;background:#fcfcfc;z-index:100;border:1px solid #cfd7dd;box-shadow:0 2px 2px 0 rgba(0,0,0,.1);padding:12px}.wy-dropdown-menu>dd>a{display:block;clear:both;color:#404040;white-space:nowrap;font-size:90%;padding:0 12px;cursor:pointer}.wy-dropdown-menu>dd>a:hover{background:#2980b9;color:#fff}.wy-dropdown-menu>dd.divider{border-top:1px solid #cfd7dd;margin:6px 0}.wy-dropdown-menu>dd.search{padding-bottom:12px}.wy-dropdown-menu>dd.search input[type=search]{width:100%}.wy-dropdown-menu>dd.call-to-action{background:#e3e3e3;text-transform:uppercase;font-weight:500;font-size:80%}.wy-dropdown-menu>dd.call-to-action:hover{background:#e3e3e3}.wy-dropdown-menu>dd.call-to-action .btn{color:#fff}.wy-dropdown.wy-dropdown-up .wy-dropdown-menu{bottom:100%;top:auto;left:auto;right:0}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu{background:#fcfcfc;margin-top:2px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a{padding:6px 12px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a:hover{background:#2980b9;color:#fff}.wy-dropdown.wy-dropdown-left .wy-dropdown-menu{right:0;left:auto;text-align:right}.wy-dropdown-arrow:before{content:" ";border-bottom:5px solid #f5f5f5;border-left:5px solid transparent;border-right:5px solid transparent;position:absolute;display:block;top:-4px;left:50%;margin-left:-3px}.wy-dropdown-arrow.wy-dropdown-arrow-left:before{left:11px}.wy-form-stacked select{display:block}.wy-form-aligned .wy-help-inline,.wy-form-aligned input,.wy-form-aligned label,.wy-form-aligned select,.wy-form-aligned textarea{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-form-aligned .wy-control-group>label{display:inline-block;vertical-align:middle;width:10em;margin:6px 12px 0 0;float:left}.wy-form-aligned .wy-control{float:left}.wy-form-aligned .wy-control label{display:block}.wy-form-aligned .wy-control select{margin-top:6px}fieldset{margin:0}fieldset,legend{border:0;padding:0}legend{width:100%;white-space:normal;margin-bottom:24px;font-size:150%;*margin-left:-7px}label,legend{display:block}label{margin:0 0 .3125em;color:#333;font-size:90%}input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}.wy-control-group{margin-bottom:24px;max-width:1200px;margin-left:auto;margin-right:auto;*zoom:1}.wy-control-group:after,.wy-control-group:before{display:table;content:""}.wy-control-group:after{clear:both}.wy-control-group.wy-control-group-required>label:after{content:" *";color:#e74c3c}.wy-control-group .wy-form-full,.wy-control-group .wy-form-halves,.wy-control-group .wy-form-thirds{padding-bottom:12px}.wy-control-group .wy-form-full input[type=color],.wy-control-group .wy-form-full input[type=date],.wy-control-group .wy-form-full input[type=datetime-local],.wy-control-group .wy-form-full input[type=datetime],.wy-control-group .wy-form-full input[type=email],.wy-control-group .wy-form-full input[type=month],.wy-control-group .wy-form-full input[type=number],.wy-control-group .wy-form-full input[type=password],.wy-control-group .wy-form-full input[type=search],.wy-control-group .wy-form-full input[type=tel],.wy-control-group .wy-form-full input[type=text],.wy-control-group .wy-form-full input[type=time],.wy-control-group .wy-form-full input[type=url],.wy-control-group .wy-form-full input[type=week],.wy-control-group .wy-form-full select,.wy-control-group .wy-form-halves input[type=color],.wy-control-group .wy-form-halves input[type=date],.wy-control-group .wy-form-halves input[type=datetime-local],.wy-control-group .wy-form-halves input[type=datetime],.wy-control-group .wy-form-halves input[type=email],.wy-control-group .wy-form-halves input[type=month],.wy-control-group .wy-form-halves input[type=number],.wy-control-group .wy-form-halves input[type=password],.wy-control-group .wy-form-halves input[type=search],.wy-control-group .wy-form-halves input[type=tel],.wy-control-group .wy-form-halves input[type=text],.wy-control-group .wy-form-halves input[type=time],.wy-control-group .wy-form-halves input[type=url],.wy-control-group .wy-form-halves input[type=week],.wy-control-group .wy-form-halves select,.wy-control-group .wy-form-thirds input[type=color],.wy-control-group .wy-form-thirds input[type=date],.wy-control-group .wy-form-thirds input[type=datetime-local],.wy-control-group .wy-form-thirds input[type=datetime],.wy-control-group .wy-form-thirds input[type=email],.wy-control-group .wy-form-thirds input[type=month],.wy-control-group .wy-form-thirds input[type=number],.wy-control-group .wy-form-thirds input[type=password],.wy-control-group .wy-form-thirds input[type=search],.wy-control-group .wy-form-thirds input[type=tel],.wy-control-group .wy-form-thirds input[type=text],.wy-control-group .wy-form-thirds input[type=time],.wy-control-group .wy-form-thirds input[type=url],.wy-control-group .wy-form-thirds input[type=week],.wy-control-group .wy-form-thirds select{width:100%}.wy-control-group .wy-form-full{float:left;display:block;width:100%;margin-right:0}.wy-control-group .wy-form-full:last-child{margin-right:0}.wy-control-group .wy-form-halves{float:left;display:block;margin-right:2.35765%;width:48.82117%}.wy-control-group .wy-form-halves:last-child,.wy-control-group .wy-form-halves:nth-of-type(2n){margin-right:0}.wy-control-group .wy-form-halves:nth-of-type(odd){clear:left}.wy-control-group .wy-form-thirds{float:left;display:block;margin-right:2.35765%;width:31.76157%}.wy-control-group .wy-form-thirds:last-child,.wy-control-group .wy-form-thirds:nth-of-type(3n){margin-right:0}.wy-control-group .wy-form-thirds:nth-of-type(3n+1){clear:left}.wy-control-group.wy-control-group-no-input .wy-control,.wy-control-no-input{margin:6px 0 0;font-size:90%}.wy-control-no-input{display:inline-block}.wy-control-group.fluid-input input[type=color],.wy-control-group.fluid-input input[type=date],.wy-control-group.fluid-input input[type=datetime-local],.wy-control-group.fluid-input input[type=datetime],.wy-control-group.fluid-input input[type=email],.wy-control-group.fluid-input input[type=month],.wy-control-group.fluid-input input[type=number],.wy-control-group.fluid-input input[type=password],.wy-control-group.fluid-input input[type=search],.wy-control-group.fluid-input input[type=tel],.wy-control-group.fluid-input input[type=text],.wy-control-group.fluid-input input[type=time],.wy-control-group.fluid-input input[type=url],.wy-control-group.fluid-input input[type=week]{width:100%}.wy-form-message-inline{padding-left:.3em;color:#666;font-size:90%}.wy-form-message{display:block;color:#999;font-size:70%;margin-top:.3125em;font-style:italic}.wy-form-message p{font-size:inherit;font-style:italic;margin-bottom:6px}.wy-form-message p:last-child{margin-bottom:0}input{line-height:normal}input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;*overflow:visible}input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week]{-webkit-appearance:none;padding:6px;display:inline-block;border:1px solid #ccc;font-size:80%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 3px #ddd;border-radius:0;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}input[type=datetime-local]{padding:.34375em .625em}input[disabled]{cursor:default}input[type=checkbox],input[type=radio]{padding:0;margin-right:.3125em;*height:13px;*width:13px}input[type=checkbox],input[type=radio],input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}input[type=color]:focus,input[type=date]:focus,input[type=datetime-local]:focus,input[type=datetime]:focus,input[type=email]:focus,input[type=month]:focus,input[type=number]:focus,input[type=password]:focus,input[type=search]:focus,input[type=tel]:focus,input[type=text]:focus,input[type=time]:focus,input[type=url]:focus,input[type=week]:focus{outline:0;outline:thin dotted\9;border-color:#333}input.no-focus:focus{border-color:#ccc!important}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:thin dotted #333;outline:1px auto #129fea}input[type=color][disabled],input[type=date][disabled],input[type=datetime-local][disabled],input[type=datetime][disabled],input[type=email][disabled],input[type=month][disabled],input[type=number][disabled],input[type=password][disabled],input[type=search][disabled],input[type=tel][disabled],input[type=text][disabled],input[type=time][disabled],input[type=url][disabled],input[type=week][disabled]{cursor:not-allowed;background-color:#fafafa}input:focus:invalid,select:focus:invalid,textarea:focus:invalid{color:#e74c3c;border:1px solid #e74c3c}input:focus:invalid:focus,select:focus:invalid:focus,textarea:focus:invalid:focus{border-color:#e74c3c}input[type=checkbox]:focus:invalid:focus,input[type=file]:focus:invalid:focus,input[type=radio]:focus:invalid:focus{outline-color:#e74c3c}input.wy-input-large{padding:12px;font-size:100%}textarea{overflow:auto;vertical-align:top;width:100%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif}select,textarea{padding:.5em .625em;display:inline-block;border:1px solid #ccc;font-size:80%;box-shadow:inset 0 1px 3px #ddd;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}select{border:1px solid #ccc;background-color:#fff}select[multiple]{height:auto}select:focus,textarea:focus{outline:0}input[readonly],select[disabled],select[readonly],textarea[disabled],textarea[readonly]{cursor:not-allowed;background-color:#fafafa}input[type=checkbox][disabled],input[type=radio][disabled]{cursor:not-allowed}.wy-checkbox,.wy-radio{margin:6px 0;color:#404040;display:block}.wy-checkbox input,.wy-radio input{vertical-align:baseline}.wy-form-message-inline{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-input-prefix,.wy-input-suffix{white-space:nowrap;padding:6px}.wy-input-prefix .wy-input-context,.wy-input-suffix .wy-input-context{line-height:27px;padding:0 8px;display:inline-block;font-size:80%;background-color:#f3f6f6;border:1px solid #ccc;color:#999}.wy-input-suffix .wy-input-context{border-left:0}.wy-input-prefix .wy-input-context{border-right:0}.wy-switch{position:relative;display:block;height:24px;margin-top:12px;cursor:pointer}.wy-switch:before{left:0;top:0;width:36px;height:12px;background:#ccc}.wy-switch:after,.wy-switch:before{position:absolute;content:"";display:block;border-radius:4px;-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.wy-switch:after{width:18px;height:18px;background:#999;left:-3px;top:-3px}.wy-switch span{position:absolute;left:48px;display:block;font-size:12px;color:#ccc;line-height:1}.wy-switch.active:before{background:#1e8449}.wy-switch.active:after{left:24px;background:#27ae60}.wy-switch.disabled{cursor:not-allowed;opacity:.8}.wy-control-group.wy-control-group-error .wy-form-message,.wy-control-group.wy-control-group-error>label{color:#e74c3c}.wy-control-group.wy-control-group-error input[type=color],.wy-control-group.wy-control-group-error input[type=date],.wy-control-group.wy-control-group-error input[type=datetime-local],.wy-control-group.wy-control-group-error input[type=datetime],.wy-control-group.wy-control-group-error input[type=email],.wy-control-group.wy-control-group-error input[type=month],.wy-control-group.wy-control-group-error input[type=number],.wy-control-group.wy-control-group-error input[type=password],.wy-control-group.wy-control-group-error input[type=search],.wy-control-group.wy-control-group-error input[type=tel],.wy-control-group.wy-control-group-error input[type=text],.wy-control-group.wy-control-group-error input[type=time],.wy-control-group.wy-control-group-error input[type=url],.wy-control-group.wy-control-group-error input[type=week],.wy-control-group.wy-control-group-error textarea{border:1px solid #e74c3c}.wy-inline-validate{white-space:nowrap}.wy-inline-validate .wy-input-context{padding:.5em .625em;display:inline-block;font-size:80%}.wy-inline-validate.wy-inline-validate-success .wy-input-context{color:#27ae60}.wy-inline-validate.wy-inline-validate-danger .wy-input-context{color:#e74c3c}.wy-inline-validate.wy-inline-validate-warning .wy-input-context{color:#e67e22}.wy-inline-validate.wy-inline-validate-info .wy-input-context{color:#2980b9}.rotate-90{-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.rotate-180{-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.rotate-270{-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.mirror{-webkit-transform:scaleX(-1);-moz-transform:scaleX(-1);-ms-transform:scaleX(-1);-o-transform:scaleX(-1);transform:scaleX(-1)}.mirror.rotate-90{-webkit-transform:scaleX(-1) rotate(90deg);-moz-transform:scaleX(-1) rotate(90deg);-ms-transform:scaleX(-1) rotate(90deg);-o-transform:scaleX(-1) rotate(90deg);transform:scaleX(-1) rotate(90deg)}.mirror.rotate-180{-webkit-transform:scaleX(-1) rotate(180deg);-moz-transform:scaleX(-1) rotate(180deg);-ms-transform:scaleX(-1) rotate(180deg);-o-transform:scaleX(-1) rotate(180deg);transform:scaleX(-1) rotate(180deg)}.mirror.rotate-270{-webkit-transform:scaleX(-1) rotate(270deg);-moz-transform:scaleX(-1) rotate(270deg);-ms-transform:scaleX(-1) rotate(270deg);-o-transform:scaleX(-1) rotate(270deg);transform:scaleX(-1) rotate(270deg)}@media only screen and (max-width:480px){.wy-form button[type=submit]{margin:.7em 0 0}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=text],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week],.wy-form label{margin-bottom:.3em;display:block}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week]{margin-bottom:0}.wy-form-aligned .wy-control-group label{margin-bottom:.3em;text-align:left;display:block;width:100%}.wy-form-aligned .wy-control{margin:1.5em 0 0}.wy-form-message,.wy-form-message-inline,.wy-form .wy-help-inline{display:block;font-size:80%;padding:6px 0}}@media screen and (max-width:768px){.tablet-hide{display:none}}@media screen and (max-width:480px){.mobile-hide{display:none}}.float-left{float:left}.float-right{float:right}.full-width{width:100%}.rst-content table.docutils,.rst-content table.field-list,.wy-table{border-collapse:collapse;border-spacing:0;empty-cells:show;margin-bottom:24px}.rst-content table.docutils caption,.rst-content table.field-list caption,.wy-table caption{color:#000;font:italic 85%/1 arial,sans-serif;padding:1em 0;text-align:center}.rst-content table.docutils td,.rst-content table.docutils th,.rst-content table.field-list td,.rst-content table.field-list th,.wy-table td,.wy-table th{font-size:90%;margin:0;overflow:visible;padding:8px 16px}.rst-content table.docutils td:first-child,.rst-content table.docutils th:first-child,.rst-content table.field-list td:first-child,.rst-content table.field-list th:first-child,.wy-table td:first-child,.wy-table th:first-child{border-left-width:0}.rst-content table.docutils thead,.rst-content table.field-list thead,.wy-table thead{color:#000;text-align:left;vertical-align:bottom;white-space:nowrap}.rst-content table.docutils thead th,.rst-content table.field-list thead th,.wy-table thead th{font-weight:700;border-bottom:2px solid #e1e4e5}.rst-content table.docutils td,.rst-content table.field-list td,.wy-table td{background-color:transparent;vertical-align:middle}.rst-content table.docutils td p,.rst-content table.field-list td p,.wy-table td p{line-height:18px}.rst-content table.docutils td p:last-child,.rst-content table.field-list td p:last-child,.wy-table td p:last-child{margin-bottom:0}.rst-content table.docutils .wy-table-cell-min,.rst-content table.field-list .wy-table-cell-min,.wy-table .wy-table-cell-min{width:1%;padding-right:0}.rst-content table.docutils .wy-table-cell-min input[type=checkbox],.rst-content table.field-list .wy-table-cell-min input[type=checkbox],.wy-table .wy-table-cell-min input[type=checkbox]{margin:0}.wy-table-secondary{color:grey;font-size:90%}.wy-table-tertiary{color:grey;font-size:80%}.rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td,.wy-table-backed,.wy-table-odd td,.wy-table-striped tr:nth-child(2n-1) td{background-color:#f3f6f6}.rst-content table.docutils,.wy-table-bordered-all{border:1px solid #e1e4e5}.rst-content table.docutils td,.wy-table-bordered-all td{border-bottom:1px solid #e1e4e5;border-left:1px solid #e1e4e5}.rst-content table.docutils tbody>tr:last-child td,.wy-table-bordered-all tbody>tr:last-child td{border-bottom-width:0}.wy-table-bordered{border:1px solid #e1e4e5}.wy-table-bordered-rows td{border-bottom:1px solid #e1e4e5}.wy-table-bordered-rows tbody>tr:last-child td{border-bottom-width:0}.wy-table-horizontal td,.wy-table-horizontal th{border-width:0 0 1px;border-bottom:1px solid #e1e4e5}.wy-table-horizontal tbody>tr:last-child td{border-bottom-width:0}.wy-table-responsive{margin-bottom:24px;max-width:100%;overflow:auto}.wy-table-responsive table{margin-bottom:0!important}.wy-table-responsive table td,.wy-table-responsive table th{white-space:nowrap}a{color:#2980b9;text-decoration:none;cursor:pointer}a:hover{color:#3091d1}a:visited{color:#9b59b6}html{height:100%}body,html{overflow-x:hidden}body{font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;font-weight:400;color:#404040;min-height:100%;background:#edf0f2}.wy-text-left{text-align:left}.wy-text-center{text-align:center}.wy-text-right{text-align:right}.wy-text-large{font-size:120%}.wy-text-normal{font-size:100%}.wy-text-small,small{font-size:80%}.wy-text-strike{text-decoration:line-through}.wy-text-warning{color:#e67e22!important}a.wy-text-warning:hover{color:#eb9950!important}.wy-text-info{color:#2980b9!important}a.wy-text-info:hover{color:#409ad5!important}.wy-text-success{color:#27ae60!important}a.wy-text-success:hover{color:#36d278!important}.wy-text-danger{color:#e74c3c!important}a.wy-text-danger:hover{color:#ed7669!important}.wy-text-neutral{color:#404040!important}a.wy-text-neutral:hover{color:#595959!important}.rst-content .toctree-wrapper>p.caption,h1,h2,h3,h4,h5,h6,legend{margin-top:0;font-weight:700;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif}p{line-height:24px;font-size:16px;margin:0 0 24px}h1{font-size:175%}.rst-content .toctree-wrapper>p.caption,h2{font-size:150%}h3{font-size:125%}h4{font-size:115%}h5{font-size:110%}h6{font-size:100%}hr{display:block;height:1px;border:0;border-top:1px solid #e1e4e5;margin:24px 0;padding:0}.rst-content code,.rst-content tt,code{white-space:nowrap;max-width:100%;background:#fff;border:1px solid #e1e4e5;font-size:75%;padding:0 5px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#e74c3c;overflow-x:auto}.rst-content tt.code-large,code.code-large{font-size:90%}.rst-content .section ul,.rst-content .toctree-wrapper ul,.rst-content section ul,.wy-plain-list-disc,article ul{list-style:disc;line-height:24px;margin-bottom:24px}.rst-content .section ul li,.rst-content .toctree-wrapper ul li,.rst-content section ul li,.wy-plain-list-disc li,article ul li{list-style:disc;margin-left:24px}.rst-content .section ul li p:last-child,.rst-content .section ul li ul,.rst-content .toctree-wrapper ul li p:last-child,.rst-content .toctree-wrapper ul li ul,.rst-content section ul li p:last-child,.rst-content section ul li ul,.wy-plain-list-disc li p:last-child,.wy-plain-list-disc li ul,article ul li p:last-child,article ul li ul{margin-bottom:0}.rst-content .section ul li li,.rst-content .toctree-wrapper ul li li,.rst-content section ul li li,.wy-plain-list-disc li li,article ul li li{list-style:circle}.rst-content .section ul li li li,.rst-content .toctree-wrapper ul li li li,.rst-content section ul li li li,.wy-plain-list-disc li li li,article ul li li li{list-style:square}.rst-content .section ul li ol li,.rst-content .toctree-wrapper ul li ol li,.rst-content section ul li ol li,.wy-plain-list-disc li ol li,article ul li ol li{list-style:decimal}.rst-content .section ol,.rst-content .section ol.arabic,.rst-content .toctree-wrapper ol,.rst-content .toctree-wrapper ol.arabic,.rst-content section ol,.rst-content section ol.arabic,.wy-plain-list-decimal,article ol{list-style:decimal;line-height:24px;margin-bottom:24px}.rst-content .section ol.arabic li,.rst-content .section ol li,.rst-content .toctree-wrapper ol.arabic li,.rst-content .toctree-wrapper ol li,.rst-content section ol.arabic li,.rst-content section ol li,.wy-plain-list-decimal li,article ol li{list-style:decimal;margin-left:24px}.rst-content .section ol.arabic li ul,.rst-content .section ol li p:last-child,.rst-content .section ol li ul,.rst-content .toctree-wrapper ol.arabic li ul,.rst-content .toctree-wrapper ol li p:last-child,.rst-content .toctree-wrapper ol li ul,.rst-content section ol.arabic li ul,.rst-content section ol li p:last-child,.rst-content section ol li ul,.wy-plain-list-decimal li p:last-child,.wy-plain-list-decimal li ul,article ol li p:last-child,article ol li ul{margin-bottom:0}.rst-content .section ol.arabic li ul li,.rst-content .section ol li ul li,.rst-content .toctree-wrapper ol.arabic li ul li,.rst-content .toctree-wrapper ol li ul li,.rst-content section ol.arabic li ul li,.rst-content section ol li ul li,.wy-plain-list-decimal li ul li,article ol li ul li{list-style:disc}.wy-breadcrumbs{*zoom:1}.wy-breadcrumbs:after,.wy-breadcrumbs:before{display:table;content:""}.wy-breadcrumbs:after{clear:both}.wy-breadcrumbs>li{display:inline-block;padding-top:5px}.wy-breadcrumbs>li.wy-breadcrumbs-aside{float:right}.rst-content .wy-breadcrumbs>li code,.rst-content .wy-breadcrumbs>li tt,.wy-breadcrumbs>li .rst-content tt,.wy-breadcrumbs>li code{all:inherit;color:inherit}.breadcrumb-item:before{content:"/";color:#bbb;font-size:13px;padding:0 6px 0 3px}.wy-breadcrumbs-extra{margin-bottom:0;color:#b3b3b3;font-size:80%;display:inline-block}@media screen and (max-width:480px){.wy-breadcrumbs-extra,.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}@media print{.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}html{font-size:16px}.wy-affix{position:fixed;top:1.618em}.wy-menu a:hover{text-decoration:none}.wy-menu-horiz{*zoom:1}.wy-menu-horiz:after,.wy-menu-horiz:before{display:table;content:""}.wy-menu-horiz:after{clear:both}.wy-menu-horiz li,.wy-menu-horiz ul{display:inline-block}.wy-menu-horiz li:hover{background:hsla(0,0%,100%,.1)}.wy-menu-horiz li.divide-left{border-left:1px solid #404040}.wy-menu-horiz li.divide-right{border-right:1px solid #404040}.wy-menu-horiz a{height:32px;display:inline-block;line-height:32px;padding:0 16px}.wy-menu-vertical{width:300px}.wy-menu-vertical header,.wy-menu-vertical p.caption{color:#55a5d9;height:32px;line-height:32px;padding:0 1.618em;margin:12px 0 0;display:block;font-weight:700;text-transform:uppercase;font-size:85%;white-space:nowrap}.wy-menu-vertical ul{margin-bottom:0}.wy-menu-vertical li.divide-top{border-top:1px solid #404040}.wy-menu-vertical li.divide-bottom{border-bottom:1px solid #404040}.wy-menu-vertical li.current{background:#e3e3e3}.wy-menu-vertical li.current a{color:grey;border-right:1px solid #c9c9c9;padding:.4045em 2.427em}.wy-menu-vertical li.current a:hover{background:#d6d6d6}.rst-content .wy-menu-vertical li tt,.wy-menu-vertical li .rst-content tt,.wy-menu-vertical li code{border:none;background:inherit;color:inherit;padding-left:0;padding-right:0}.wy-menu-vertical li button.toctree-expand{display:block;float:left;margin-left:-1.2em;line-height:18px;color:#4d4d4d;border:none;background:none;padding:0}.wy-menu-vertical li.current>a,.wy-menu-vertical li.on a{color:#404040;font-weight:700;position:relative;background:#fcfcfc;border:none;padding:.4045em 1.618em}.wy-menu-vertical li.current>a:hover,.wy-menu-vertical li.on a:hover{background:#fcfcfc}.wy-menu-vertical li.current>a:hover button.toctree-expand,.wy-menu-vertical li.on a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand{display:block;line-height:18px;color:#333}.wy-menu-vertical li.toctree-l1.current>a{border-bottom:1px solid #c9c9c9;border-top:1px solid #c9c9c9}.wy-menu-vertical .toctree-l1.current .toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .toctree-l11>ul{display:none}.wy-menu-vertical .toctree-l1.current .current.toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .current.toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .current.toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .current.toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .current.toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .current.toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .current.toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .current.toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .current.toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .current.toctree-l11>ul{display:block}.wy-menu-vertical li.toctree-l3,.wy-menu-vertical li.toctree-l4{font-size:.9em}.wy-menu-vertical li.toctree-l2 a,.wy-menu-vertical li.toctree-l3 a,.wy-menu-vertical li.toctree-l4 a,.wy-menu-vertical li.toctree-l5 a,.wy-menu-vertical li.toctree-l6 a,.wy-menu-vertical li.toctree-l7 a,.wy-menu-vertical li.toctree-l8 a,.wy-menu-vertical li.toctree-l9 a,.wy-menu-vertical li.toctree-l10 a{color:#404040}.wy-menu-vertical li.toctree-l2 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l3 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l4 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l5 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l6 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l7 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l8 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l9 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l10 a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a,.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a,.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a,.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a,.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a,.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a,.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a,.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{display:block}.wy-menu-vertical li.toctree-l2.current>a{padding:.4045em 2.427em}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{padding:.4045em 1.618em .4045em 4.045em}.wy-menu-vertical li.toctree-l3.current>a{padding:.4045em 4.045em}.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{padding:.4045em 1.618em .4045em 5.663em}.wy-menu-vertical li.toctree-l4.current>a{padding:.4045em 5.663em}.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a{padding:.4045em 1.618em .4045em 7.281em}.wy-menu-vertical li.toctree-l5.current>a{padding:.4045em 7.281em}.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a{padding:.4045em 1.618em .4045em 8.899em}.wy-menu-vertical li.toctree-l6.current>a{padding:.4045em 8.899em}.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a{padding:.4045em 1.618em .4045em 10.517em}.wy-menu-vertical li.toctree-l7.current>a{padding:.4045em 10.517em}.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a{padding:.4045em 1.618em .4045em 12.135em}.wy-menu-vertical li.toctree-l8.current>a{padding:.4045em 12.135em}.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a{padding:.4045em 1.618em .4045em 13.753em}.wy-menu-vertical li.toctree-l9.current>a{padding:.4045em 13.753em}.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a{padding:.4045em 1.618em .4045em 15.371em}.wy-menu-vertical li.toctree-l10.current>a{padding:.4045em 15.371em}.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{padding:.4045em 1.618em .4045em 16.989em}.wy-menu-vertical li.toctree-l2.current>a,.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{background:#c9c9c9}.wy-menu-vertical li.toctree-l2 button.toctree-expand{color:#a3a3a3}.wy-menu-vertical li.toctree-l3.current>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{background:#bdbdbd}.wy-menu-vertical li.toctree-l3 button.toctree-expand{color:#969696}.wy-menu-vertical li.current ul{display:block}.wy-menu-vertical li ul{margin-bottom:0;display:none}.wy-menu-vertical li ul li a{margin-bottom:0;color:#d9d9d9;font-weight:400}.wy-menu-vertical a{line-height:18px;padding:.4045em 1.618em;display:block;position:relative;font-size:90%;color:#d9d9d9}.wy-menu-vertical a:hover{background-color:#4e4a4a;cursor:pointer}.wy-menu-vertical a:hover button.toctree-expand{color:#d9d9d9}.wy-menu-vertical a:active{background-color:#2980b9;cursor:pointer;color:#fff}.wy-menu-vertical a:active button.toctree-expand{color:#fff}.wy-side-nav-search{display:block;width:300px;padding:.809em;margin-bottom:.809em;z-index:200;background-color:#2980b9;text-align:center;color:#fcfcfc}.wy-side-nav-search input[type=text]{width:100%;border-radius:50px;padding:6px 12px;border-color:#2472a4}.wy-side-nav-search img{display:block;margin:auto auto .809em;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-side-nav-search .wy-dropdown>a,.wy-side-nav-search>a{color:#fcfcfc;font-size:100%;font-weight:700;display:inline-block;padding:4px 6px;margin-bottom:.809em;max-width:100%}.wy-side-nav-search .wy-dropdown>a:hover,.wy-side-nav-search>a:hover{background:hsla(0,0%,100%,.1)}.wy-side-nav-search .wy-dropdown>a img.logo,.wy-side-nav-search>a img.logo{display:block;margin:0 auto;height:auto;width:auto;border-radius:0;max-width:100%;background:transparent}.wy-side-nav-search .wy-dropdown>a.icon img.logo,.wy-side-nav-search>a.icon img.logo{margin-top:.85em}.wy-side-nav-search>div.version{margin-top:-.4045em;margin-bottom:.809em;font-weight:400;color:hsla(0,0%,100%,.3)}.wy-nav .wy-menu-vertical header{color:#2980b9}.wy-nav .wy-menu-vertical a{color:#b3b3b3}.wy-nav .wy-menu-vertical a:hover{background-color:#2980b9;color:#fff}[data-menu-wrap]{-webkit-transition:all .2s ease-in;-moz-transition:all .2s ease-in;transition:all .2s ease-in;position:absolute;opacity:1;width:100%;opacity:0}[data-menu-wrap].move-center{left:0;right:auto;opacity:1}[data-menu-wrap].move-left{right:auto;left:-100%;opacity:0}[data-menu-wrap].move-right{right:-100%;left:auto;opacity:0}.wy-body-for-nav{background:#fcfcfc}.wy-grid-for-nav{position:absolute;width:100%;height:100%}.wy-nav-side{position:fixed;top:0;bottom:0;left:0;padding-bottom:2em;width:300px;overflow-x:hidden;overflow-y:hidden;min-height:100%;color:#9b9b9b;background:#343131;z-index:200}.wy-side-scroll{width:320px;position:relative;overflow-x:hidden;overflow-y:scroll;height:100%}.wy-nav-top{display:none;background:#2980b9;color:#fff;padding:.4045em .809em;position:relative;line-height:50px;text-align:center;font-size:100%;*zoom:1}.wy-nav-top:after,.wy-nav-top:before{display:table;content:""}.wy-nav-top:after{clear:both}.wy-nav-top a{color:#fff;font-weight:700}.wy-nav-top img{margin-right:12px;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-nav-top i{font-size:30px;float:left;cursor:pointer;padding-top:inherit}.wy-nav-content-wrap{margin-left:300px;background:#fcfcfc;min-height:100%}.wy-nav-content{padding:1.618em 3.236em;height:100%;max-width:800px;margin:auto}.wy-body-mask{position:fixed;width:100%;height:100%;background:rgba(0,0,0,.2);display:none;z-index:499}.wy-body-mask.on{display:block}footer{color:grey}footer p{margin-bottom:12px}.rst-content footer span.commit tt,footer span.commit .rst-content tt,footer span.commit code{padding:0;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:1em;background:none;border:none;color:grey}.rst-footer-buttons{*zoom:1}.rst-footer-buttons:after,.rst-footer-buttons:before{width:100%;display:table;content:""}.rst-footer-buttons:after{clear:both}.rst-breadcrumbs-buttons{margin-top:12px;*zoom:1}.rst-breadcrumbs-buttons:after,.rst-breadcrumbs-buttons:before{display:table;content:""}.rst-breadcrumbs-buttons:after{clear:both}#search-results .search li{margin-bottom:24px;border-bottom:1px solid #e1e4e5;padding-bottom:24px}#search-results .search li:first-child{border-top:1px solid #e1e4e5;padding-top:24px}#search-results .search li a{font-size:120%;margin-bottom:12px;display:inline-block}#search-results .context{color:grey;font-size:90%}.genindextable li>ul{margin-left:24px}@media screen and (max-width:768px){.wy-body-for-nav{background:#fcfcfc}.wy-nav-top{display:block}.wy-nav-side{left:-300px}.wy-nav-side.shift{width:85%;left:0}.wy-menu.wy-menu-vertical,.wy-side-nav-search,.wy-side-scroll{width:auto}.wy-nav-content-wrap{margin-left:0}.wy-nav-content-wrap .wy-nav-content{padding:1.618em}.wy-nav-content-wrap.shift{position:fixed;min-width:100%;left:85%;top:0;height:100%;overflow:hidden}}@media screen and (min-width:1100px){.wy-nav-content-wrap{background:rgba(0,0,0,.05)}.wy-nav-content{margin:0;background:#fcfcfc}}@media print{.rst-versions,.wy-nav-side,footer{display:none}.wy-nav-content-wrap{margin-left:0}}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60;*zoom:1}.rst-versions .rst-current-version:after,.rst-versions .rst-current-version:before{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-content .code-block-caption .rst-versions .rst-current-version .headerlink,.rst-content .eqno .rst-versions .rst-current-version .headerlink,.rst-content .rst-versions .rst-current-version .admonition-title,.rst-content code.download .rst-versions .rst-current-version span:first-child,.rst-content dl dt .rst-versions .rst-current-version .headerlink,.rst-content h1 .rst-versions .rst-current-version .headerlink,.rst-content h2 .rst-versions .rst-current-version .headerlink,.rst-content h3 .rst-versions .rst-current-version .headerlink,.rst-content h4 .rst-versions .rst-current-version .headerlink,.rst-content h5 .rst-versions .rst-current-version .headerlink,.rst-content h6 .rst-versions .rst-current-version .headerlink,.rst-content p .rst-versions .rst-current-version .headerlink,.rst-content table>caption .rst-versions .rst-current-version .headerlink,.rst-content tt.download .rst-versions .rst-current-version span:first-child,.rst-versions .rst-current-version .fa,.rst-versions .rst-current-version .icon,.rst-versions .rst-current-version .rst-content .admonition-title,.rst-versions .rst-current-version .rst-content .code-block-caption .headerlink,.rst-versions .rst-current-version .rst-content .eqno .headerlink,.rst-versions .rst-current-version .rst-content code.download span:first-child,.rst-versions .rst-current-version .rst-content dl dt .headerlink,.rst-versions .rst-current-version .rst-content h1 .headerlink,.rst-versions .rst-current-version .rst-content h2 .headerlink,.rst-versions .rst-current-version .rst-content h3 .headerlink,.rst-versions .rst-current-version .rst-content h4 .headerlink,.rst-versions .rst-current-version .rst-content h5 .headerlink,.rst-versions .rst-current-version .rst-content h6 .headerlink,.rst-versions .rst-current-version .rst-content p .headerlink,.rst-versions .rst-current-version .rst-content table>caption .headerlink,.rst-versions .rst-current-version .rst-content tt.download span:first-child,.rst-versions .rst-current-version .wy-menu-vertical li button.toctree-expand,.wy-menu-vertical li .rst-versions .rst-current-version button.toctree-expand{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}.rst-content .toctree-wrapper>p.caption,.rst-content h1,.rst-content h2,.rst-content h3,.rst-content h4,.rst-content h5,.rst-content h6{margin-bottom:24px}.rst-content img{max-width:100%;height:auto}.rst-content div.figure,.rst-content figure{margin-bottom:24px}.rst-content div.figure .caption-text,.rst-content figure .caption-text{font-style:italic}.rst-content div.figure p:last-child.caption,.rst-content figure p:last-child.caption{margin-bottom:0}.rst-content div.figure.align-center,.rst-content figure.align-center{text-align:center}.rst-content .section>a>img,.rst-content .section>img,.rst-content section>a>img,.rst-content section>img{margin-bottom:24px}.rst-content abbr[title]{text-decoration:none}.rst-content.style-external-links a.reference.external:after{font-family:FontAwesome;content:"\f08e";color:#b3b3b3;vertical-align:super;font-size:60%;margin:0 .2em}.rst-content blockquote{margin-left:24px;line-height:24px;margin-bottom:24px}.rst-content pre.literal-block{white-space:pre;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;display:block;overflow:auto}.rst-content div[class^=highlight],.rst-content pre.literal-block{border:1px solid #e1e4e5;overflow-x:auto;margin:1px 0 24px}.rst-content div[class^=highlight] div[class^=highlight],.rst-content pre.literal-block div[class^=highlight]{padding:0;border:none;margin:0}.rst-content div[class^=highlight] td.code{width:100%}.rst-content .linenodiv pre{border-right:1px solid #e6e9ea;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;user-select:none;pointer-events:none}.rst-content div[class^=highlight] pre{white-space:pre;margin:0;padding:12px;display:block;overflow:auto}.rst-content div[class^=highlight] pre .hll{display:block;margin:0 -12px;padding:0 12px}.rst-content .linenodiv pre,.rst-content div[class^=highlight] pre,.rst-content pre.literal-block{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:12px;line-height:1.4}.rst-content div.highlight .gp,.rst-content div.highlight span.linenos{user-select:none;pointer-events:none}.rst-content div.highlight span.linenos{display:inline-block;padding-left:0;padding-right:12px;margin-right:12px;border-right:1px solid #e6e9ea}.rst-content .code-block-caption{font-style:italic;font-size:85%;line-height:1;padding:1em 0;text-align:center}@media print{.rst-content .codeblock,.rst-content div[class^=highlight],.rst-content div[class^=highlight] pre{white-space:pre-wrap}}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning{clear:both}.rst-content .admonition-todo .last,.rst-content .admonition-todo>:last-child,.rst-content .admonition .last,.rst-content .admonition>:last-child,.rst-content .attention .last,.rst-content .attention>:last-child,.rst-content .caution .last,.rst-content .caution>:last-child,.rst-content .danger .last,.rst-content .danger>:last-child,.rst-content .error .last,.rst-content .error>:last-child,.rst-content .hint .last,.rst-content .hint>:last-child,.rst-content .important .last,.rst-content .important>:last-child,.rst-content .note .last,.rst-content .note>:last-child,.rst-content .seealso .last,.rst-content .seealso>:last-child,.rst-content .tip .last,.rst-content .tip>:last-child,.rst-content .warning .last,.rst-content .warning>:last-child{margin-bottom:0}.rst-content .admonition-title:before{margin-right:4px}.rst-content .admonition table{border-color:rgba(0,0,0,.1)}.rst-content .admonition table td,.rst-content .admonition table th{background:transparent!important;border-color:rgba(0,0,0,.1)!important}.rst-content .section ol.loweralpha,.rst-content .section ol.loweralpha>li,.rst-content .toctree-wrapper ol.loweralpha,.rst-content .toctree-wrapper ol.loweralpha>li,.rst-content section ol.loweralpha,.rst-content section ol.loweralpha>li{list-style:lower-alpha}.rst-content .section ol.upperalpha,.rst-content .section ol.upperalpha>li,.rst-content .toctree-wrapper ol.upperalpha,.rst-content .toctree-wrapper ol.upperalpha>li,.rst-content section ol.upperalpha,.rst-content section ol.upperalpha>li{list-style:upper-alpha}.rst-content .section ol li>*,.rst-content .section ul li>*,.rst-content .toctree-wrapper ol li>*,.rst-content .toctree-wrapper ul li>*,.rst-content section ol li>*,.rst-content section ul li>*{margin-top:12px;margin-bottom:12px}.rst-content .section ol li>:first-child,.rst-content .section ul li>:first-child,.rst-content .toctree-wrapper ol li>:first-child,.rst-content .toctree-wrapper ul li>:first-child,.rst-content section ol li>:first-child,.rst-content section ul li>:first-child{margin-top:0}.rst-content .section ol li>p,.rst-content .section ol li>p:last-child,.rst-content .section ul li>p,.rst-content .section ul li>p:last-child,.rst-content .toctree-wrapper ol li>p,.rst-content .toctree-wrapper ol li>p:last-child,.rst-content .toctree-wrapper ul li>p,.rst-content .toctree-wrapper ul li>p:last-child,.rst-content section ol li>p,.rst-content section ol li>p:last-child,.rst-content section ul li>p,.rst-content section ul li>p:last-child{margin-bottom:12px}.rst-content .section ol li>p:only-child,.rst-content .section ol li>p:only-child:last-child,.rst-content .section ul li>p:only-child,.rst-content .section ul li>p:only-child:last-child,.rst-content .toctree-wrapper ol li>p:only-child,.rst-content .toctree-wrapper ol li>p:only-child:last-child,.rst-content .toctree-wrapper ul li>p:only-child,.rst-content .toctree-wrapper ul li>p:only-child:last-child,.rst-content section ol li>p:only-child,.rst-content section ol li>p:only-child:last-child,.rst-content section ul li>p:only-child,.rst-content section ul li>p:only-child:last-child{margin-bottom:0}.rst-content .section ol li>ol,.rst-content .section ol li>ul,.rst-content .section ul li>ol,.rst-content .section ul li>ul,.rst-content .toctree-wrapper ol li>ol,.rst-content .toctree-wrapper ol li>ul,.rst-content .toctree-wrapper ul li>ol,.rst-content .toctree-wrapper ul li>ul,.rst-content section ol li>ol,.rst-content section ol li>ul,.rst-content section ul li>ol,.rst-content section ul li>ul{margin-bottom:12px}.rst-content .section ol.simple li>*,.rst-content .section ol.simple li ol,.rst-content .section ol.simple li ul,.rst-content .section ul.simple li>*,.rst-content .section ul.simple li ol,.rst-content .section ul.simple li ul,.rst-content .toctree-wrapper ol.simple li>*,.rst-content .toctree-wrapper ol.simple li ol,.rst-content .toctree-wrapper ol.simple li ul,.rst-content .toctree-wrapper ul.simple li>*,.rst-content .toctree-wrapper ul.simple li ol,.rst-content .toctree-wrapper ul.simple li ul,.rst-content section ol.simple li>*,.rst-content section ol.simple li ol,.rst-content section ol.simple li ul,.rst-content section ul.simple li>*,.rst-content section ul.simple li ol,.rst-content section ul.simple li ul{margin-top:0;margin-bottom:0}.rst-content .line-block{margin-left:0;margin-bottom:24px;line-height:24px}.rst-content .line-block .line-block{margin-left:24px;margin-bottom:0}.rst-content .topic-title{font-weight:700;margin-bottom:12px}.rst-content .toc-backref{color:#404040}.rst-content .align-right{float:right;margin:0 0 24px 24px}.rst-content .align-left{float:left;margin:0 24px 24px 0}.rst-content .align-center{margin:auto}.rst-content .align-center:not(table){display:block}.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink{opacity:0;font-size:14px;font-family:FontAwesome;margin-left:.5em}.rst-content .code-block-caption .headerlink:focus,.rst-content .code-block-caption:hover .headerlink,.rst-content .eqno .headerlink:focus,.rst-content .eqno:hover .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink:focus,.rst-content .toctree-wrapper>p.caption:hover .headerlink,.rst-content dl dt .headerlink:focus,.rst-content dl dt:hover .headerlink,.rst-content h1 .headerlink:focus,.rst-content h1:hover .headerlink,.rst-content h2 .headerlink:focus,.rst-content h2:hover .headerlink,.rst-content h3 .headerlink:focus,.rst-content h3:hover .headerlink,.rst-content h4 .headerlink:focus,.rst-content h4:hover .headerlink,.rst-content h5 .headerlink:focus,.rst-content h5:hover .headerlink,.rst-content h6 .headerlink:focus,.rst-content h6:hover .headerlink,.rst-content p.caption .headerlink:focus,.rst-content p.caption:hover .headerlink,.rst-content p .headerlink:focus,.rst-content p:hover .headerlink,.rst-content table>caption .headerlink:focus,.rst-content table>caption:hover .headerlink{opacity:1}.rst-content p a{overflow-wrap:anywhere}.rst-content .wy-table td p,.rst-content .wy-table td ul,.rst-content .wy-table th p,.rst-content .wy-table th ul,.rst-content table.docutils td p,.rst-content table.docutils td ul,.rst-content table.docutils th p,.rst-content table.docutils th ul,.rst-content table.field-list td p,.rst-content table.field-list td ul,.rst-content table.field-list th p,.rst-content table.field-list th ul{font-size:inherit}.rst-content .btn:focus{outline:2px solid}.rst-content table>caption .headerlink:after{font-size:12px}.rst-content .centered{text-align:center}.rst-content .sidebar{float:right;width:40%;display:block;margin:0 0 24px 24px;padding:24px;background:#f3f6f6;border:1px solid #e1e4e5}.rst-content .sidebar dl,.rst-content .sidebar p,.rst-content .sidebar ul{font-size:90%}.rst-content .sidebar .last,.rst-content .sidebar>:last-child{margin-bottom:0}.rst-content .sidebar .sidebar-title{display:block;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif;font-weight:700;background:#e1e4e5;padding:6px 12px;margin:-24px -24px 24px;font-size:100%}.rst-content .highlighted{background:#f1c40f;box-shadow:0 0 0 2px #f1c40f;display:inline;font-weight:700}.rst-content .citation-reference,.rst-content .footnote-reference{vertical-align:baseline;position:relative;top:-.4em;line-height:0;font-size:90%}.rst-content .citation-reference>span.fn-bracket,.rst-content .footnote-reference>span.fn-bracket{display:none}.rst-content .hlist{width:100%}.rst-content dl dt span.classifier:before{content:" : "}.rst-content dl dt span.classifier-delimiter{display:none!important}html.writer-html4 .rst-content table.docutils.citation,html.writer-html4 .rst-content table.docutils.footnote{background:none;border:none}html.writer-html4 .rst-content table.docutils.citation td,html.writer-html4 .rst-content table.docutils.citation tr,html.writer-html4 .rst-content table.docutils.footnote td,html.writer-html4 .rst-content table.docutils.footnote tr{border:none;background-color:transparent!important;white-space:normal}html.writer-html4 .rst-content table.docutils.citation td.label,html.writer-html4 .rst-content table.docutils.footnote td.label{padding-left:0;padding-right:0;vertical-align:top}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{display:grid;grid-template-columns:auto minmax(80%,95%)}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{display:inline-grid;grid-template-columns:max-content auto}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{display:grid;grid-template-columns:auto auto minmax(.65rem,auto) minmax(40%,95%)}html.writer-html5 .rst-content aside.citation>span.label,html.writer-html5 .rst-content aside.footnote>span.label,html.writer-html5 .rst-content div.citation>span.label{grid-column-start:1;grid-column-end:2}html.writer-html5 .rst-content aside.citation>span.backrefs,html.writer-html5 .rst-content aside.footnote>span.backrefs,html.writer-html5 .rst-content div.citation>span.backrefs{grid-column-start:2;grid-column-end:3;grid-row-start:1;grid-row-end:3}html.writer-html5 .rst-content aside.citation>p,html.writer-html5 .rst-content aside.footnote>p,html.writer-html5 .rst-content div.citation>p{grid-column-start:4;grid-column-end:5}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{margin-bottom:24px}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{padding-left:1rem}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dd,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dd,html.writer-html5 .rst-content dl.footnote>dt{margin-bottom:0}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{font-size:.9rem}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.footnote>dt{margin:0 .5rem .5rem 0;line-height:1.2rem;word-break:break-all;font-weight:400}html.writer-html5 .rst-content dl.citation>dt>span.brackets:before,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:before{content:"["}html.writer-html5 .rst-content dl.citation>dt>span.brackets:after,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:after{content:"]"}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a{word-break:keep-all}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a:not(:first-child):before,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.footnote>dd{margin:0 0 .5rem;line-height:1.2rem}html.writer-html5 .rst-content dl.citation>dd p,html.writer-html5 .rst-content dl.footnote>dd p{font-size:.9rem}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{padding-left:1rem;padding-right:1rem;font-size:.9rem;line-height:1.2rem}html.writer-html5 .rst-content aside.citation p,html.writer-html5 .rst-content aside.footnote p,html.writer-html5 .rst-content div.citation p{font-size:.9rem;line-height:1.2rem;margin-bottom:12px}html.writer-html5 .rst-content aside.citation span.backrefs,html.writer-html5 .rst-content aside.footnote span.backrefs,html.writer-html5 .rst-content div.citation span.backrefs{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content aside.citation span.backrefs>a,html.writer-html5 .rst-content aside.footnote span.backrefs>a,html.writer-html5 .rst-content div.citation span.backrefs>a{word-break:keep-all}html.writer-html5 .rst-content aside.citation span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content aside.footnote span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content div.citation span.backrefs>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content aside.citation span.label,html.writer-html5 .rst-content aside.footnote span.label,html.writer-html5 .rst-content div.citation span.label{line-height:1.2rem}html.writer-html5 .rst-content aside.citation-list,html.writer-html5 .rst-content aside.footnote-list,html.writer-html5 .rst-content div.citation-list{margin-bottom:24px}html.writer-html5 .rst-content dl.option-list kbd{font-size:.9rem}.rst-content table.docutils.footnote,html.writer-html4 .rst-content table.docutils.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content aside.footnote-list aside.footnote,html.writer-html5 .rst-content div.citation-list>div.citation,html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{color:grey}.rst-content table.docutils.footnote code,.rst-content table.docutils.footnote tt,html.writer-html4 .rst-content table.docutils.citation code,html.writer-html4 .rst-content table.docutils.citation tt,html.writer-html5 .rst-content aside.footnote-list aside.footnote code,html.writer-html5 .rst-content aside.footnote-list aside.footnote tt,html.writer-html5 .rst-content aside.footnote code,html.writer-html5 .rst-content aside.footnote tt,html.writer-html5 .rst-content div.citation-list>div.citation code,html.writer-html5 .rst-content div.citation-list>div.citation tt,html.writer-html5 .rst-content dl.citation code,html.writer-html5 .rst-content dl.citation tt,html.writer-html5 .rst-content dl.footnote code,html.writer-html5 .rst-content dl.footnote tt{color:#555}.rst-content .wy-table-responsive.citation,.rst-content .wy-table-responsive.footnote{margin-bottom:0}.rst-content .wy-table-responsive.citation+:not(.citation),.rst-content .wy-table-responsive.footnote+:not(.footnote){margin-top:24px}.rst-content .wy-table-responsive.citation:last-child,.rst-content .wy-table-responsive.footnote:last-child{margin-bottom:24px}.rst-content table.docutils th{border-color:#e1e4e5}html.writer-html5 .rst-content table.docutils th{border:1px solid #e1e4e5}html.writer-html5 .rst-content table.docutils td>p,html.writer-html5 .rst-content table.docutils th>p{line-height:1rem;margin-bottom:0;font-size:.9rem}.rst-content table.docutils td .last,.rst-content table.docutils td .last>:last-child{margin-bottom:0}.rst-content table.field-list,.rst-content table.field-list td{border:none}.rst-content table.field-list td p{line-height:inherit}.rst-content table.field-list td>strong{display:inline-block}.rst-content table.field-list .field-name{padding-right:10px;text-align:left;white-space:nowrap}.rst-content table.field-list .field-body{text-align:left}.rst-content code,.rst-content tt{color:#000;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;padding:2px 5px}.rst-content code big,.rst-content code em,.rst-content tt big,.rst-content tt em{font-size:100%!important;line-height:normal}.rst-content code.literal,.rst-content tt.literal{color:#e74c3c;white-space:normal}.rst-content code.xref,.rst-content tt.xref,a .rst-content code,a .rst-content tt{font-weight:700;color:#404040;overflow-wrap:normal}.rst-content kbd,.rst-content pre,.rst-content samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace}.rst-content a code,.rst-content a tt{color:#2980b9}.rst-content dl{margin-bottom:24px}.rst-content dl dt{font-weight:700;margin-bottom:12px}.rst-content dl ol,.rst-content dl p,.rst-content dl table,.rst-content dl ul{margin-bottom:12px}.rst-content dl dd{margin:0 0 12px 24px;line-height:24px}.rst-content dl dd>ol:last-child,.rst-content dl dd>p:last-child,.rst-content dl dd>table:last-child,.rst-content dl dd>ul:last-child{margin-bottom:0}html.writer-html4 .rst-content dl:not(.docutils),html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple){margin-bottom:24px}html.writer-html4 .rst-content dl:not(.docutils)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{display:table;margin:6px 0;font-size:90%;line-height:normal;background:#e7f2fa;color:#2980b9;border-top:3px solid #6ab0de;padding:6px;position:relative}html.writer-html4 .rst-content dl:not(.docutils)>dt:before,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:before{color:#6ab0de}html.writer-html4 .rst-content dl:not(.docutils)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{margin-bottom:6px;border:none;border-left:3px solid #ccc;background:#f0f0f0;color:#555}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils)>dt:first-child,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:first-child{margin-top:0}html.writer-html4 .rst-content dl:not(.docutils) code.descclassname,html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descclassname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{background-color:transparent;border:none;padding:0;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .optional,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .optional{display:inline-block;padding:0 4px;color:#000;font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .property,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .property{display:inline-block;padding-right:8px;max-width:100%}html.writer-html4 .rst-content dl:not(.docutils) .k,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .k{font-style:italic}html.writer-html4 .rst-content dl:not(.docutils) .descclassname,html.writer-html4 .rst-content dl:not(.docutils) .descname,html.writer-html4 .rst-content dl:not(.docutils) .sig-name,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .sig-name{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#000}.rst-content .viewcode-back,.rst-content .viewcode-link{display:inline-block;color:#27ae60;font-size:80%;padding-left:24px}.rst-content .viewcode-back{display:block;float:right}.rst-content p.rubric{margin-bottom:12px;font-weight:700}.rst-content code.download,.rst-content tt.download{background:inherit;padding:inherit;font-weight:400;font-family:inherit;font-size:inherit;color:inherit;border:inherit;white-space:inherit}.rst-content code.download span:first-child,.rst-content tt.download span:first-child{-webkit-font-smoothing:subpixel-antialiased}.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{margin-right:4px}.rst-content .guilabel,.rst-content .menuselection{font-size:80%;font-weight:700;border-radius:4px;padding:2.4px 6px;margin:auto 2px}.rst-content .guilabel,.rst-content .menuselection{border:1px solid #7fbbe3;background:#e7f2fa}.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>.kbd,.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>kbd{color:inherit;font-size:80%;background-color:#fff;border:1px solid #a6a6a6;border-radius:4px;box-shadow:0 2px grey;padding:2.4px 6px;margin:auto 0}.rst-content .versionmodified{font-style:italic}@media screen and (max-width:480px){.rst-content .sidebar{width:100%}}span[id*=MathJax-Span]{color:#404040}.math{text-align:center}@font-face{font-family:Lato;src:url(fonts/lato-normal.woff2?bd03a2cc277bbbc338d464e679fe9942) format("woff2"),url(fonts/lato-normal.woff?27bd77b9162d388cb8d4c4217c7c5e2a) format("woff");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold.woff2?cccb897485813c7c256901dbca54ecf2) format("woff2"),url(fonts/lato-bold.woff?d878b6c29b10beca227e9eef4246111b) format("woff");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold-italic.woff2?0b6bb6725576b072c5d0b02ecdd1900d) format("woff2"),url(fonts/lato-bold-italic.woff?9c7e4e9eb485b4a121c760e61bc3707c) format("woff");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-normal-italic.woff2?4eb103b4d12be57cb1d040ed5e162e9d) format("woff2"),url(fonts/lato-normal-italic.woff?f28f2d6482446544ef1ea1ccc6dd5892) format("woff");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:400;src:url(fonts/Roboto-Slab-Regular.woff2?7abf5b8d04d26a2cafea937019bca958) format("woff2"),url(fonts/Roboto-Slab-Regular.woff?c1be9284088d487c5e3ff0a10a92e58c) format("woff");font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:700;src:url(fonts/Roboto-Slab-Bold.woff2?9984f4a9bda09be08e83f2506954adbe) format("woff2"),url(fonts/Roboto-Slab-Bold.woff?bed5564a116b05148e3b3bea6fb1162a) format("woff");font-display:block} \ No newline at end of file diff --git a/v4.0.3/_static/docs-versions-menu.js b/v4.0.3/_static/docs-versions-menu.js new file mode 100644 index 00000000..696095a6 --- /dev/null +++ b/v4.0.3/_static/docs-versions-menu.js @@ -0,0 +1,148 @@ +"use strict"; + +function getGhPagesCurrentFolder() { + // Extract version folder under the assumpgion that the URL is of the form + // https://.github.io///... + if (window.location.hostname.includes("github.io")){ + return window.location.pathname.split('/')[2]; + } +} + +function getRootUrl() { + // Return the "root" URL, i.e. everything before the current folder + // (getGhPagesCurrentFolder). On gh-pages, this includes the project name. + var root_url = window.location.origin; + if (window.location.hostname.includes("github.io")){ + root_url = root_url + '/' + window.location.pathname.split('/')[1]; + } + return root_url; +} + +function getGithubProjectUrl(){ + // Return the project url on Github, under the assumption that the current + // page is hosted on github-pages (https://.github.io//) + var root_url = getRootUrl(); + var match = root_url.match(/([\w\d-]+)\.github\.io\/([\w\d-]+)/) + if (match !== null){ + var username = match[1]; + var projectname = match[2]; + return "https://github.com/" + username + "/" + projectname; + } else { + return null + } +} + +function _addVersionsMenu(version_data) { + // The menu was reverse-engineered from the RTD websites, so it's very + // specific to the sphinx_rtd_theme + var folders = version_data["versions"]; + var root_url = getRootUrl(); + var current_url = document.URL; + var current_folder = getGhPagesCurrentFolder(); + if (current_folder === undefined) return; + var current_version = version_data["labels"][current_folder]; + var menu = document.createElement('div'); + menu.setAttribute('class', 'rst-versions'); + menu.setAttribute('data-toggle', 'rst-versions'); + menu.setAttribute('role', 'note'); + menu.setAttribute('aria-label', 'versions'); + var inner_html = + "" + + " Docs " + + "" + current_version + " " + + "" + + "" + + "
" + + "
" + + "
" + + "
Versions
"; + var i; + for (i in folders) { + var folder = folders[i]; + if (folder == current_folder){ + var inner_html = inner_html + "
" + current_version + "
"; + } else { + var inner_html = inner_html + "
" + version_data["labels"][folder] + "
"; + } + } + var downloads = version_data["downloads"][current_folder]; + if (downloads.length > 0){ + var inner_html = inner_html + + "
Downloads
"; + for (i in downloads) { + var download_label = downloads[i][0]; + var download_url = downloads[i][1]; + if (!(/^(https?|ftp):/.test(download_url))){ + if (!download_url.startsWith('/')){ + var download_url = '/' + download_url; + } + var download_url = root_url + download_url; + } + var inner_html = inner_html + "
" + + download_label + "
"; + } + } + var github_project_url = getGithubProjectUrl(); + if (github_project_url !== null && github_project_url.length > 0){ + var inner_html = inner_html + + "
On Github
" + + "
Project Home
" + + "
Issues
"; + } + var inner_html = inner_html + + "
" + + "
" + + "Generated by Docs Versions Menu" + + "" + + "
" + + "
"; + menu.innerHTML = inner_html; + var parent = document.body; + parent.insertBefore(menu, parent.lastChild); + + // Add a warning banner for dev/outdated versions + var warning; + var msg; + if (version_data["warnings"][current_folder].indexOf("outdated") >=0){ + warning = document.createElement('div'); + warning.setAttribute('class', 'admonition danger'); + msg = "This document is for an outdated version."; + } else if (version_data["warnings"][current_folder].indexOf("unreleased") >=0){ + warning = document.createElement('div'); + warning.setAttribute('class', 'admonition danger'); + msg = "This document is for an unreleased development version."; + } else if (version_data["warnings"][current_folder].indexOf("prereleased") >=0){ + warning = document.createElement('div'); + warning.setAttribute('class', 'admonition danger'); + msg = "This document is for a pre-release development version."; + } + if (warning !== undefined){ + if (version_data["latest"] !== null){ + msg = msg + " Documentation is available for the " + "latest public release." + } + warning.innerHTML = "

Note

" + + "

" + msg + "

"; + var parent = document.querySelector('div.body') + || document.querySelector('div.document') + || document.body; + parent.insertBefore(warning, parent.firstChild); + } + + +} + +function addVersionsMenu() { + // We assume that we can load versions.json from + // https://.github.io//versions.json + // That is, there's a path between the hostname and versions.json + var json_file = "/" + window.location.pathname.split("/")[1] + "/versions.json"; + $.getJSON(json_file, _addVersionsMenu); +} + +document.addEventListener('DOMContentLoaded', addVersionsMenu); \ No newline at end of file diff --git a/v4.0.3/_static/doctools.js b/v4.0.3/_static/doctools.js new file mode 100644 index 00000000..d06a71d7 --- /dev/null +++ b/v4.0.3/_static/doctools.js @@ -0,0 +1,156 @@ +/* + * doctools.js + * ~~~~~~~~~~~ + * + * Base JavaScript utilities for all Sphinx HTML documentation. + * + * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ +"use strict"; + +const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([ + "TEXTAREA", + "INPUT", + "SELECT", + "BUTTON", +]); + +const _ready = (callback) => { + if (document.readyState !== "loading") { + callback(); + } else { + document.addEventListener("DOMContentLoaded", callback); + } +}; + +/** + * Small JavaScript module for the documentation. + */ +const Documentation = { + init: () => { + Documentation.initDomainIndexTable(); + Documentation.initOnKeyListeners(); + }, + + /** + * i18n support + */ + TRANSLATIONS: {}, + PLURAL_EXPR: (n) => (n === 1 ? 0 : 1), + LOCALE: "unknown", + + // gettext and ngettext don't access this so that the functions + // can safely bound to a different name (_ = Documentation.gettext) + gettext: (string) => { + const translated = Documentation.TRANSLATIONS[string]; + switch (typeof translated) { + case "undefined": + return string; // no translation + case "string": + return translated; // translation exists + default: + return translated[0]; // (singular, plural) translation tuple exists + } + }, + + ngettext: (singular, plural, n) => { + const translated = Documentation.TRANSLATIONS[singular]; + if (typeof translated !== "undefined") + return translated[Documentation.PLURAL_EXPR(n)]; + return n === 1 ? singular : plural; + }, + + addTranslations: (catalog) => { + Object.assign(Documentation.TRANSLATIONS, catalog.messages); + Documentation.PLURAL_EXPR = new Function( + "n", + `return (${catalog.plural_expr})` + ); + Documentation.LOCALE = catalog.locale; + }, + + /** + * helper function to focus on search bar + */ + focusSearchBar: () => { + document.querySelectorAll("input[name=q]")[0]?.focus(); + }, + + /** + * Initialise the domain index toggle buttons + */ + initDomainIndexTable: () => { + const toggler = (el) => { + const idNumber = el.id.substr(7); + const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`); + if (el.src.substr(-9) === "minus.png") { + el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`; + toggledRows.forEach((el) => (el.style.display = "none")); + } else { + el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`; + toggledRows.forEach((el) => (el.style.display = "")); + } + }; + + const togglerElements = document.querySelectorAll("img.toggler"); + togglerElements.forEach((el) => + el.addEventListener("click", (event) => toggler(event.currentTarget)) + ); + togglerElements.forEach((el) => (el.style.display = "")); + if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler); + }, + + initOnKeyListeners: () => { + // only install a listener if it is really needed + if ( + !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS && + !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS + ) + return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.altKey || event.ctrlKey || event.metaKey) return; + + if (!event.shiftKey) { + switch (event.key) { + case "ArrowLeft": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const prevLink = document.querySelector('link[rel="prev"]'); + if (prevLink && prevLink.href) { + window.location.href = prevLink.href; + event.preventDefault(); + } + break; + case "ArrowRight": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const nextLink = document.querySelector('link[rel="next"]'); + if (nextLink && nextLink.href) { + window.location.href = nextLink.href; + event.preventDefault(); + } + break; + } + } + + // some keyboard layouts may need Shift to get / + switch (event.key) { + case "/": + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break; + Documentation.focusSearchBar(); + event.preventDefault(); + } + }); + }, +}; + +// quick alias for translations +const _ = Documentation.gettext; + +_ready(Documentation.init); diff --git a/v4.0.3/_static/documentation_options.js b/v4.0.3/_static/documentation_options.js new file mode 100644 index 00000000..7e4c114f --- /dev/null +++ b/v4.0.3/_static/documentation_options.js @@ -0,0 +1,13 @@ +const DOCUMENTATION_OPTIONS = { + VERSION: '', + LANGUAGE: 'en', + COLLAPSE_INDEX: false, + BUILDER: 'html', + FILE_SUFFIX: '.html', + LINK_SUFFIX: '.html', + HAS_SOURCE: true, + SOURCELINK_SUFFIX: '.txt', + NAVIGATION_WITH_KEYS: false, + SHOW_SEARCH_SUMMARY: true, + ENABLE_SEARCH_SHORTCUTS: true, +}; \ No newline at end of file diff --git a/v4.0.3/_static/file.png b/v4.0.3/_static/file.png new file mode 100644 index 00000000..a858a410 Binary files /dev/null and b/v4.0.3/_static/file.png differ diff --git a/v4.0.3/_static/jquery.js b/v4.0.3/_static/jquery.js new file mode 100644 index 00000000..c4c6022f --- /dev/null +++ b/v4.0.3/_static/jquery.js @@ -0,0 +1,2 @@ +/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */ +!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="",y.option=!!ce.lastChild;var ge={thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n",""]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="
",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=y.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=y.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),y.elements=c+" "+a,j(b)}function f(a){var b=x[a[v]];return b||(b={},w++,a[v]=w,x[w]=b),b}function g(a,c,d){if(c||(c=b),q)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():u.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||t.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),q)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return y.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(y,b.frag)}function j(a){a||(a=b);var d=f(a);return!y.shivCSS||p||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),q||i(a,d),a}function k(a){for(var b,c=a.getElementsByTagName("*"),e=c.length,f=RegExp("^(?:"+d().join("|")+")$","i"),g=[];e--;)b=c[e],f.test(b.nodeName)&&g.push(b.applyElement(l(b)));return g}function l(a){for(var b,c=a.attributes,d=c.length,e=a.ownerDocument.createElement(A+":"+a.nodeName);d--;)b=c[d],b.specified&&e.setAttribute(b.nodeName,b.nodeValue);return e.style.cssText=a.style.cssText,e}function m(a){for(var b,c=a.split("{"),e=c.length,f=RegExp("(^|[\\s,>+~])("+d().join("|")+")(?=[[\\s,>+~#.:]|$)","gi"),g="$1"+A+"\\:$2";e--;)b=c[e]=c[e].split("}"),b[b.length-1]=b[b.length-1].replace(f,g),c[e]=b.join("}");return c.join("{")}function n(a){for(var b=a.length;b--;)a[b].removeNode()}function o(a){function b(){clearTimeout(g._removeSheetTimer),d&&d.removeNode(!0),d=null}var d,e,g=f(a),h=a.namespaces,i=a.parentWindow;return!B||a.printShived?a:("undefined"==typeof h[A]&&h.add(A),i.attachEvent("onbeforeprint",function(){b();for(var f,g,h,i=a.styleSheets,j=[],l=i.length,n=Array(l);l--;)n[l]=i[l];for(;h=n.pop();)if(!h.disabled&&z.test(h.media)){try{f=h.imports,g=f.length}catch(o){g=0}for(l=0;g>l;l++)n.push(f[l]);try{j.push(h.cssText)}catch(o){}}j=m(j.reverse().join("")),e=k(a),d=c(a,j)}),i.attachEvent("onafterprint",function(){n(e),clearTimeout(g._removeSheetTimer),g._removeSheetTimer=setTimeout(b,500)}),a.printShived=!0,a)}var p,q,r="3.7.3",s=a.html5||{},t=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,u=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,v="_html5shiv",w=0,x={};!function(){try{var a=b.createElement("a");a.innerHTML="",p="hidden"in a,q=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){p=!0,q=!0}}();var y={elements:s.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:r,shivCSS:s.shivCSS!==!1,supportsUnknownElements:q,shivMethods:s.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=y,j(b);var z=/^$|\b(?:all|print)\b/,A="html5shiv",B=!q&&function(){var c=b.documentElement;return!("undefined"==typeof b.namespaces||"undefined"==typeof b.parentWindow||"undefined"==typeof c.applyElement||"undefined"==typeof c.removeNode||"undefined"==typeof a.attachEvent)}();y.type+=" print",y.shivPrint=o,o(b),"object"==typeof module&&module.exports&&(module.exports=y)}("undefined"!=typeof window?window:this,document); \ No newline at end of file diff --git a/v4.0.3/_static/js/html5shiv.min.js b/v4.0.3/_static/js/html5shiv.min.js new file mode 100644 index 00000000..cd1c674f --- /dev/null +++ b/v4.0.3/_static/js/html5shiv.min.js @@ -0,0 +1,4 @@ +/** +* @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed +*/ +!function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=t.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=t.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),t.elements=c+" "+a,j(b)}function f(a){var b=s[a[q]];return b||(b={},r++,a[q]=r,s[r]=b),b}function g(a,c,d){if(c||(c=b),l)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():p.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||o.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),l)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return t.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(t,b.frag)}function j(a){a||(a=b);var d=f(a);return!t.shivCSS||k||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),l||i(a,d),a}var k,l,m="3.7.3-pre",n=a.html5||{},o=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,p=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,q="_html5shiv",r=0,s={};!function(){try{var a=b.createElement("a");a.innerHTML="",k="hidden"in a,l=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){k=!0,l=!0}}();var t={elements:n.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:m,shivCSS:n.shivCSS!==!1,supportsUnknownElements:l,shivMethods:n.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=t,j(b),"object"==typeof module&&module.exports&&(module.exports=t)}("undefined"!=typeof window?window:this,document); \ No newline at end of file diff --git a/v4.0.3/_static/js/theme.js b/v4.0.3/_static/js/theme.js new file mode 100644 index 00000000..1fddb6ee --- /dev/null +++ b/v4.0.3/_static/js/theme.js @@ -0,0 +1 @@ +!function(n){var e={};function t(i){if(e[i])return e[i].exports;var o=e[i]={i:i,l:!1,exports:{}};return n[i].call(o.exports,o,o.exports,t),o.l=!0,o.exports}t.m=n,t.c=e,t.d=function(n,e,i){t.o(n,e)||Object.defineProperty(n,e,{enumerable:!0,get:i})},t.r=function(n){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(n,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(n,"__esModule",{value:!0})},t.t=function(n,e){if(1&e&&(n=t(n)),8&e)return n;if(4&e&&"object"==typeof n&&n&&n.__esModule)return n;var i=Object.create(null);if(t.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:n}),2&e&&"string"!=typeof n)for(var o in n)t.d(i,o,function(e){return n[e]}.bind(null,o));return i},t.n=function(n){var e=n&&n.__esModule?function(){return n.default}:function(){return n};return t.d(e,"a",e),e},t.o=function(n,e){return Object.prototype.hasOwnProperty.call(n,e)},t.p="",t(t.s=0)}([function(n,e,t){t(1),n.exports=t(3)},function(n,e,t){(function(){var e="undefined"!=typeof window?window.jQuery:t(2);n.exports.ThemeNav={navBar:null,win:null,winScroll:!1,winResize:!1,linkScroll:!1,winPosition:0,winHeight:null,docHeight:null,isRunning:!1,enable:function(n){var t=this;void 0===n&&(n=!0),t.isRunning||(t.isRunning=!0,e((function(e){t.init(e),t.reset(),t.win.on("hashchange",t.reset),n&&t.win.on("scroll",(function(){t.linkScroll||t.winScroll||(t.winScroll=!0,requestAnimationFrame((function(){t.onScroll()})))})),t.win.on("resize",(function(){t.winResize||(t.winResize=!0,requestAnimationFrame((function(){t.onResize()})))})),t.onResize()})))},enableSticky:function(){this.enable(!0)},init:function(n){n(document);var e=this;this.navBar=n("div.wy-side-scroll:first"),this.win=n(window),n(document).on("click","[data-toggle='wy-nav-top']",(function(){n("[data-toggle='wy-nav-shift']").toggleClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift")})).on("click",".wy-menu-vertical .current ul li a",(function(){var t=n(this);n("[data-toggle='wy-nav-shift']").removeClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift"),e.toggleCurrent(t),e.hashChange()})).on("click","[data-toggle='rst-current-version']",(function(){n("[data-toggle='rst-versions']").toggleClass("shift-up")})),n("table.docutils:not(.field-list,.footnote,.citation)").wrap("
"),n("table.docutils.footnote").wrap("
"),n("table.docutils.citation").wrap("
"),n(".wy-menu-vertical ul").not(".simple").siblings("a").each((function(){var t=n(this);expand=n(''),expand.on("click",(function(n){return e.toggleCurrent(t),n.stopPropagation(),!1})),t.prepend(expand)}))},reset:function(){var n=encodeURI(window.location.hash)||"#";try{var e=$(".wy-menu-vertical"),t=e.find('[href="'+n+'"]');if(0===t.length){var i=$('.document [id="'+n.substring(1)+'"]').closest("div.section");0===(t=e.find('[href="#'+i.attr("id")+'"]')).length&&(t=e.find('[href="#"]'))}if(t.length>0){$(".wy-menu-vertical .current").removeClass("current").attr("aria-expanded","false"),t.addClass("current").attr("aria-expanded","true"),t.closest("li.toctree-l1").parent().addClass("current").attr("aria-expanded","true");for(let n=1;n<=10;n++)t.closest("li.toctree-l"+n).addClass("current").attr("aria-expanded","true");t[0].scrollIntoView()}}catch(n){console.log("Error expanding nav for anchor",n)}},onScroll:function(){this.winScroll=!1;var n=this.win.scrollTop(),e=n+this.winHeight,t=this.navBar.scrollTop()+(n-this.winPosition);n<0||e>this.docHeight||(this.navBar.scrollTop(t),this.winPosition=n)},onResize:function(){this.winResize=!1,this.winHeight=this.win.height(),this.docHeight=$(document).height()},hashChange:function(){this.linkScroll=!0,this.win.one("hashchange",(function(){this.linkScroll=!1}))},toggleCurrent:function(n){var e=n.closest("li");e.siblings("li.current").removeClass("current").attr("aria-expanded","false"),e.siblings().find("li.current").removeClass("current").attr("aria-expanded","false");var t=e.find("> ul li");t.length&&(t.removeClass("current").attr("aria-expanded","false"),e.toggleClass("current").attr("aria-expanded",(function(n,e){return"true"==e?"false":"true"})))}},"undefined"!=typeof window&&(window.SphinxRtdTheme={Navigation:n.exports.ThemeNav,StickyNav:n.exports.ThemeNav}),function(){for(var n=0,e=["ms","moz","webkit","o"],t=0;t0 + var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1 + var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1 + var s_v = "^(" + C + ")?" + v; // vowel in stem + + this.stemWord = function (w) { + var stem; + var suffix; + var firstch; + var origword = w; + + if (w.length < 3) + return w; + + var re; + var re2; + var re3; + var re4; + + firstch = w.substr(0,1); + if (firstch == "y") + w = firstch.toUpperCase() + w.substr(1); + + // Step 1a + re = /^(.+?)(ss|i)es$/; + re2 = /^(.+?)([^s])s$/; + + if (re.test(w)) + w = w.replace(re,"$1$2"); + else if (re2.test(w)) + w = w.replace(re2,"$1$2"); + + // Step 1b + re = /^(.+?)eed$/; + re2 = /^(.+?)(ed|ing)$/; + if (re.test(w)) { + var fp = re.exec(w); + re = new RegExp(mgr0); + if (re.test(fp[1])) { + re = /.$/; + w = w.replace(re,""); + } + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1]; + re2 = new RegExp(s_v); + if (re2.test(stem)) { + w = stem; + re2 = /(at|bl|iz)$/; + re3 = new RegExp("([^aeiouylsz])\\1$"); + re4 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re2.test(w)) + w = w + "e"; + else if (re3.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + else if (re4.test(w)) + w = w + "e"; + } + } + + // Step 1c + re = /^(.+?)y$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(s_v); + if (re.test(stem)) + w = stem + "i"; + } + + // Step 2 + re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step2list[suffix]; + } + + // Step 3 + re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step3list[suffix]; + } + + // Step 4 + re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/; + re2 = /^(.+?)(s|t)(ion)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + if (re.test(stem)) + w = stem; + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1] + fp[2]; + re2 = new RegExp(mgr1); + if (re2.test(stem)) + w = stem; + } + + // Step 5 + re = /^(.+?)e$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + re2 = new RegExp(meq1); + re3 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re.test(stem) || (re2.test(stem) && !(re3.test(stem)))) + w = stem; + } + re = /ll$/; + re2 = new RegExp(mgr1); + if (re.test(w) && re2.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + + // and turn initial Y back to y + if (firstch == "y") + w = firstch.toLowerCase() + w.substr(1); + return w; + } +} + diff --git a/v4.0.3/_static/minus.png b/v4.0.3/_static/minus.png new file mode 100644 index 00000000..d96755fd Binary files /dev/null and b/v4.0.3/_static/minus.png differ diff --git a/v4.0.3/_static/plus.png b/v4.0.3/_static/plus.png new file mode 100644 index 00000000..7107cec9 Binary files /dev/null and b/v4.0.3/_static/plus.png differ diff --git a/v4.0.3/_static/pygments.css b/v4.0.3/_static/pygments.css new file mode 100644 index 00000000..84ab3030 --- /dev/null +++ b/v4.0.3/_static/pygments.css @@ -0,0 +1,75 @@ +pre { line-height: 125%; } +td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +.highlight .hll { background-color: #ffffcc } +.highlight { background: #f8f8f8; } +.highlight .c { color: #3D7B7B; font-style: italic } /* Comment */ +.highlight .err { border: 1px solid #FF0000 } /* Error */ +.highlight .k { color: #008000; font-weight: bold } /* Keyword */ +.highlight .o { color: #666666 } /* Operator */ +.highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */ +.highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */ +.highlight .cp { color: #9C6500 } /* Comment.Preproc */ +.highlight .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */ +.highlight .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */ +.highlight .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */ +.highlight .gd { color: #A00000 } /* Generic.Deleted */ +.highlight .ge { font-style: italic } /* Generic.Emph */ +.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */ +.highlight .gr { color: #E40000 } /* Generic.Error */ +.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */ +.highlight .gi { color: #008400 } /* Generic.Inserted */ +.highlight .go { color: #717171 } /* Generic.Output */ +.highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */ +.highlight .gs { font-weight: bold } /* Generic.Strong */ +.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */ +.highlight .gt { color: #0044DD } /* Generic.Traceback */ +.highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */ +.highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */ +.highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */ +.highlight .kp { color: #008000 } /* Keyword.Pseudo */ +.highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */ +.highlight .kt { color: #B00040 } /* Keyword.Type */ +.highlight .m { color: #666666 } /* Literal.Number */ +.highlight .s { color: #BA2121 } /* Literal.String */ +.highlight .na { color: #687822 } /* Name.Attribute */ +.highlight .nb { color: #008000 } /* Name.Builtin */ +.highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */ +.highlight .no { color: #880000 } /* Name.Constant */ +.highlight .nd { color: #AA22FF } /* Name.Decorator */ +.highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */ +.highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */ +.highlight .nf { color: #0000FF } /* Name.Function */ +.highlight .nl { color: #767600 } /* Name.Label */ +.highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */ +.highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */ +.highlight .nv { color: #19177C } /* Name.Variable */ +.highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */ +.highlight .w { color: #bbbbbb } /* Text.Whitespace */ +.highlight .mb { color: #666666 } /* Literal.Number.Bin */ +.highlight .mf { color: #666666 } /* Literal.Number.Float */ +.highlight .mh { color: #666666 } /* Literal.Number.Hex */ +.highlight .mi { color: #666666 } /* Literal.Number.Integer */ +.highlight .mo { color: #666666 } /* Literal.Number.Oct */ +.highlight .sa { color: #BA2121 } /* Literal.String.Affix */ +.highlight .sb { color: #BA2121 } /* Literal.String.Backtick */ +.highlight .sc { color: #BA2121 } /* Literal.String.Char */ +.highlight .dl { color: #BA2121 } /* Literal.String.Delimiter */ +.highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */ +.highlight .s2 { color: #BA2121 } /* Literal.String.Double */ +.highlight .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */ +.highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */ +.highlight .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */ +.highlight .sx { color: #008000 } /* Literal.String.Other */ +.highlight .sr { color: #A45A77 } /* Literal.String.Regex */ +.highlight .s1 { color: #BA2121 } /* Literal.String.Single */ +.highlight .ss { color: #19177C } /* Literal.String.Symbol */ +.highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */ +.highlight .fm { color: #0000FF } /* Name.Function.Magic */ +.highlight .vc { color: #19177C } /* Name.Variable.Class */ +.highlight .vg { color: #19177C } /* Name.Variable.Global */ +.highlight .vi { color: #19177C } /* Name.Variable.Instance */ +.highlight .vm { color: #19177C } /* Name.Variable.Magic */ +.highlight .il { color: #666666 } /* Literal.Number.Integer.Long */ \ No newline at end of file diff --git a/v4.0.3/_static/searchtools.js b/v4.0.3/_static/searchtools.js new file mode 100644 index 00000000..7918c3fa --- /dev/null +++ b/v4.0.3/_static/searchtools.js @@ -0,0 +1,574 @@ +/* + * searchtools.js + * ~~~~~~~~~~~~~~~~ + * + * Sphinx JavaScript utilities for the full-text search. + * + * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ +"use strict"; + +/** + * Simple result scoring code. + */ +if (typeof Scorer === "undefined") { + var Scorer = { + // Implement the following function to further tweak the score for each result + // The function takes a result array [docname, title, anchor, descr, score, filename] + // and returns the new score. + /* + score: result => { + const [docname, title, anchor, descr, score, filename] = result + return score + }, + */ + + // query matches the full name of an object + objNameMatch: 11, + // or matches in the last dotted part of the object name + objPartialMatch: 6, + // Additive scores depending on the priority of the object + objPrio: { + 0: 15, // used to be importantResults + 1: 5, // used to be objectResults + 2: -5, // used to be unimportantResults + }, + // Used when the priority is not in the mapping. + objPrioDefault: 0, + + // query found in title + title: 15, + partialTitle: 7, + // query found in terms + term: 5, + partialTerm: 2, + }; +} + +const _removeChildren = (element) => { + while (element && element.lastChild) element.removeChild(element.lastChild); +}; + +/** + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping + */ +const _escapeRegExp = (string) => + string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string + +const _displayItem = (item, searchTerms, highlightTerms) => { + const docBuilder = DOCUMENTATION_OPTIONS.BUILDER; + const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX; + const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX; + const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY; + const contentRoot = document.documentElement.dataset.content_root; + + const [docName, title, anchor, descr, score, _filename] = item; + + let listItem = document.createElement("li"); + let requestUrl; + let linkUrl; + if (docBuilder === "dirhtml") { + // dirhtml builder + let dirname = docName + "/"; + if (dirname.match(/\/index\/$/)) + dirname = dirname.substring(0, dirname.length - 6); + else if (dirname === "index/") dirname = ""; + requestUrl = contentRoot + dirname; + linkUrl = requestUrl; + } else { + // normal html builders + requestUrl = contentRoot + docName + docFileSuffix; + linkUrl = docName + docLinkSuffix; + } + let linkEl = listItem.appendChild(document.createElement("a")); + linkEl.href = linkUrl + anchor; + linkEl.dataset.score = score; + linkEl.innerHTML = title; + if (descr) { + listItem.appendChild(document.createElement("span")).innerHTML = + " (" + descr + ")"; + // highlight search terms in the description + if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js + highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted")); + } + else if (showSearchSummary) + fetch(requestUrl) + .then((responseData) => responseData.text()) + .then((data) => { + if (data) + listItem.appendChild( + Search.makeSearchSummary(data, searchTerms) + ); + // highlight search terms in the summary + if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js + highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted")); + }); + Search.output.appendChild(listItem); +}; +const _finishSearch = (resultCount) => { + Search.stopPulse(); + Search.title.innerText = _("Search Results"); + if (!resultCount) + Search.status.innerText = Documentation.gettext( + "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories." + ); + else + Search.status.innerText = _( + `Search finished, found ${resultCount} page(s) matching the search query.` + ); +}; +const _displayNextItem = ( + results, + resultCount, + searchTerms, + highlightTerms, +) => { + // results left, load the summary and display it + // this is intended to be dynamic (don't sub resultsCount) + if (results.length) { + _displayItem(results.pop(), searchTerms, highlightTerms); + setTimeout( + () => _displayNextItem(results, resultCount, searchTerms, highlightTerms), + 5 + ); + } + // search finished, update title and status message + else _finishSearch(resultCount); +}; + +/** + * Default splitQuery function. Can be overridden in ``sphinx.search`` with a + * custom function per language. + * + * The regular expression works by splitting the string on consecutive characters + * that are not Unicode letters, numbers, underscores, or emoji characters. + * This is the same as ``\W+`` in Python, preserving the surrogate pair area. + */ +if (typeof splitQuery === "undefined") { + var splitQuery = (query) => query + .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu) + .filter(term => term) // remove remaining empty strings +} + +/** + * Search Module + */ +const Search = { + _index: null, + _queued_query: null, + _pulse_status: -1, + + htmlToText: (htmlString) => { + const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html'); + htmlElement.querySelectorAll(".headerlink").forEach((el) => { el.remove() }); + const docContent = htmlElement.querySelector('[role="main"]'); + if (docContent !== undefined) return docContent.textContent; + console.warn( + "Content block not found. Sphinx search tries to obtain it via '[role=main]'. Could you check your theme or template." + ); + return ""; + }, + + init: () => { + const query = new URLSearchParams(window.location.search).get("q"); + document + .querySelectorAll('input[name="q"]') + .forEach((el) => (el.value = query)); + if (query) Search.performSearch(query); + }, + + loadIndex: (url) => + (document.body.appendChild(document.createElement("script")).src = url), + + setIndex: (index) => { + Search._index = index; + if (Search._queued_query !== null) { + const query = Search._queued_query; + Search._queued_query = null; + Search.query(query); + } + }, + + hasIndex: () => Search._index !== null, + + deferQuery: (query) => (Search._queued_query = query), + + stopPulse: () => (Search._pulse_status = -1), + + startPulse: () => { + if (Search._pulse_status >= 0) return; + + const pulse = () => { + Search._pulse_status = (Search._pulse_status + 1) % 4; + Search.dots.innerText = ".".repeat(Search._pulse_status); + if (Search._pulse_status >= 0) window.setTimeout(pulse, 500); + }; + pulse(); + }, + + /** + * perform a search for something (or wait until index is loaded) + */ + performSearch: (query) => { + // create the required interface elements + const searchText = document.createElement("h2"); + searchText.textContent = _("Searching"); + const searchSummary = document.createElement("p"); + searchSummary.classList.add("search-summary"); + searchSummary.innerText = ""; + const searchList = document.createElement("ul"); + searchList.classList.add("search"); + + const out = document.getElementById("search-results"); + Search.title = out.appendChild(searchText); + Search.dots = Search.title.appendChild(document.createElement("span")); + Search.status = out.appendChild(searchSummary); + Search.output = out.appendChild(searchList); + + const searchProgress = document.getElementById("search-progress"); + // Some themes don't use the search progress node + if (searchProgress) { + searchProgress.innerText = _("Preparing search..."); + } + Search.startPulse(); + + // index already loaded, the browser was quick! + if (Search.hasIndex()) Search.query(query); + else Search.deferQuery(query); + }, + + /** + * execute search (requires search index to be loaded) + */ + query: (query) => { + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const titles = Search._index.titles; + const allTitles = Search._index.alltitles; + const indexEntries = Search._index.indexentries; + + // stem the search terms and add them to the correct list + const stemmer = new Stemmer(); + const searchTerms = new Set(); + const excludedTerms = new Set(); + const highlightTerms = new Set(); + const objectTerms = new Set(splitQuery(query.toLowerCase().trim())); + splitQuery(query.trim()).forEach((queryTerm) => { + const queryTermLower = queryTerm.toLowerCase(); + + // maybe skip this "word" + // stopwords array is from language_data.js + if ( + stopwords.indexOf(queryTermLower) !== -1 || + queryTerm.match(/^\d+$/) + ) + return; + + // stem the word + let word = stemmer.stemWord(queryTermLower); + // select the correct list + if (word[0] === "-") excludedTerms.add(word.substr(1)); + else { + searchTerms.add(word); + highlightTerms.add(queryTermLower); + } + }); + + if (SPHINX_HIGHLIGHT_ENABLED) { // set in sphinx_highlight.js + localStorage.setItem("sphinx_highlight_terms", [...highlightTerms].join(" ")) + } + + // console.debug("SEARCH: searching for:"); + // console.info("required: ", [...searchTerms]); + // console.info("excluded: ", [...excludedTerms]); + + // array of [docname, title, anchor, descr, score, filename] + let results = []; + _removeChildren(document.getElementById("search-progress")); + + const queryLower = query.toLowerCase(); + for (const [title, foundTitles] of Object.entries(allTitles)) { + if (title.toLowerCase().includes(queryLower) && (queryLower.length >= title.length/2)) { + for (const [file, id] of foundTitles) { + let score = Math.round(100 * queryLower.length / title.length) + results.push([ + docNames[file], + titles[file] !== title ? `${titles[file]} > ${title}` : title, + id !== null ? "#" + id : "", + null, + score, + filenames[file], + ]); + } + } + } + + // search for explicit entries in index directives + for (const [entry, foundEntries] of Object.entries(indexEntries)) { + if (entry.includes(queryLower) && (queryLower.length >= entry.length/2)) { + for (const [file, id] of foundEntries) { + let score = Math.round(100 * queryLower.length / entry.length) + results.push([ + docNames[file], + titles[file], + id ? "#" + id : "", + null, + score, + filenames[file], + ]); + } + } + } + + // lookup as object + objectTerms.forEach((term) => + results.push(...Search.performObjectSearch(term, objectTerms)) + ); + + // lookup as search terms in fulltext + results.push(...Search.performTermsSearch(searchTerms, excludedTerms)); + + // let the scorer override scores with a custom scoring function + if (Scorer.score) results.forEach((item) => (item[4] = Scorer.score(item))); + + // now sort the results by score (in opposite order of appearance, since the + // display function below uses pop() to retrieve items) and then + // alphabetically + results.sort((a, b) => { + const leftScore = a[4]; + const rightScore = b[4]; + if (leftScore === rightScore) { + // same score: sort alphabetically + const leftTitle = a[1].toLowerCase(); + const rightTitle = b[1].toLowerCase(); + if (leftTitle === rightTitle) return 0; + return leftTitle > rightTitle ? -1 : 1; // inverted is intentional + } + return leftScore > rightScore ? 1 : -1; + }); + + // remove duplicate search results + // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept + let seen = new Set(); + results = results.reverse().reduce((acc, result) => { + let resultStr = result.slice(0, 4).concat([result[5]]).map(v => String(v)).join(','); + if (!seen.has(resultStr)) { + acc.push(result); + seen.add(resultStr); + } + return acc; + }, []); + + results = results.reverse(); + + // for debugging + //Search.lastresults = results.slice(); // a copy + // console.info("search results:", Search.lastresults); + + // print the results + _displayNextItem(results, results.length, searchTerms, highlightTerms); + }, + + /** + * search for object names + */ + performObjectSearch: (object, objectTerms) => { + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const objects = Search._index.objects; + const objNames = Search._index.objnames; + const titles = Search._index.titles; + + const results = []; + + const objectSearchCallback = (prefix, match) => { + const name = match[4] + const fullname = (prefix ? prefix + "." : "") + name; + const fullnameLower = fullname.toLowerCase(); + if (fullnameLower.indexOf(object) < 0) return; + + let score = 0; + const parts = fullnameLower.split("."); + + // check for different match types: exact matches of full name or + // "last name" (i.e. last dotted part) + if (fullnameLower === object || parts.slice(-1)[0] === object) + score += Scorer.objNameMatch; + else if (parts.slice(-1)[0].indexOf(object) > -1) + score += Scorer.objPartialMatch; // matches in last name + + const objName = objNames[match[1]][2]; + const title = titles[match[0]]; + + // If more than one term searched for, we require other words to be + // found in the name/title/description + const otherTerms = new Set(objectTerms); + otherTerms.delete(object); + if (otherTerms.size > 0) { + const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase(); + if ( + [...otherTerms].some((otherTerm) => haystack.indexOf(otherTerm) < 0) + ) + return; + } + + let anchor = match[3]; + if (anchor === "") anchor = fullname; + else if (anchor === "-") anchor = objNames[match[1]][1] + "-" + fullname; + + const descr = objName + _(", in ") + title; + + // add custom score for some objects according to scorer + if (Scorer.objPrio.hasOwnProperty(match[2])) + score += Scorer.objPrio[match[2]]; + else score += Scorer.objPrioDefault; + + results.push([ + docNames[match[0]], + fullname, + "#" + anchor, + descr, + score, + filenames[match[0]], + ]); + }; + Object.keys(objects).forEach((prefix) => + objects[prefix].forEach((array) => + objectSearchCallback(prefix, array) + ) + ); + return results; + }, + + /** + * search for full-text terms in the index + */ + performTermsSearch: (searchTerms, excludedTerms) => { + // prepare search + const terms = Search._index.terms; + const titleTerms = Search._index.titleterms; + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const titles = Search._index.titles; + + const scoreMap = new Map(); + const fileMap = new Map(); + + // perform the search on the required terms + searchTerms.forEach((word) => { + const files = []; + const arr = [ + { files: terms[word], score: Scorer.term }, + { files: titleTerms[word], score: Scorer.title }, + ]; + // add support for partial matches + if (word.length > 2) { + const escapedWord = _escapeRegExp(word); + Object.keys(terms).forEach((term) => { + if (term.match(escapedWord) && !terms[word]) + arr.push({ files: terms[term], score: Scorer.partialTerm }); + }); + Object.keys(titleTerms).forEach((term) => { + if (term.match(escapedWord) && !titleTerms[word]) + arr.push({ files: titleTerms[word], score: Scorer.partialTitle }); + }); + } + + // no match but word was a required one + if (arr.every((record) => record.files === undefined)) return; + + // found search word in contents + arr.forEach((record) => { + if (record.files === undefined) return; + + let recordFiles = record.files; + if (recordFiles.length === undefined) recordFiles = [recordFiles]; + files.push(...recordFiles); + + // set score for the word in each file + recordFiles.forEach((file) => { + if (!scoreMap.has(file)) scoreMap.set(file, {}); + scoreMap.get(file)[word] = record.score; + }); + }); + + // create the mapping + files.forEach((file) => { + if (fileMap.has(file) && fileMap.get(file).indexOf(word) === -1) + fileMap.get(file).push(word); + else fileMap.set(file, [word]); + }); + }); + + // now check if the files don't contain excluded terms + const results = []; + for (const [file, wordList] of fileMap) { + // check if all requirements are matched + + // as search terms with length < 3 are discarded + const filteredTermCount = [...searchTerms].filter( + (term) => term.length > 2 + ).length; + if ( + wordList.length !== searchTerms.size && + wordList.length !== filteredTermCount + ) + continue; + + // ensure that none of the excluded terms is in the search result + if ( + [...excludedTerms].some( + (term) => + terms[term] === file || + titleTerms[term] === file || + (terms[term] || []).includes(file) || + (titleTerms[term] || []).includes(file) + ) + ) + break; + + // select one (max) score for the file. + const score = Math.max(...wordList.map((w) => scoreMap.get(file)[w])); + // add result to the result list + results.push([ + docNames[file], + titles[file], + "", + null, + score, + filenames[file], + ]); + } + return results; + }, + + /** + * helper function to return a node containing the + * search summary for a given text. keywords is a list + * of stemmed words. + */ + makeSearchSummary: (htmlText, keywords) => { + const text = Search.htmlToText(htmlText); + if (text === "") return null; + + const textLower = text.toLowerCase(); + const actualStartPosition = [...keywords] + .map((k) => textLower.indexOf(k.toLowerCase())) + .filter((i) => i > -1) + .slice(-1)[0]; + const startWithContext = Math.max(actualStartPosition - 120, 0); + + const top = startWithContext === 0 ? "" : "..."; + const tail = startWithContext + 240 < text.length ? "..." : ""; + + let summary = document.createElement("p"); + summary.classList.add("context"); + summary.textContent = top + text.substr(startWithContext, 240).trim() + tail; + + return summary; + }, +}; + +_ready(Search.init); diff --git a/v4.0.3/_static/sphinx_highlight.js b/v4.0.3/_static/sphinx_highlight.js new file mode 100644 index 00000000..8a96c69a --- /dev/null +++ b/v4.0.3/_static/sphinx_highlight.js @@ -0,0 +1,154 @@ +/* Highlighting utilities for Sphinx HTML documentation. */ +"use strict"; + +const SPHINX_HIGHLIGHT_ENABLED = true + +/** + * highlight a given string on a node by wrapping it in + * span elements with the given class name. + */ +const _highlight = (node, addItems, text, className) => { + if (node.nodeType === Node.TEXT_NODE) { + const val = node.nodeValue; + const parent = node.parentNode; + const pos = val.toLowerCase().indexOf(text); + if ( + pos >= 0 && + !parent.classList.contains(className) && + !parent.classList.contains("nohighlight") + ) { + let span; + + const closestNode = parent.closest("body, svg, foreignObject"); + const isInSVG = closestNode && closestNode.matches("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.classList.add(className); + } + + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + const rest = document.createTextNode(val.substr(pos + text.length)); + parent.insertBefore( + span, + parent.insertBefore( + rest, + node.nextSibling + ) + ); + node.nodeValue = val.substr(0, pos); + /* There may be more occurrences of search term in this node. So call this + * function recursively on the remaining fragment. + */ + _highlight(rest, addItems, text, className); + + if (isInSVG) { + const rect = document.createElementNS( + "http://www.w3.org/2000/svg", + "rect" + ); + const bbox = parent.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute("class", className); + addItems.push({ parent: parent, target: rect }); + } + } + } else if (node.matches && !node.matches("button, select, textarea")) { + node.childNodes.forEach((el) => _highlight(el, addItems, text, className)); + } +}; +const _highlightText = (thisNode, text, className) => { + let addItems = []; + _highlight(thisNode, addItems, text, className); + addItems.forEach((obj) => + obj.parent.insertAdjacentElement("beforebegin", obj.target) + ); +}; + +/** + * Small JavaScript module for the documentation. + */ +const SphinxHighlight = { + + /** + * highlight the search words provided in localstorage in the text + */ + highlightSearchWords: () => { + if (!SPHINX_HIGHLIGHT_ENABLED) return; // bail if no highlight + + // get and clear terms from localstorage + const url = new URL(window.location); + const highlight = + localStorage.getItem("sphinx_highlight_terms") + || url.searchParams.get("highlight") + || ""; + localStorage.removeItem("sphinx_highlight_terms") + url.searchParams.delete("highlight"); + window.history.replaceState({}, "", url); + + // get individual terms from highlight string + const terms = highlight.toLowerCase().split(/\s+/).filter(x => x); + if (terms.length === 0) return; // nothing to do + + // There should never be more than one element matching "div.body" + const divBody = document.querySelectorAll("div.body"); + const body = divBody.length ? divBody[0] : document.querySelector("body"); + window.setTimeout(() => { + terms.forEach((term) => _highlightText(body, term, "highlighted")); + }, 10); + + const searchBox = document.getElementById("searchbox"); + if (searchBox === null) return; + searchBox.appendChild( + document + .createRange() + .createContextualFragment( + '

' + + '' + + _("Hide Search Matches") + + "

" + ) + ); + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords: () => { + document + .querySelectorAll("#searchbox .highlight-link") + .forEach((el) => el.remove()); + document + .querySelectorAll("span.highlighted") + .forEach((el) => el.classList.remove("highlighted")); + localStorage.removeItem("sphinx_highlight_terms") + }, + + initEscapeListener: () => { + // only install a listener if it is really needed + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return; + if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) { + SphinxHighlight.hideSearchWords(); + event.preventDefault(); + } + }); + }, +}; + +_ready(() => { + /* Do not call highlightSearchWords() when we are on the search page. + * It will highlight words from the *previous* search query. + */ + if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords(); + SphinxHighlight.initEscapeListener(); +}); diff --git a/v4.0.3/genindex.html b/v4.0.3/genindex.html new file mode 100644 index 00000000..0d0385ee --- /dev/null +++ b/v4.0.3/genindex.html @@ -0,0 +1,122 @@ + + + + + + Index — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Index
    • +
  • +
    • +
+
+
+
+
+ + +

Index

+ +
+ +
+ + +
+
+
+ +
+ +
+

© Copyright 2023, SLAC National Accelerator Laboratory.

+
+ + Built with Sphinx using a + theme + provided by Read the Docs. + + +
+
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/index.html b/v4.0.3/index.html new file mode 100644 index 00000000..4de5b65d --- /dev/null +++ b/v4.0.3/index.html @@ -0,0 +1,360 @@ + + + + + + + lcls-twincat-motion — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

lcls-twincat-motion

+
+

lcls-twincat-motion

+ +
+
+

Library

+ +
+
+

Indices and tables

+ +
+
+ + +
+
+
+ +
+ +
+

© Copyright 2023, SLAC National Accelerator Laboratory.

+
+ + Built with Sphinx using a + theme + provided by Read the Docs. + + +
+
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/lcls-twincat-motion_Library_epics.html b/v4.0.3/lcls-twincat-motion_Library_epics.html new file mode 100644 index 00000000..1839d832 --- /dev/null +++ b/v4.0.3/lcls-twincat-motion_Library_epics.html @@ -0,0 +1,130 @@ + + + + + + + Data Types — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Data Types

+
+
+

Database Records

+

No records defined.

+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/lcls-twincat-motion_Library_source.html b/v4.0.3/lcls-twincat-motion_Library_source.html new file mode 100644 index 00000000..81a779cc --- /dev/null +++ b/v4.0.3/lcls-twincat-motion_Library_source.html @@ -0,0 +1,17930 @@ + + + + + + + DUTs — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

DUTs

+
+

DUT_AxisStatus_v0_01

+
TYPE DUT_AxisStatus_v0_01 :
+STRUCT
+    bEnable: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+    nCommand: UINT;
+    nCmdData: UINT;
+    fVelocity: LREAL;
+    fPosition: LREAL;
+    fAcceleration: LREAL;
+    fDeceleration: LREAL;
+    bJogFwd: BOOL;
+    bJogBwd: BOOL;
+    bLimitFwd: BOOL;
+    bLimitBwd: BOOL;
+    fOverride: LREAL := 100;
+    bHomeSensor: BOOL;
+    bEnabled: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+    fActVelocity: LREAL;
+    fActPosition: LREAL;
+    fActDiff: LREAL;
+    bHomed:BOOL;
+    bBusy:BOOL;
+END_STRUCT
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

DUT_ErrorState

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE DUT_ErrorState :
+(
+    None,
+    Active,
+    Inactive,
+    Acknowledged
+);
+END_TYPE
+
+
+
+
+

DUT_MotionPneumaticActuator

+
{attribute 'obsolete' := 'DUT_MotionPneumaticActuator has been renamed to ST_MotionPneumaticActuator'}
+TYPE DUT_MotionPneumaticActuator : ST_MotionPneumaticActuator; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

DUT_MotionStage

+
{attribute 'obsolete' := 'DUT_MotionStage has been renamed to ST_MotionStage'}
+TYPE DUT_MotionStage : ST_MotionStage; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

DUT_PositionState

+
{attribute 'obsolete' := 'DUT_PositionState has been renamed to ST_PositionState'}
+TYPE DUT_PositionState : ST_PositionState; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

DUT_TerminalError

+
TYPE DUT_TerminalError :
+STRUCT
+    //Error system related
+    iTerminalID : INT;                                      //ID of the terminal
+    Error_ID : ULINT := 0;                          //ID for the Error entry
+    ErrorState : DUT_ErrorState;            //State of the error
+
+    //Error related
+    nDateTimeOn : ULINT;                            //Date and time when the error occured. Raw data
+    sDateTimeOn : STRING(24);                       //Date and time when the error occured. Readable format
+    nDateTimeOff : ULINT;                           //Date and time when the error disapeared. Raw data
+    sDateTimeOff : STRING(24);                      //Date and time when the error disapeared. Readable format
+    bWcState : BOOL;                                        //WcState variable of the terminal
+    uiInfoDataState : UINT;                         //InfoData.State variable of the terminal
+    sErrorMessage : STRING (128);           //Error message corresponding to WcState and InfoData.State
+    ErrorType : INT;                                        //Error types (priorities) need to be developed
+END_STRUCT
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

dutEL2521_Ctrl

+
TYPE dutEL2521_Ctrl :
+STRUCT
+    ///The control word (CW) is located in the output process image, and is transmitted from the controller to the terminal.
+    ///CW.0 FREQ_SEL 0bin / 1bin  Rapid change of the base frequency (only if the ramp function is inactive):
+    ///0bin = Base frequency 1 (object 8001:02)
+    ///1bin = Base frequency 2 (object 8001:03)
+    FREQ_SEL: BOOL;
+    ///CW.1 RAMP_DIS 1bin Operation of the ramp function is cancelled, in spite of object 8000:06 being active; if travel distance control is active, it is interrupted by this bit
+    RAMP_DIS: BOOL;
+    ///CW.2 GO_COUNTER 1bin  If travel distance control is active (object 8000:0A), then a pre-set counter value is approached when the bit is set
+    GO_COUNTER: BOOL;
+    ///CW.5 CNT_CLR 1bin The contents of the counter is cleared or set (object 8000:0B) by this bit.
+    ///Any overflow or underflow bits that might be set are also cleared by this bit.
+    ///The process can be edge triggered or level triggered (object 8000:05).
+    CNT_CLR: BOOL;
+END_STRUCT
+END_TYPE
+
+
+
+
+

dutEL2521_Status

+
TYPE dutEL2521_Status :
+STRUCT
+    ///The status word (SW) is located in the input process image, and is transmitted from the terminal to the controller.
+    ///SW.0 SEL_ACK/END_COUNTER 1bin  Confirms the change of base frequency. At activated travel distance control: target counter value reached
+    SEL_ACK: BOOL;
+    ///SW.1 RAMP_ACTIVE 1bin Ramp is currently being followed
+    RAMP_ACTIVE: BOOL;
+    ///SW.2 UNDERFLOW 1bin This bit is set if the 16-bit counter underflows (0 -> 65535). It is reset when the counter drops below two thirds of its measuring range (43690 -> 43689) or immediately an overflow occurs.
+    UNDERFLOW: BOOL;
+    ///SW.3 OVERFLOW 1bin This bit is set if the 16-bit counter overflows (65535 -> 0). It is reset when the counter exceeds one third of its measuring range (21845 -> 21846) or immediately an underflow occurs
+    OVERFLOW: BOOL;
+    ///SW.4 INPUT_T 1bin Status of INPUT_T
+    INPUT_T: BOOL;
+    ///SW.5 INPUT_Z 1bin Status of INPUT_Z
+    INPUT_Z: BOOL;
+    ///SW.6 ERROR 1bin General error bit, included with overflow/underflow
+    ERROR: BOOL;
+END_STRUCT
+END_TYPE
+
+
+
+
+

E_EpicsHomeCmd

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE E_EpicsHomeCmd :
+    // Defines the valid options for homing in FB_MotionStage
+(
+    LOW_LIMIT := 1, // Low limit switch
+    HIGH_LIMIT := 2, // High limit switch
+    HOME_VIA_LOW := 3, // Home switch via low switch
+    HOME_VIA_HIGH := 4, // Home switch via high switch
+    ABSOLUTE_SET := 15, // Set here to be fHomePosition
+    NONE := -1 // Do not home, ever
+);
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

E_EpicsInOut

+
{attribute 'qualified_only'}
+// Example EPICS states enum for use in all versions of the states FBs
+// Remove strict attribute for easier handling
+TYPE E_EpicsInOut :
+(
+    UNKNOWN := 0, // UNKNOWN must be in slot 0 or the FB breaks
+    OUT := 1, // OUT at slot 1 is a convention
+    IN := 2
+) UINT;
+END_TYPE
+
+
+
+
+

E_EpicsMotorCmd

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE E_EpicsMotorCmd :
+    // Defines valid EPICS commands for nCommand
+(
+    JOG := 0,
+    MOVE_VELOCITY := 1,
+    MOVE_RELATIVE := 2,
+    MOVE_ABSOLUTE := 3,
+    MOVE_MODULO := 4,
+    HOME := 10,
+    GEAR := 30
+);
+END_TYPE
+
+
+
+
+

E_MotionFFType

+
{attribute 'qualified_only'}
+TYPE E_MotionFFType :
+(
+    STOPPER_FAULT := 16#1000,
+    ZERO_RATE := 16#1001,
+    BPTM_TIMEOUT := 16#1002,
+    BPTM_ERROR := 16#1003,
+    MAINT_MODE := 16#1004,
+    NOT_A_STATE := 16#1005,
+    INVALID_GOAL := 16#1006,
+    TOO_MANY_TRIPS := 16#1007,
+    BP_MISMATCH := 16#1008,
+    INTERNAL_ERROR := 16#1009,
+    PNEUMATIC_MOVE := 16#1010,
+    MOT_GENERIC := 16#1011,
+    LOW_RESERVED_NC := 16#2000,
+    HIGH_RESERVED_NC := 16#20FF,
+    DEVICE_MOVE := 16#2100
+) UINT := MOT_GENERIC;
+END_TYPE
+
+
+
+
+

E_MotionRequest

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE E_MotionRequest :
+    // Defines behavior options for when FB_MotionRequest is run during an active move from another source
+(
+    WAIT := 0,
+    INTERRUPT := 1,
+    ABORT := 2
+);
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

E_PnuematicActuatorPositionState

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+// Defines the positions for a pnuematic actuator
+TYPE E_PnuematicActuatorPositionState :
+(
+   RETRACTED    := 0, // Out limit switch is active
+   INSERTED    := 1, // In limit switch is active
+   MOVING    := 2, // Neither limit switches is Active
+   INVALID :=3 // Invalid state
+);
+END_TYPE
+
+
+
+
+

E_StageBrakeMode

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE E_StageBrakeMode :
+    // Defines when to send the brake disengage signal in FB_MotionStage
+(
+    IF_ENABLED, // Disengage brake when the motor is enabled
+    IF_MOVING, // Disengage brake when the motor is moving
+    NO_BRAKE // Do not change the brake state in FB_MotionStage
+);
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

E_StageEnableMode

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE E_StageEnableMode :
+    // Define conditions when FB_MotionStage automatically sets bEnable
+(
+    ALWAYS, // Always set bEnable to TRUE
+    NEVER,  // Only change bEnable on errors
+    DURING_MOTION  // Enable before motion, disable after motion
+);
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

E_StatePMPSStatus

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE E_StatePMPSStatus :
+(
+    // No other enum state describes it
+    UNKNOWN := 0,
+    // Moving toward a known state
+    TRANSITION := 1,
+    // Within a known state, not trying to leave
+    AT_STATE := 2,
+    // PMPS is in some way disabled, either with maint mode or arbiter disable
+    DISABLED := 3
+);
+END_TYPE
+
+
+
+
+

E_TestStates

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE E_TestStates :
+(
+    Unknown := 0,
+    OUT := 1,
+    TARGET1 := 2,
+    TARGET2 := 3
+) UINT;
+END_TYPE
+
+
+
+
+

EL5042_Status

+
{attribute 'obsolete' := 'EL5042_Status has been renamed to ST_EL5042_Status'}
+TYPE EL5042_Status : ST_EL5042_Status; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_EpicsHomeCmd

+
{attribute 'obsolete' := 'Use E_EpicsHomeCmd'}
+TYPE ENUM_EpicsHomeCmd : E_EpicsHomeCmd; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_EpicsInOut

+
{attribute 'obsolete' := 'Use E_EpicsInOut'}
+TYPE ENUM_EpicsInOut : E_EpicsInOut; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_EpicsInOut_INT

+
{attribute 'obsolete' := 'Use ENUM_EpicsInOut'}
+{attribute 'qualified_only'}
+// Example EPICS states enum for use in all versions of the states FBs
+// Remove strict attribute for easier handling
+TYPE ENUM_EpicsInOut_INT :
+(
+    UNKNOWN := 0, // UNKNOWN must be in slot 0 or the FB breaks
+    OUT := 1, // OUT at slot 1 is a convention
+    IN := 2
+) INT;
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_EpicsMotorCmd

+
{attribute 'obsolete' := 'Use E_EpicsMotorCmd'}
+TYPE ENUM_EpicsMotorCmd : E_EpicsMotorCmd; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_MotionFFType

+
{attribute 'obsolete' := 'Use E_MotionFFType'}
+TYPE ENUM_MotionFFType : E_MotionFFType; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_MotionRequest

+
{attribute 'obsolete' := 'Use E_MotionRequest'}
+TYPE ENUM_MotionRequest : E_MotionRequest; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_PnuematicActuatorPositionState

+
{attribute 'obsolete' := 'Use E_PnuematicActuatorPositionState'}
+TYPE ENUM_PnuematicActuatorPositionState : E_PnuematicActuatorPositionState; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_StageBrakeMode

+
{attribute 'obsolete' := 'Use E_StageBrakeMode'}
+TYPE ENUM_StageBrakeMode : E_StageBrakeMode; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_StageEnableMode

+
{attribute 'obsolete' := 'Use E_StageEnableMode'}
+TYPE ENUM_StageEnableMode : E_StageEnableMode; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ENUM_StatePMPSStatus

+
{attribute 'obsolete' := 'Use E_StatePMPSStatus'}
+TYPE ENUM_StatePMPSStatus : E_StatePMPSStatus; END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ST_EL5042_Status

+
TYPE ST_EL5042_Status :
+STRUCT
+END_STRUCT
+END_TYPE
+
+
+
+
+

ST_ErrorSystem

+
TYPE ST_ErrorSystem :
+STRUCT
+    //Array of error data. Size = cSizeOfErrorData in the GVL
+    aErrorData : ARRAY [0..GVL_ErrorSystem.cSizeOfErrorData - 1] OF DUT_TerminalError;
+    lNextErrorID : ULINT := 1;                                      //ErrorID for the next error entry
+    nNoErrors : UINT;                                                       //Number of errors in the list
+    nNoOverflows : INT := 0;                                        //Number of overflows. How many error entries have been lost
+END_STRUCT
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ST_MotionPneumaticActuator

+
{attribute 'qualified_only'}
+{attribute 'strict'}
+TYPE ST_MotionPneumaticActuator :
+    // Defines the EPICS interface to actuating a pneumatic stage
+STRUCT
+     (* Hardware *)
+    //Readbacks
+    //Limit Switch
+    {attribute 'pytmc' := '
+     pv: PLC:bInLimitSwitch
+     io: i
+     field: ZNAM FALSE
+     field: ONAM TRUE
+     field: DESC TRUE if IN limit is reached
+    '}
+    i_bInLimitSwitch    :    BOOL;
+    {attribute 'pytmc' := '
+     pv: PLC:bOutLimitSwitch
+     io: i
+     field: ZNAM FALSE
+     field: ONAM TRUE
+     field: DESC TRUE if OUT limit is reached
+    '}
+    i_bOutLimitSwitch    :    BOOL;
+    //Controls
+    //Digital outputs
+    {attribute 'pytmc' := '
+    pv: bRetractDigitalOutput;
+    io: i;
+    field: ONAM FALSE
+    field: ZNAM TRUE
+    field: DESC TRUE if Retract digital output is active
+    '}
+    q_bRetract    :    BOOL;
+    {attribute 'pytmc' := '
+    pv: bInsertDigitalOutput;
+    io: i;
+    field: ONAM FALSE
+    field: ZNAM TRUE
+    field: DESC TRUE if Insert digital output is active
+    '}
+    q_bInsert    :    BOOL;
+
+
+    //Logic and supervisory
+    {attribute 'pytmc' := '
+    pv: bInterlockOK;
+    io: i;
+    field: ZNAM FALSE
+    field: ONAM TRUE
+    field: DESC True if the actuator has permission to move in either direction
+    '}
+    bILK_OK: BOOL;
+    {attribute 'pytmc' := '
+    pv: bInsertEnable;
+    io: i;
+    field: ZNAM FALSE
+    field: ONAM TRUE
+    field: DESC True if the actuator had permission to be retracted
+    '}
+    bInsertOK    :    BOOL;
+    {attribute 'pytmc' := '
+    pv: bRetractEnable;
+    io: i;
+    field: ZNAM FALSE
+    field: ONAM TRUE
+    field: DESC True if the actuator had permission to be inserted
+    '}
+    bRetractOK    :    BOOL;
+
+    (* Commands *)
+    // Used from Epics to comand the actuator to  move
+    {attribute 'pytmc' := '
+    pv: CMD:IN;
+    io: io;
+    field: DESC Used by EPICS and internally to request Insert motion
+    '}
+    bInsert_SW        :    BOOL;
+    {attribute 'pytmc' := '
+    pv: CMD:OUT;
+    io: io;
+    field: DESC Used by EPICS and internally to request retract motion
+    '}
+    bRetract_SW    :    BOOL;
+
+    (*Returns*)
+     // TRUE if in the middle of a command
+    {attribute 'pytmc' := '
+     pv: bBusy
+     io: i
+     field: ONAM FALSE
+     field: ZNAM TRUE
+     field: DESC TRUE if in the middle of a command
+    '}
+    bBusy: BOOL;
+    // TRUE if we've done a command and it has finished
+    {attribute 'pytmc' := '
+     pv: bDone
+     io: i
+     field: ONAM FALSE
+     field: ZNAM TRUE
+      field: DESC TRUE if command finished successfully
+    '}
+    bDone: BOOL;
+     {attribute 'pytmc' := '
+        pv: bReset
+        io: io
+        field: ZNAM FALSE
+        field: ONAM TRUE
+        field: DESC Used internally to reset errors
+    '}
+    bReset: BOOL;
+    // TRUE if we're in an error state
+    {attribute 'pytmc' := '
+     pv: PLC:bError
+     io: i
+     field: ONAM FALSE
+     field: ZNAM TRUE
+     field: DESC TRUE if we're in an error state
+    '}
+    bError: BOOL;
+
+     // Error code if nonzero
+    {attribute 'pytmc' := '
+     pv: PLC:nErrorId
+     io: i
+     field: DESC Error code if nonzero
+    '}
+    nErrorId: UDINT;
+    // Message to identify the error state
+    {attribute 'pytmc' := '
+     pv: PLC:sErrorMessage
+     io: i
+     field: DESC Message to identify the error state
+    '}
+    sErrorMessage: STRING;
+    {attribute 'pytmc' := '
+    pv: nPositionState ;
+    type: mbbi ;
+    field: ZRST RETRACTED ;
+    field: ONST INSERTED ;
+    field: TWST MOVING ;
+    field: THST INVALID ;
+    io: i
+    field: DESC Pneumatic actuator position
+    '}
+
+    eState    :    E_PnuematicActuatorPositionState := E_PnuematicActuatorPositionState.INVALID;
+
+END_STRUCT
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ST_MotionStage

+
TYPE ST_MotionStage :
+    // Defines the EPICS interface to moving a motor in TwinCAT
+STRUCT
+    (* Hardware *)
+
+    // PLC Axis Reference
+    Axis: AXIS_REF;
+    // NC Forward Limit Switch: TRUE if ok to move
+    bLimitForwardEnable AT %I*: BOOL;
+    // NC Backward Limit Switch: TRUE if ok to move
+    bLimitBackwardEnable AT %I*: BOOL;
+    // NO Home Switch: TRUE if at home
+    bHome AT %I*: BOOL;
+    // NC Brake Output: TRUE to release brake
+    bBrakeRelease AT %Q*: BOOL;
+    // NC STO Input: TRUE if ok to move
+    {attribute 'pytmc' := '
+        pv: PLC:bHardwareEnable
+        io: i
+        field: ZNAM FALSE
+        field: ONAM TRUE
+        field: DESC TRUE if STO not hit
+    '}
+    bHardwareEnable AT %I*: BOOL;
+
+    // Raw encoder IO for ULINT (Biss-C)
+    nRawEncoderULINT AT %I*: ULINT;
+    // Raw encoder IO for UINT (Relative Encoders)
+    nRawEncoderUINT AT %I*: UINT;
+    // Raw encoder IO for INT (LVDT)
+    nRawEncoderINT AT %I*: INT;
+
+    (* Psuedo-hardware *)
+
+    // Forward enable EPS summary
+    bAllForwardEnable: BOOL:=FALSE;
+    // Backward enable EPS summary
+    bAllBackwardEnable: BOOL:=FALSE;
+    // Enable EPS summary encapsulating emergency stop button and any additional motion preventive hardware
+    bAllEnable: BOOL:=FALSE;
+    // Forward virtual gantry limit switch
+    bGantryForwardEnable: BOOL:=FALSE;
+    // Backward virtual gantry limit switch
+    bGantryBackwardEnable: BOOL:=FALSE;
+    // Encoder count summary, if linked above
+    {attribute 'pytmc' := '
+        pv: PLC:nEncoderCount
+        io: i
+        field: DESC Count from encoder hardware
+    '}
+    nEncoderCount: UDINT;
+    // Forward Enable EPS struct
+    {attribute 'pytmc' := '
+        pv: PLC:stEPSF
+        io: i
+        field: DESC Forward Enable Interlocks
+    '}
+    stEPSForwardEnable: DUT_EPS;
+    // Backward Enable EPS struct
+    {attribute 'pytmc' := '
+        pv: PLC:stEPSB
+        io: i
+        field: DESC Backward Enable Interlocks
+    '}
+    stEPSBackwardEnable: DUT_EPS;
+    // Power Enable EPS struct
+    {attribute 'pytmc' := '
+        pv: PLC:stEPSP
+        io: i
+        field: DESC Power Interlocks
+    '}
+    stEPSPowerEnable: DUT_EPS;
+
+    (* Settings *)
+    // Name to use for log messages, fast faults, etc.
+    sName: STRING;
+    // If TRUE, we want to enable the motor independently of PMPS or other safety systems.
+    bPowerSelf: BOOL:=FALSE;
+    // Determines when we automatically enable the motor
+    nEnableMode: E_StageEnableMode:=E_StageEnableMode.DURING_MOTION;
+    // Determines when we automatically disengage the brake
+    nBrakeMode: E_StageBrakeMode:=E_StageBrakeMode.IF_ENABLED;
+    // Determines our encoder homing strategy
+    nHomingMode: E_EpicsHomeCmd:=E_EpicsHomeCmd.NONE;
+    // Set true to activate gantry EPS
+    bGantryAxis: BOOL:=FALSE;
+
+    // Set to gantry difference tolerance
+    nGantryTol: LINT:=0;
+
+    // Encoder count at which this axis is aligned with other axis
+    nEncRef: ULINT:=0;
+
+    (* Commands *)
+    // Used internally to request enables
+    bEnable: BOOL;
+    // Used internally to reset errors and other state
+    {attribute 'pytmc' := '
+        pv: PLC:bReset
+        io: io
+        field: ZNAM FALSE
+        field: ONAM TRUE
+        field: DESC Used internally to reset errors
+    '}
+    bReset: BOOL;
+    // Used internally and by the IOC to start or stop a move
+    bExecute: BOOL;
+    // Used by the IOC to disable an axis
+    {attribute 'pytmc' := '
+        pv: PLC:bUserEnable
+        io: io
+        field: ZNAM DISABLE
+        field: ONAM ENABLE
+        field: DESC Used to disable power entirely for an axis
+    '}
+    bUserEnable: BOOL := 1;
+
+    (* Shortcut Commands *)
+    // Start a move to fPosition with fVelocity
+    bMoveCmd: BOOL;
+    // Start the homing routine
+    {attribute 'pytmc' := '
+        pv: PLC:bHomeCmd
+        io: io
+        field: DESC Start the homing routine
+    '}
+    bHomeCmd: BOOL;
+
+    (* Command Args *)
+    // Used internally and by the IOC to pick what kind of move to do
+    nCommand: INT;
+    // Used internally and by the IOC to pass additional data to some commands
+    nCmdData: INT;
+    // Used internally and by the IOC to pick a destination for the move
+    fPosition: LREAL;
+    // Used internally and by the IOC to pick a move velocity
+    fVelocity: LREAL;
+    // Used internally and by the IOC to pick a move acceleration
+    fAcceleration: LREAL;
+    // Used internally and by the IOC to pick a move deceleration
+    fDeceleration: LREAL;
+    // Used internally and by the IOC to pick a home position
+    {attribute 'pytmc' := '
+        pv: PLC:fHomePosition
+        io: io
+        field: DESC Used internally and by the IOC to pick home position
+    '}
+    fHomePosition: LREAL;
+
+    (* Info *)
+    // Unique ID assigned to each axis in the NC
+    nMotionAxisID: UDINT:=0;
+
+    (* Returns *)
+    // TRUE if done enabling
+    bEnableDone: BOOL;
+    // TRUE if in the middle of a command
+    bBusy: BOOL;
+    // TRUE if we've done a command and it has finished
+    bDone: BOOL;
+    // TRUE if the motor has been homed, or does not need to be homed
+    bHomed: BOOL;
+    // TRUE if we have safety permission to move
+    bSafetyReady: BOOL;
+    // TRUE if we're in an error state
+    {attribute 'pytmc' := '
+        pv: PLC:bError
+        io: i
+        field: ZNAM FALSE
+        field: ONAM TRUE
+        field: DESC TRUE if we are in an error state
+        update: 100Hz notify
+    '}
+    bError: BOOL;
+    // Error code if nonzero
+    {attribute 'pytmc' := '
+        pv: PLC:nErrorId
+        io: i
+        field: DESC Error code if nonzero
+        update: 100Hz notify
+    '}
+    nErrorId: UDINT;
+    // Message to identify the error state
+    {attribute 'pytmc' := '
+        pv: PLC:sErrorMessage
+        io: i
+        field: DESC Message to identify the error state
+        update: 100Hz notify
+    '}
+    sErrorMessage: STRING;
+    // Internal hook for custom error messages
+    sCustomErrorMessage: STRING;
+    // MC_ReadParameterSet Output
+    stAxisParameters: ST_AxisParameterSet;
+    // True if we've updated stAxisParameters at least once
+    bAxisParamsInit: BOOL;
+
+    // Misc axis status information for the IOC
+    stAxisStatus: DUT_AxisStatus_v0_01;
+
+    (* Other status information for users of the IOC *)
+    // Position lag difference
+    {attribute 'pytmc' := '
+        pv: PLC:fPosDiff
+        io: i
+        field: DESC Position lag difference
+    '}
+    fPosDiff: LREAL;
+END_STRUCT
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ST_PositionState

+
TYPE ST_PositionState :
+    // Defines settings and current safety status for moves to specific positions for an axis
+STRUCT
+    // Name as queried via the NAME PV in EPICS
+    {attribute 'pytmc' := '
+        pv: NAME
+        io: input
+        field: DESC Name of this position state
+    '}
+    sName: STRING := 'Invalid';
+
+    // Position associated with this state
+    {attribute 'pytmc' := '
+        pv: SETPOINT
+        io: io
+        field: DESC Axis position associated with this state
+    '}
+    fPosition: LREAL;
+
+    {attribute 'pytmc' := '
+        pv: ENCODER
+        io: i
+        field: DESC Encoder count associated with this state
+    '}
+    nEncoderCount: UDINT;
+
+    // Maximum allowable deviation from fPosition while at the state
+    fDelta: LREAL;
+
+    // Speed at which to move to this state
+    {attribute 'pytmc' := '
+        pv: VELO
+        io: io
+        field: DESC Speed at which to move to this state
+    '}
+    fVelocity: LREAL;
+
+    // (optional) Acceleration to use for moves to this state
+    fAccel: LREAL;
+
+    // (optional) Deceleration to use for moves to this state
+    fDecel: LREAL;
+
+    // Safety parameter. This must be set to TRUE by the PLC program to allow moves to this state. This is expected to change as conditions change.
+    {attribute 'pytmc' := '
+        pv: MOVE_OK
+        io: i
+        field: ZNAM FALSE
+        field: ONAM TRUE
+        field: DESC TRUE if the move would be safe
+    '}
+    bMoveOk: BOOL;
+
+    // Signifies to FB_PositionStateLock that this state should be immutable
+    bLocked: BOOL;
+
+    // Set this to TRUE when you make your state. This defaults to FALSE so that uninitialized states can never be moved to
+    bValid: BOOL;
+
+    // Set this to TRUE when you want to use the raw encoder counts to define the state
+    bUseRawCounts: BOOL;
+
+    // Is set to TRUE by FB_PositionStateInternal when called
+    bUpdated: BOOL;
+
+    // We give this a state name and it is used to load parameters from the pmps database.
+    stPMPS: ST_DbStateParams;
+END_STRUCT
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ST_RenishawAbsEnc

+
// Renishaw BiSS-C absolute encoder used with an EL5042
+TYPE ST_RenishawAbsEnc :
+STRUCT
+    Count AT %I*: ULINT; // Connect to encoder "Position" input
+    Status: ST_EL5042_Status; // Status struct placeholder
+    Ref: ULINT; // Encoder zero position (useful for aligned position with gantries)
+END_STRUCT
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ST_StateEpicsToPlc

+
TYPE ST_StateEpicsToPlc :
+(*
+    This data structure contains the standard EPICS input connection points for the state movers.
+
+    The data in this struct flows from EPICS to the PLC.
+
+    It includes everything except the SET PV, which cannot be included here
+    as it is sourced from enum values unique to the application, and the PMPS PVs, which are
+    gathered in their own data type, ST_StatePMPSEpicsToPlc. That actually means that this only
+    holds the RESET PV, for now.
+
+    nSetValue here is actively used by state blocks even though it is not exposed
+    directly to EPICS. You should avoid manually modifying it or else
+    you may interfere with normal operations of the state function blocks.
+
+    For including your own ENUM input, you should pytmc pragma the PV name to end in "SET",
+    and match the prefix of this FB's "RESET" PV. Then, you can include your enum
+    as the eEnumSet IN_OUT var and let the EPICS IOC handle it.
+*)
+STRUCT
+    // For internal use only. This holds new goal positions as an integer, else it is 0 if there is no new state move request. It is written to from the user's input enum.
+    nSetValue: UINT;
+
+    // Set this to TRUE to acknowledge and clear an error.
+    {attribute 'pytmc' := '
+        pv: RESET
+        io: io
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bReset: BOOL;
+END_STRUCT
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ST_StatePlcToEpics

+
TYPE ST_StatePlcToEpics :
+(*
+    This data structure contains the standard EPICS connection points for the state movers.
+
+    The data in this struct flows from the PLC to EPICS.
+
+    It includes everything except the GET PV, which cannot be included here
+    as it is sourced from enum values unique to the application, and the PMPS PVs, which are
+    gathered in their own data type, ST_StatePMPSPlcToEpics.
+
+    nGetValue here is actively used by state blocks even though it is not exposed directly
+    to EPICS. It is safe to read this value, but you should avoid modifying it, which may
+    interfere with normal operations of the state function blocks.
+
+    For including your own ENUM input, you should pytmc pragma the PV name to end in "GET",
+    and match the prefix of this FB's "DONE" PV. Then, you can include your enum
+    as the eEnumGet IN_OUT var and let the EPICS IOC handle it.
+*)
+STRUCT
+    // For internal use only. This holds the current position index as an integer, else it is 0 if we are changing states or not at any particular state.
+    nGetValue: UINT;
+    // This will be TRUE when we are in an active state move and FALSE otherwise.
+    {attribute 'pytmc' := '
+        pv: BUSY
+        io: i
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bBusy: BOOL;
+    // This will be TRUE after a move completes and FALSE otherwise.
+    {attribute 'pytmc' := '
+        pv: DONE
+        io: i
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bDone: BOOL;
+    // This will be TRUE if the most recent move had an error and FALSE otherwise.
+    {attribute 'pytmc' := '
+        pv: ERR
+        io: i
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bError: BOOL;
+    // This will be set to an NC error code during an error if one exists or left at 0 otherwise.
+    {attribute 'pytmc' := '
+        pv: ERRID
+        io: i
+    '}
+    nErrorID: UDINT;
+    // This will be set to an appropriate error message during an error if one exists or left as an empty string otherwise.
+    {attribute 'pytmc' := '
+        pv: ERRMSG
+        io: i
+    '}
+    sErrorMsg: STRING;
+END_STRUCT
+END_TYPE
+
+
+
+
Related:
+
+
+
+
+

ST_StatePMPSEpicsToPlc

+
TYPE ST_StatePMPSEpicsToPlc :
+(*
+    This data structure contains the standard PMPS EPICS connection points for the state movers.
+
+    The data in this struct flows from EPICS to the PLC.
+*)
+STRUCT
+    // User setting: TRUE to enable the arbiter, FALSE to disable it.
+    {attribute 'pytmc' := '
+        pv: PMPS:ARB:ENABLE
+        io: io
+    '}
+    bArbiterEnabled: BOOL := TRUE;
+    // User setting: TRUE to enable maintenance mode (Fast fault, free motion), FALSE to disable it.
+    {attribute 'pytmc' := '
+        pv: PMPS:MAINT
+        io: io
+    '}
+    bMaintMode: BOOL;
+END_STRUCT
+END_TYPE
+
+
+
+
+

ST_StatePMPSPlcToEpics

+
TYPE ST_StatePMPSPlcToEpics :
+(*
+    This data structure contains the standard PMPS EPICS connection points for the state movers.
+
+    The data in this struct flows from the PLC to EPICS.
+*)
+STRUCT
+    // The database entry for the transition state. This should always be present.
+    {attribute 'pytmc' := '
+        pv: PMPS:TRANS
+        io: i
+    '}
+    stTransitionDb: ST_DbStateParams;
+END_STRUCT
+END_TYPE
+
+
+
+
+
+

GVLs

+
+

Global_Version

+
{attribute 'TcGenerated'}
+// This function has been automatically generated from the project information.
+VAR_GLOBAL CONSTANT
+    {attribute 'const_non_replaced'}
+    {attribute 'linkalways'}
+    stLibVersion_lcls_twincat_motion : ST_LibVersion := (iMajor := 4, iMinor := 0, iBuild := 3, iRevision := 0, sVersion := '4.0.3');
+END_VAR
+
+
+
+
+

GVL

+
VAR_GLOBAL
+    nHomingError:UDINT:=16#14D00;
+END_VAR
+
+
+
+
+

GVL_ErrorSystem

+
{attribute 'qualified_only'}
+VAR_GLOBAL CONSTANT
+    cSizeOfErrorData : UINT := 128;
+
+END_VAR
+
+
+
+
+

MOTION_GVL

+
{attribute 'qualified_only'}
+VAR_GLOBAL
+    // Global file reader instance, used in fbStandardPMPSDB
+    fbPmpsFileReader: FB_JsonFileToJsonDoc;
+    {attribute 'pytmc' := '
+        pv: @(PREFIX)DB
+        io: io
+    '}
+    // Global DB handler, Must be called in PLC project to use the PMPS DB for a motion project
+    fbStandardPMPSDB: FB_Standard_PMPSDB;
+    // Debug, records the highest number of motors used in an ND states block in the PLC. Can be used to limit MotionConstants.MAX_STATE_MOTORS to save on memory usage and PV count.
+    nMaxStateMotorCount: UINT;
+    // Debug, records the highest state count in the PLC. Can be used to limit GeneralConstants.MAX_STATES to save on memory usage and PV count.
+    nMaxStates: UINT;
+END_VAR
+
+
+
+
Related:
+
+
+
+
+

MotionConstants

+
{attribute 'qualified_only'}
+(*
+    Global Configurable Motion Constants
+
+    These are reconfigurable at the project level.
+    When reconfigured they are set prior to compilation and cannot be changed at runtime.
+*)
+VAR_GLOBAL CONSTANT
+    (*
+    Arbitary cap on multidimensional states to simplify statements for the compiler.
+    This is reconfigurable at the project level and should be set to the highest number of motors used in a states block.
+    If you are not sure how many motors are used per state block, check MOTION_GVL.nMaxStateMotorCount
+    *)
+    MAX_STATE_MOTORS: UINT := 3;
+END_VAR
+
+
+
+
Related:
+
+
+
+
+
+

POUs

+
+

CheckBounds

+
// Implicitly generated code : DO NOT EDIT
+FUNCTION CheckBounds : DINT
+VAR_INPUT
+    index, lower, upper: DINT;
+END_VAR
+// Implicitly generated code : Only an Implementation suggestion
+{noflow}
+IF  index < lower THEN
+    CheckBounds := lower;
+ELSIF  index > upper THEN
+    CheckBounds := upper;
+ELSE
+    CheckBounds := index;
+END_IF
+{flow}
+
+END_FUNCTION
+
+
+
+
+

CheckDivDInt

+
// Implicitly generated code : DO NOT EDIT
+FUNCTION CheckDivDInt : DINT
+VAR_INPUT
+    divisor:DINT;
+END_VAR
+// Implicitly generated code : Only an Implementation suggestion
+{noflow}
+IF divisor = 0 THEN
+    CheckDivDInt:=1;
+ELSE
+    CheckDivDInt:=divisor;
+END_IF;
+{flow}
+
+END_FUNCTION
+
+
+
+
+

CheckDivLInt

+
// Implicitly generated code : DO NOT EDIT
+FUNCTION CheckDivLInt : LINT
+VAR_INPUT
+    divisor:LINT;
+END_VAR
+// Implicitly generated code : Only an Implementation suggestion
+{noflow}
+IF divisor = 0 THEN
+    CheckDivLInt:=1;
+ELSE
+    CheckDivLInt:=divisor;
+END_IF;
+{flow}
+
+END_FUNCTION
+
+
+
+
+

CheckDivLReal

+
// Implicitly generated code : DO NOT EDIT
+FUNCTION CheckDivLReal : LREAL
+VAR_INPUT
+    divisor:LREAL;
+END_VAR
+// Implicitly generated code : Only an Implementation suggestion
+{noflow}
+IF divisor = 0 THEN
+    CheckDivLReal:=1;
+ELSE
+    CheckDivLReal:=divisor;
+END_IF;
+{flow}
+
+END_FUNCTION
+
+
+
+
+

CheckDivReal

+
// Implicitly generated code : DO NOT EDIT
+FUNCTION CheckDivReal : REAL
+VAR_INPUT
+    divisor:REAL;
+END_VAR
+// Implicitly generated code : Only an Implementation suggestion
+{noflow}
+IF divisor = 0 THEN
+    CheckDivReal:=1;
+ELSE
+    CheckDivReal:=divisor;
+END_IF;
+{flow}
+
+END_FUNCTION
+
+
+
+
+

EK1200

+
FUNCTION_BLOCK EK1200
+VAR_INPUT
+    En: BOOL;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+END_VAR
+EnO:=En;
+
+END_FUNCTION_BLOCK
+
+
+
+
+

EL1008

+
///EL1008 | 8-channel digital input terminal 24 V DC, 3 ms
+FUNCTION_BLOCK EL1008
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    bDi_1: BOOL;
+    bDi_2: BOOL;
+    bDi_3: BOOL;
+    bDi_4: BOOL;
+    bDi_5: BOOL;
+    bDi_6: BOOL;
+    bDi_7: BOOL;
+    bDi_8: BOOL;
+    bError: BOOL;
+END_VAR
+
+VAR
+    Channel_1_Input AT %I*: BOOL;
+    Channel_2_Input AT %I*: BOOL;
+    Channel_3_Input AT %I*: BOOL;
+    Channel_4_Input AT %I*: BOOL;
+    Channel_5_Input AT %I*: BOOL;
+    Channel_6_Input AT %I*: BOOL;
+    Channel_7_Input AT %I*: BOOL;
+    Channel_8_Input AT %I*: BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL1008_Error : FB_TerminalError;
+END_VAR
+EnO:=En;
+
+//Error FB instance
+EL1008_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError=FALSE THEN
+            bDi_1:=Channel_1_Input;
+            bDi_2:=Channel_2_Input;
+            bDi_3:=Channel_3_Input;
+            bDi_4:=Channel_4_Input;
+            bDi_5:=Channel_5_Input;
+            bDi_6:=Channel_6_Input;
+            bDi_7:=Channel_7_Input;
+            bDi_8:=Channel_8_Input;
+    ELSE
+            bDi_1:=FALSE;
+            bDi_2:=FALSE;
+            bDi_3:=FALSE;
+            bDi_4:=FALSE;
+            bDi_5:=FALSE;
+            bDi_6:=FALSE;
+            bDi_7:=FALSE;
+            bDi_8:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL1018

+
///EL1018 | 8-channel digital input terminal 24 V DC, 10 µs
+FUNCTION_BLOCK EL1018
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    bDi_1: BOOL;
+    bDi_2: BOOL;
+    bDi_3: BOOL;
+    bDi_4: BOOL;
+    bDi_5: BOOL;
+    bDi_6: BOOL;
+    bDi_7: BOOL;
+    bDi_8: BOOL;
+    bError : BOOL;
+END_VAR
+
+VAR
+    Channel_1_Input AT %I*: BOOL;
+    Channel_2_Input AT %I*: BOOL;
+    Channel_3_Input AT %I*: BOOL;
+    Channel_4_Input AT %I*: BOOL;
+    Channel_5_Input AT %I*: BOOL;
+    Channel_6_Input AT %I*: BOOL;
+    Channel_7_Input AT %I*: BOOL;
+    Channel_8_Input AT %I*: BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State  AT %I*: UINT;
+
+    //FB-s
+    EL1018_Error : FB_TerminalError;
+END_VAR
+EnO:=En;
+
+//Error FB instance
+EL1018_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError=FALSE THEN
+            bDi_1:=Channel_1_Input;
+            bDi_2:=Channel_2_Input;
+            bDi_3:=Channel_3_Input;
+            bDi_4:=Channel_4_Input;
+            bDi_5:=Channel_5_Input;
+            bDi_6:=Channel_6_Input;
+            bDi_7:=Channel_7_Input;
+            bDi_8:=Channel_8_Input;
+    ELSE
+            bDi_1:=FALSE;
+            bDi_2:=FALSE;
+            bDi_3:=FALSE;
+            bDi_4:=FALSE;
+            bDi_5:=FALSE;
+            bDi_6:=FALSE;
+            bDi_7:=FALSE;
+            bDi_8:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL1808

+
///EL1808 | HD EtherCAT Terminals, 8-channel digital input 24 V DC, 3 ms, 2-wire connection
+FUNCTION_BLOCK EL1808
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    bDi_1: BOOL;
+    bDi_2: BOOL;
+    bDi_3: BOOL;
+    bDi_4: BOOL;
+    bDi_5: BOOL;
+    bDi_6: BOOL;
+    bDi_7: BOOL;
+    bDi_8: BOOL;
+    bError: BOOL;
+END_VAR
+
+VAR
+    Channel_1_Input AT %I*: BOOL;
+    Channel_2_Input AT %I*: BOOL;
+    Channel_3_Input AT %I*: BOOL;
+    Channel_4_Input AT %I*: BOOL;
+    Channel_5_Input AT %I*: BOOL;
+    Channel_6_Input AT %I*: BOOL;
+    Channel_7_Input AT %I*: BOOL;
+    Channel_8_Input AT %I*: BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL1808_Error : FB_TerminalError;
+END_VAR
+EnO:=En;
+
+//Error FB instance
+EL1808_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError=FALSE THEN
+            bDi_1:=Channel_1_Input;
+            bDi_2:=Channel_2_Input;
+            bDi_3:=Channel_3_Input;
+            bDi_4:=Channel_4_Input;
+            bDi_5:=Channel_5_Input;
+            bDi_6:=Channel_6_Input;
+            bDi_7:=Channel_7_Input;
+            bDi_8:=Channel_8_Input;
+    ELSE
+            bDi_1:=FALSE;
+            bDi_2:=FALSE;
+            bDi_3:=FALSE;
+            bDi_4:=FALSE;
+            bDi_5:=FALSE;
+            bDi_6:=FALSE;
+            bDi_7:=FALSE;
+            bDi_8:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL1809

+
///EL1809 | HD EtherCAT Terminals, 16-channel digital input 24 V DC, 3 ms
+FUNCTION_BLOCK EL1809
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    bDi_1: BOOL;
+    bDi_2: BOOL;
+    bDi_3: BOOL;
+    bDi_4: BOOL;
+    bDi_5: BOOL;
+    bDi_6: BOOL;
+    bDi_7: BOOL;
+    bDi_8: BOOL;
+    bDi_9: BOOL;
+    bDi_10: BOOL;
+    bDi_11: BOOL;
+    bDi_12: BOOL;
+    bDi_13: BOOL;
+    bDi_14: BOOL;
+    bDi_15: BOOL;
+    bDi_16: BOOL;
+    bError: BOOL;
+END_VAR
+
+VAR
+    Channel_1_Input AT %I*: BOOL;
+    Channel_2_Input AT %I*: BOOL;
+    Channel_3_Input AT %I*: BOOL;
+    Channel_4_Input AT %I*: BOOL;
+    Channel_5_Input AT %I*: BOOL;
+    Channel_6_Input AT %I*: BOOL;
+    Channel_7_Input AT %I*: BOOL;
+    Channel_8_Input AT %I*: BOOL;
+    Channel_9_Input AT %I*: BOOL;
+    Channel_10_Input AT %I*: BOOL;
+    Channel_11_Input AT %I*: BOOL;
+    Channel_12_Input AT %I*: BOOL;
+    Channel_13_Input AT %I*: BOOL;
+    Channel_14_Input AT %I*: BOOL;
+    Channel_15_Input AT %I*: BOOL;
+    Channel_16_Input AT %I*: BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL1809_Error : FB_TerminalError;
+END_VAR
+EnO:=En;
+
+//Error FB instance
+EL1809_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError=FALSE THEN
+            bDi_1:=Channel_1_Input;
+            bDi_2:=Channel_2_Input;
+            bDi_3:=Channel_3_Input;
+            bDi_4:=Channel_4_Input;
+            bDi_5:=Channel_5_Input;
+            bDi_6:=Channel_6_Input;
+            bDi_7:=Channel_7_Input;
+            bDi_8:=Channel_8_Input;
+            bDi_9:=Channel_9_Input;
+            bDi_10:=Channel_10_Input;
+            bDi_11:=Channel_11_Input;
+            bDi_12:=Channel_12_Input;
+            bDi_13:=Channel_13_Input;
+            bDi_14:=Channel_14_Input;
+            bDi_15:=Channel_15_Input;
+            bDi_16:=Channel_16_Input;
+    ELSE
+            bDi_1:=FALSE;
+            bDi_2:=FALSE;
+            bDi_3:=FALSE;
+            bDi_4:=FALSE;
+            bDi_5:=FALSE;
+            bDi_6:=FALSE;
+            bDi_7:=FALSE;
+            bDi_8:=FALSE;
+            bDi_9:=FALSE;
+            bDi_10:=FALSE;
+            bDi_11:=FALSE;
+            bDi_12:=FALSE;
+            bDi_13:=FALSE;
+            bDi_14:=FALSE;
+            bDi_15:=FALSE;
+            bDi_16:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL1819

+
///EL1819 | HD EtherCAT Terminals, 16-channel digital input 24 V DC, 10 µs
+FUNCTION_BLOCK EL1819
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    bDi_1: BOOL;
+    bDi_2: BOOL;
+    bDi_3: BOOL;
+    bDi_4: BOOL;
+    bDi_5: BOOL;
+    bDi_6: BOOL;
+    bDi_7: BOOL;
+    bDi_8: BOOL;
+    bDi_9: BOOL;
+    bDi_10: BOOL;
+    bDi_11: BOOL;
+    bDi_12: BOOL;
+    bDi_13: BOOL;
+    bDi_14: BOOL;
+    bDi_15: BOOL;
+    bDi_16: BOOL;
+    bError: BOOL;
+END_VAR
+
+VAR
+    Channel_1_Input AT %I*: BOOL;
+    Channel_2_Input AT %I*: BOOL;
+    Channel_3_Input AT %I*: BOOL;
+    Channel_4_Input AT %I*: BOOL;
+    Channel_5_Input AT %I*: BOOL;
+    Channel_6_Input AT %I*: BOOL;
+    Channel_7_Input AT %I*: BOOL;
+    Channel_8_Input AT %I*: BOOL;
+    Channel_9_Input AT %I*: BOOL;
+    Channel_10_Input AT %I*: BOOL;
+    Channel_11_Input AT %I*: BOOL;
+    Channel_12_Input AT %I*: BOOL;
+    Channel_13_Input AT %I*: BOOL;
+    Channel_14_Input AT %I*: BOOL;
+    Channel_15_Input AT %I*: BOOL;
+    Channel_16_Input AT %I*: BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL1819_Error : FB_TerminalError;
+END_VAR
+EnO:=En;
+
+//Error FB instance
+EL1819_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError=FALSE THEN
+            bDi_1:=Channel_1_Input;
+            bDi_2:=Channel_2_Input;
+            bDi_3:=Channel_3_Input;
+            bDi_4:=Channel_4_Input;
+            bDi_5:=Channel_5_Input;
+            bDi_6:=Channel_6_Input;
+            bDi_7:=Channel_7_Input;
+            bDi_8:=Channel_8_Input;
+            bDi_9:=Channel_9_Input;
+            bDi_10:=Channel_10_Input;
+            bDi_11:=Channel_11_Input;
+            bDi_12:=Channel_12_Input;
+            bDi_13:=Channel_13_Input;
+            bDi_14:=Channel_14_Input;
+            bDi_15:=Channel_15_Input;
+            bDi_16:=Channel_16_Input;
+    ELSE
+            bDi_1:=FALSE;
+            bDi_2:=FALSE;
+            bDi_3:=FALSE;
+            bDi_4:=FALSE;
+            bDi_5:=FALSE;
+            bDi_6:=FALSE;
+            bDi_7:=FALSE;
+            bDi_8:=FALSE;
+            bDi_9:=FALSE;
+            bDi_10:=FALSE;
+            bDi_11:=FALSE;
+            bDi_12:=FALSE;
+            bDi_13:=FALSE;
+            bDi_14:=FALSE;
+            bDi_15:=FALSE;
+            bDi_16:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL2014

+
FUNCTION_BLOCK EL2014
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    bDo_1: BOOL;
+    bDo_2: BOOL;
+    bDo_3: BOOL;
+    bDo_4: BOOL;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO : BOOL;
+    bError : BOOL;
+END_VAR
+
+VAR
+    Channel_1_Output AT %Q*: BOOL;
+    Channel_2_Output AT %Q*: BOOL;
+    Channel_3_Output AT %Q*: BOOL;
+    Channel_4_Output AT %Q*: BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL2014_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Channel diagnostic variables and device diag variables
+*)
+
+EnO:=En;
+
+EL2014_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError=FALSE THEN
+            Channel_1_Output:=bDo_1;
+            Channel_2_Output:=bDo_2;
+            Channel_3_Output:=bDo_3;
+            Channel_4_Output:=bDo_4;
+    ELSE
+            Channel_1_Output:=FALSE;
+            Channel_2_Output:=FALSE;
+            Channel_3_Output:=FALSE;
+            Channel_4_Output:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL2252

+
///EL2252 | XFC, 2-channel digital output terminal with time stamp, tri-state
+FUNCTION_BLOCK EL2252
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    bDo_1: BOOL;
+    bDo_2: BOOL;
+ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO : BOOL;
+    bError : BOOL;
+END_VAR
+
+VAR
+    Channel_1_Output AT %Q*: BOOL;
+    Channel_2_Output AT %Q*: BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL2252_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Add the DC sync variables
+*)
+
+EL2252_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError=FALSE THEN
+            Channel_1_Output:=bDo_1;
+            Channel_2_Output:=bDo_2;
+    ELSE
+            Channel_1_Output:=FALSE;
+            Channel_2_Output:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL2808

+
FUNCTION_BLOCK EL2808
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    bDo_1: BOOL;
+    bDo_2: BOOL;
+    bDo_3: BOOL;
+    bDo_4: BOOL;
+    bDo_5: BOOL;
+    bDo_6: BOOL;
+    bDo_7: BOOL;
+    bDo_8: BOOL;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO : BOOL;
+    bError : BOOL;
+END_VAR
+
+VAR
+    Channel_1_Output AT %Q*: BOOL;
+    Channel_2_Output AT %Q*: BOOL;
+    Channel_3_Output AT %Q*: BOOL;
+    Channel_4_Output AT %Q*: BOOL;
+    Channel_5_Output AT %Q*: BOOL;
+    Channel_6_Output AT %Q*: BOOL;
+    Channel_7_Output AT %Q*: BOOL;
+    Channel_8_Output AT %Q*: BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL2808_Error : FB_TerminalError;
+END_VAR
+EnO:=En;
+
+EL2808_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError=FALSE THEN
+            Channel_1_Output:=bDo_1;
+            Channel_2_Output:=bDo_2;
+            Channel_3_Output:=bDo_3;
+            Channel_4_Output:=bDo_4;
+            Channel_5_Output:=bDo_5;
+            Channel_6_Output:=bDo_6;
+            Channel_7_Output:=bDo_7;
+            Channel_8_Output:=bDo_8;
+    ELSE
+            Channel_1_Output:=FALSE;
+            Channel_2_Output:=FALSE;
+            Channel_3_Output:=FALSE;
+            Channel_4_Output:=FALSE;
+            Channel_5_Output:=FALSE;
+            Channel_6_Output:=FALSE;
+            Channel_7_Output:=FALSE;
+            Channel_8_Output:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL2819

+
FUNCTION_BLOCK EL2819
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    bDo_1: BOOL;
+    bDo_2: BOOL;
+    bDo_3: BOOL;
+    bDo_4: BOOL;
+    bDo_5: BOOL;
+    bDo_6: BOOL;
+    bDo_7: BOOL;
+    bDo_8: BOOL;
+    bDo_9: BOOL;
+    bDo_10: BOOL;
+    bDo_11: BOOL;
+    bDo_12: BOOL;
+    bDo_13: BOOL;
+    bDo_14: BOOL;
+    bDo_15: BOOL;
+    bDo_16: BOOL;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO : BOOL;
+    bError : BOOL;
+END_VAR
+
+VAR
+    Channel_1_Output AT %Q*: BOOL;
+    Channel_2_Output AT %Q*: BOOL;
+    Channel_3_Output AT %Q*: BOOL;
+    Channel_4_Output AT %Q*: BOOL;
+    Channel_5_Output AT %Q*: BOOL;
+    Channel_6_Output AT %Q*: BOOL;
+    Channel_7_Output AT %Q*: BOOL;
+    Channel_8_Output AT %Q*: BOOL;
+    Channel_9_Output AT %Q*: BOOL;
+    Channel_10_Output AT %Q*: BOOL;
+    Channel_11_Output AT %Q*: BOOL;
+    Channel_12_Output AT %Q*: BOOL;
+    Channel_13_Output AT %Q*: BOOL;
+    Channel_14_Output AT %Q*: BOOL;
+    Channel_15_Output AT %Q*: BOOL;
+    Channel_16_Output AT %Q*: BOOL;
+
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL2819_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Channel diagnostic variables and device diag variables
+*)
+
+EnO:=En;
+
+EL2819_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError=FALSE THEN
+            Channel_1_Output:=bDo_1;
+            Channel_2_Output:=bDo_2;
+            Channel_3_Output:=bDo_3;
+            Channel_4_Output:=bDo_4;
+            Channel_5_Output:=bDo_5;
+            Channel_6_Output:=bDo_6;
+            Channel_7_Output:=bDo_7;
+            Channel_8_Output:=bDo_8;
+            Channel_9_Output:=bDo_9;
+            Channel_10_Output:=bDo_10;
+            Channel_11_Output:=bDo_11;
+            Channel_12_Output:=bDo_12;
+            Channel_13_Output:=bDo_13;
+            Channel_14_Output:=bDo_14;
+            Channel_15_Output:=bDo_15;
+            Channel_16_Output:=bDo_16;
+    ELSE
+            Channel_1_Output:=FALSE;
+            Channel_2_Output:=FALSE;
+            Channel_3_Output:=FALSE;
+            Channel_4_Output:=FALSE;
+            Channel_5_Output:=FALSE;
+            Channel_6_Output:=FALSE;
+            Channel_7_Output:=FALSE;
+            Channel_8_Output:=FALSE;
+            Channel_9_Output:=FALSE;
+            Channel_10_Output:=FALSE;
+            Channel_11_Output:=FALSE;
+            Channel_12_Output:=FALSE;
+            Channel_13_Output:=FALSE;
+            Channel_14_Output:=FALSE;
+            Channel_15_Output:=FALSE;
+            Channel_16_Output:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL3174_0002

+
//EL3174-0002 | 4-channel analog input, -10/0...+10V, -20/0/+4...20mA, 16 bit, differential
+FUNCTION_BLOCK EL3174_0002
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    iAi_Ch1_Value : INT;
+    iAi_Ch2_Value : INT;
+    iAi_Ch3_Value : INT;
+    iAi_Ch4_Value : INT;
+    bError: BOOL;
+END_VAR
+
+VAR
+    //Channels
+    AI_Std_Ch_1_Status      AT %I* : WORD;
+    AI_Std_Ch_1_Value       AT %I* : INT;
+    AI_Std_Ch_2_Status      AT %I* : WORD;
+    AI_Std_Ch_2_Value       AT %I* : INT;
+    AI_Std_Ch_3_Status      AT %I* : WORD;
+    AI_Std_Ch_3_Value       AT %I* : INT;
+    AI_Std_Ch_4_Status      AT %I* : WORD;
+    AI_Std_Ch_4_Value       AT %I* : INT;
+
+    //Terminal status
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL3174_0002_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Status words of the channels
+*)
+
+EnO := En;
+
+//Error FB instance
+EL3174_0002_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError = FALSE THEN
+            iAi_Ch1_Value := AI_Std_Ch_1_Value;
+            iAi_Ch2_Value := AI_Std_Ch_2_Value;
+            iAi_Ch3_Value := AI_Std_Ch_3_Value;
+            iAi_Ch4_Value := AI_Std_Ch_4_Value;
+    ELSE
+            iAi_Ch1_Value := 0;
+            iAi_Ch2_Value := 0;
+            iAi_Ch3_Value := 0;
+            iAi_Ch4_Value := 0;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL3214

+
//EL3214 | 4-channel analog input terminal, PT100 (RTD)
+FUNCTION_BLOCK EL3214
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    iAi_Ch1_Value : INT;
+    iAi_Ch2_Value : INT;
+    iAi_Ch3_Value : INT;
+    iAi_Ch4_Value : INT;
+    bError: BOOL;
+END_VAR
+
+VAR
+    //Channels
+    AI_RTD_Ch_1_Status      AT %I* : WORD;
+    AI_RTD_Ch_1_Value       AT %I* : INT;
+    AI_RTD_Ch_2_Status      AT %I* : WORD;
+    AI_RTD_Ch_2_Value       AT %I* : INT;
+    AI_RTD_Ch_3_Status      AT %I* : WORD;
+    AI_RTD_Ch_3_Value       AT %I* : INT;
+    AI_RTD_Ch_4_Status      AT %I* : WORD;
+    AI_RTD_Ch_4_Value       AT %I* : INT;
+
+    //Terminal status
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL3214_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Status words of the channels
+*)
+
+EnO := En;
+
+//Error FB instance
+EL3214_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF En THEN
+    IF bError = FALSE THEN
+            iAi_Ch1_Value := AI_RTD_Ch_1_Value;
+            iAi_Ch2_Value := AI_RTD_Ch_2_Value;
+            iAi_Ch3_Value := AI_RTD_Ch_3_Value;
+            iAi_Ch4_Value := AI_RTD_Ch_4_Value;
+    ELSE
+            iAi_Ch1_Value := 0;
+            iAi_Ch2_Value := 0;
+            iAi_Ch3_Value := 0;
+            iAi_Ch4_Value := 0;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL3255

+
//EL3255 | 5-channel potentiometer measurement with sensor supply
+FUNCTION_BLOCK EL3255
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO : BOOL;
+    Ch1_Value : INT;
+    Ch2_Value : INT;
+    Ch3_Value : INT;
+    Ch4_Value : INT;
+    Ch5_Value : INT;
+    bError : BOOL;
+END_VAR
+
+VAR
+    AI_Std_Ch1_Value AT %I* : INT;
+    AI_Std_Ch2_Value AT %I* : INT;
+    AI_Std_Ch3_Value AT %I* : INT;
+    AI_Std_Ch4_Value AT %I* : INT;
+    AI_Std_Ch5_Value AT %I* : INT;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL3255_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Channel Status words
+*)
+
+EnO:=En;
+
+//Error FB instance
+EL3255_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF EN THEN
+    IF NOT bError THEN
+            Ch1_Value := AI_Std_Ch1_Value;
+            Ch2_Value := AI_Std_Ch2_Value;
+            Ch3_Value := AI_Std_Ch3_Value;
+            Ch4_Value := AI_Std_Ch4_Value;
+            Ch5_Value := AI_Std_Ch5_Value;
+    ELSE
+            Ch1_Value := 0;
+            Ch2_Value := 0;
+            Ch3_Value := 0;
+            Ch4_Value := 0;
+            Ch5_Value := 0;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL5002

+
//EL5002 | 2-chennel SSI absolute encoder terminal
+FUNCTION_BLOCK EL5002
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    Ch1_Counter_Value : UDINT;
+    Ch2_Counter_Value : UDINT;
+    bError: BOOL;
+END_VAR
+
+VAR
+    udi_Ch1_Cnt_Value AT %I* : UDINT;
+    udi_Ch2_Cnt_Value AT %I* : UDINT;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL5002_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Channel Status words
+*)
+
+EnO:=En;
+
+//Error FB instance
+EL5002_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF EN THEN
+    IF NOT bError THEN
+            Ch1_Counter_Value := udi_Ch1_Cnt_Value;
+            Ch2_Counter_Value := udi_Ch2_Cnt_Value;
+    ELSE
+            Ch1_Counter_Value := 0;
+            Ch2_Counter_Value := 0;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL5021

+
//EL5021 | 1-channel Sin/Cos encoder
+FUNCTION_BLOCK EL5021
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    Counter_Value : UDINT;
+    Latch_Value : UDINT;
+    bError: BOOL;
+END_VAR
+
+VAR
+    udiCounter_Value AT %I* : UDINT;
+    udiLatch_Value AT %I* : UDINT;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL5021_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Channel Status words, control words
+*)
+
+EnO:=En;
+
+//Error FB instance
+EL5021_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF EN THEN
+    IF NOT bError THEN
+            Counter_Value := udiCounter_Value;
+            Latch_Value := udiLatch_Value;
+    ELSE
+            Counter_Value := 0;
+            Latch_Value := 0;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL5042

+
//EL5042 | 2-channel BiSS-C absolute encoder terminal
+FUNCTION_BLOCK EL5042
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    Ch1_Position : ULINT;
+    Ch2_Position : ULINT;
+    bError: BOOL;
+END_VAR
+
+VAR
+    FB_Inputs_ch1_Position AT %I* : ULINT;
+    FB_Inputs_ch2_Position AT %I* : ULINT;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL5042_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Channel Status words
+*)
+
+EnO:=En;
+
+//Error FB instance
+EL5042_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF EN THEN
+    IF NOT bError THEN
+            Ch1_Position := FB_Inputs_ch1_Position;
+            Ch2_Position := FB_Inputs_ch2_Position;
+    ELSE
+            Ch1_Position := 0;
+            Ch2_Position := 0;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL5101

+
// EL5101 | 1-channel incremental encoder terminal, 5V, RS422
+FUNCTION_BLOCK EL5101
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    Counter_Value : UINT;
+    Latch_Value : UINT;
+    bError: BOOL;
+END_VAR
+
+VAR
+    uiCounter_Value AT %I* : UINT;
+    uiLatch_Value AT %I* : UINT;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL5101_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Channel Status word, control words
+*)
+
+EnO:=En;
+
+//Error FB instance
+EL5101_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+IF EN THEN
+    IF NOT bError THEN
+            Counter_Value := uiCounter_Value;
+            Latch_Value := uiLatch_Value;
+    ELSE
+            Counter_Value := 0;
+            Latch_Value := 0;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL7211_v1_00

+
///EL7211 | Servo motor termional 5 A
+FUNCTION_BLOCK EL7211_v1_00
+VAR_INPUT
+    En: BOOL;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+
+    bError: BOOL;
+END_VAR
+VAR
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+END_VAR
+EnO:=En;
+
+IF En AND (WcState_WcState OR InfoData_State<>16#8) THEN
+    bError:=TRUE;
+ELSE
+    bError:=FALSE;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
+

EL9410

+
//EL9410 | E-Bus power supplier and refresher, diagnostics
+FUNCTION_BLOCK EL9410
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    bError: BOOL;
+END_VAR
+
+VAR
+    bStatus_Us_UV AT %I* : BOOL;
+    bStatus_Up_UV AT %I* : BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL9410_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Status bits
+*)
+
+EnO:=En;
+
+//Error FB instance
+EL9410_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL9505

+
//EL9505 | Power supply terminal 5V
+FUNCTION_BLOCK EL9505
+
+VAR_INPUT
+    En: BOOL;
+    iTerminal_ID : INT;
+    ErrorSystem : POINTER TO ST_ErrorSystem;
+END_VAR
+
+VAR_OUTPUT
+    EnO: BOOL;
+    bError: BOOL;
+END_VAR
+
+VAR
+    bStatus_Uo_Power_OK AT %I* : BOOL;
+    bStatus_Uo_Overload AT %I* : BOOL;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+    //FB-s
+    EL9505_Error : FB_TerminalError;
+END_VAR
+(*
+* TODO:
+* Status bits
+*)
+EnO:=En;
+
+//Error FB instance
+EL9505_Error(
+    En := TRUE,
+    iTerminal_ID := iTerminal_ID,
+    bWcState := WcState_WcState,
+    uiInfoData_State := InfoData_State,
+    pErrorSystem := ErrorSystem,
+    bError => bError,
+);
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

EL9576_v1_00

+
///EL9576 | Brake terminal (vap and resistor)
+FUNCTION_BLOCK EL9576_v1_00
+VAR_INPUT
+    En: BOOL;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bError: BOOL;
+    OverTemperature: BOOL;
+    I2TError : BOOL;
+    I2TWarning : BOOL;
+    OverVoltage  : BOOL;
+    UnderVoltage : BOOL;
+    ChopperOn : BOOL;
+    DCLinkVoltage : LREAL;
+    DutyCycle  : LREAL;
+    ResistorCurrent : LREAL;
+
+END_VAR
+VAR
+    BCTOverTemperature AT %I*: BOOL;
+    BCTI2TError AT %I*: BOOL;
+    BCTI2TWarning AT %I*: BOOL;
+    BCTOverVoltage  AT %I*: BOOL;
+    BCTUnderVoltage  AT %I*: BOOL;
+    BCTChopperOn  AT %I*: BOOL;
+    BCTDCLinkVoltage AT %I*: UDINT;
+    BCTDutyCycle  AT %I*: USINT;
+    BCTResistorCurrent AT %I*: UDINT;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+
+END_VAR
+EnO:=En;
+
+IF En AND (WcState_WcState OR InfoData_State<>16#8 OR BCTI2TError OR BCTI2TWarning OR BCTOverTemperature OR BCTOverVoltage OR BCTUnderVoltage) THEN
+    bError:=TRUE;
+ELSE
+    bError:=FALSE;
+END_IF
+
+OverTemperature:=BCTOverTemperature;
+I2TError:=BCTI2TError;
+I2TWarning:=BCTI2TWarning;
+OverVoltage:=BCTOverVoltage;
+UnderVoltage:=bctUnderVoltage;
+ChopperOn:=bctChopperOn;
+DCLinkVoltage:=UDINT_TO_LREAL(bctDCLinkVoltage);
+DutyCycle:=USINT_TO_LREAL(BCTDutyCycle);
+ResistorCurrent:=UDINT_TO_LREAL(BCTResistorCurrent);
+
+END_FUNCTION_BLOCK
+
+
+
+
+

F_AtPositionState

+
FUNCTION F_AtPositionState : BOOL
+(*
+    Check if the motor is within the state bounds
+    This will only run properly if FB_PositionStateInternal has been called on the position state to initialize it.
+*)
+VAR_INPUT
+    stMotionStage: ST_MotionStage;
+    stPositionState: ST_PositionState;
+END_VAR
+// If state is defined, we are within the delta, and we are either not moving or our destination is within the delta, we are at the state
+F_AtPositionState := stPositionState.bValid AND stPositionState.bUpdated
+                     AND F_PosWithinDelta(stMotionStage.stAxisStatus.fActPosition, stPositionState)
+                     AND ((NOT stMotionStage.bExecute) OR F_PosWithinDelta(stMotionStage.fPosition, stPositionState));
+
+END_FUNCTION
+
+
+
+
Related:
+
+
+
+
+

F_MotionErrorCodeLookup

+
FUNCTION F_MotionErrorCodeLookup : STRING
+VAR_INPUT
+    nErrorId: UDINT;
+END_VAR
+VAR
+    msg: STRING;
+END_VAR
+CASE nErrorId OF
+    // Common NC errors
+    16#4221: msg:='Requested set velocity is not allowed';
+    16#4222: msg:='Requested set position is not allowed';
+    16#4223: msg:='No enable for controller and/or feed';
+    16#4225: msg:='Drive not ready during axis start';
+    16#4260: msg:='Drive disabled';
+    16#42A0: msg:='Coupled axis error';
+    16#4357: msg:='Negative limit hit';
+    16#4358: msg:='Positive limit hit';
+    16#4395: msg:='Set velocity not allowed';
+    16#4550: msg:='Stall: position lag monitoring error';
+    16#4650: msg:='Drive hardware not ready to operate';
+    16#4655: msg:='Invalid IO data';
+    16#4467: msg:='Encoder error: invalid actual position data';
+    16#4B07: msg:='Timeout axis function block after 6 seconds';
+    16#4FFF: msg:='Unknown NC error (not in manual)';
+
+    // Custom error definitions
+    16#7900: msg:='Aborted move request with active move in progress';
+    16#7901: msg:='Position state unsafe';
+    16#7902: msg:='Position state invalid';
+    16#FFFF: msg:='Fake testing error';
+
+    // Fallbacks
+    0: msg:='';
+    ELSE
+        msg:='Contact PCDS to add new message';
+END_CASE
+F_MotionErrorCodeLookup := msg;
+
+END_FUNCTION
+
+
+
+
+

F_PosOverLowerBound

+
FUNCTION F_PosOverLowerBound : BOOL
+VAR_INPUT
+    fPosition: LREAL;
+    stPositionState: ST_PositionState;
+END_VAR
+F_PosOverLowerBound := fPosition > (stPositionState.fPosition - ABS(stPositionState.fDelta));
+
+END_FUNCTION
+
+
+
+
Related:
+
+
+
+
+

F_PosUnderUpperBound

+
FUNCTION F_PosUnderUpperBound : BOOL
+VAR_INPUT
+    fPosition: LREAL;
+    stPositionState: ST_PositionState;
+END_VAR
+F_PosUnderUpperBound := fPosition < (stPositionState.fPosition + ABS(stPositionState.fDelta));
+
+END_FUNCTION
+
+
+
+
Related:
+
+
+
+
+

F_PosWithinDelta

+
FUNCTION F_PosWithinDelta : BOOL
+VAR_INPUT
+    fPosition: LREAL;
+    stPositionState: ST_PositionState;
+END_VAR
+F_PosWithinDelta := F_PosOverLowerBound(fPosition, stPositionState) AND
+                    F_PosUnderUpperBound(fPosition, stPositionState);
+
+END_FUNCTION
+
+
+
+
Related:
+
+
+
+
+

FB_AtPositionState_Test

+
FUNCTION_BLOCK FB_AtPositionState_Test EXTENDS TcUnit.FB_TestSuite
+(*
+    Test the following related helper functions:
+    - F_PosOverLowerBound
+    - F_PosUnderUpperBound
+    - F_PosWithinDelta
+    - F_AtPositionState
+*)
+VAR
+    // For the multi-cycle tests
+    stMotionStage: ST_MotionStage;
+    fbMotionStage: FB_MotionStage;
+    fbTestMove: FB_TestHelperSetAndMove;
+    stPositionStateInactive: ST_PositionState;
+    stPositionStateInvalid: ST_PositionState;
+    stPositionStateGood: ST_PositionState;
+    tonInactive: TON;
+    fbInternalGood: FB_PositionStateInternal;
+    fbInternalInvalid: FB_PositionStateInternal;
+    nTestCounter: UINT;
+    bOneTestDone: BOOL;
+END_VAR
+// Single cycle tests
+TestPosOverLowerBoundYes();
+TestPosOverLowerBoundNo();
+TestPosUnderUpperBoundYes();
+TestPosUnderUpperBoundNo();
+TestPosWithinDeltaTooLow();
+TestPosWithinDeltaTooHigh();
+TestPosWithinDeltaJustRight();
+
+// Multi cycle tests
+fbMotionStage(stMotionStage:=stMotionStage);
+stPositionStateInactive.sName := 'Inactive';
+stPositionStateInactive.fPosition := 30.0;
+stPositionStateInactive.fDelta := 1.0;
+stPositionStateInactive.bValid := TRUE;
+tonInactive(
+    IN:=TRUE,
+    PT:=T#1s,
+);
+TestAtPositionStateWithoutInternal();
+
+stPositionStateInvalid.sName := 'Invalid';
+stPositionStateInvalid.fPosition := 40.0;
+stPositionStateInvalid.fDelta := 1.0;
+stPositionStateInvalid.bValid := FALSE;
+fbInternalInvalid(
+    stMotionStage:=stMotionStage,
+    stPositionState:=stPositionStateInvalid,
+);
+TestAtPositionStateInvalid();
+
+stPositionStateGood.sName := 'Good';
+stPositionStateGood.fPosition := 50.0;
+stPositionStateGood.fDelta := 1.0;
+stPositionStateGood.bValid := TRUE;
+fbInternalGood(
+    stMotionStage:=stMotionStage,
+    stPositionState:=stPositionStateGood,
+);
+TestAtPositionStateTooLow();
+TestAtPositionStateTooHigh();
+TestAtPositionStateJustRight();
+TestAtPositionStateTweak();
+TestAtPositionStateLeave();
+
+IF bOneTestDone THEN
+    bOneTestDone := FALSE;
+    nTestCounter := nTestCounter + 1;
+    fbTestMove(
+        stMotionStage:=stMotionStage,
+        bExecute:=FALSE,
+    );
+END_IF
+
+END_FUNCTION_BLOCK
+
+METHOD PRIVATE TestAtPositionStateInvalid
+(*
+    If a position state is invalid, it is never the right state.
+*)
+VAR
+
+END_VAR
+TEST('TestAtPositionStateInvalid');
+IF nTestCounter <> 1 THEN
+    RETURN;
+END_IF
+
+fbTestMove(
+    stMotionStage:=stMotionstage,
+    bExecute:=TRUE,
+    fStartPosition:=stPositionStateInvalid.fPosition,
+    fGoalPosition:=stPositionStateInvalid.fPosition,
+);
+IF fbTestMove.tElapsed > T#1s OR (stPositionStateInvalid.bUpdated AND fbTestMove.bSetDone) THEN
+    AssertFalse(
+        Condition:=F_AtPositionState(
+            stMotionStage:=stMotionStage,
+            stPositionState:=stPositionStateInvalid,
+        ),
+        Message:='Invalid state was marked OK',
+    );
+    AssertFalse(
+        Condition:=fbTestMove.tElapsed > T#1s,
+        Message:='Timeout in multi cycle test',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestAtPositionStateJustRight
+VAR
+    fLocalGoal: LREAL;
+END_VAR
+TEST('TestAtPositionStateJustRight');
+IF nTestCounter <> 4 THEN
+    RETURN;
+END_IF
+
+fLocalGoal := stPositionStateGood.fPosition + 0.2*stPositionStateGood.fDelta;
+fbTestMove(
+    stMotionStage:=stMotionstage,
+    bExecute:=TRUE,
+    fStartPosition:=fLocalGoal,
+    fGoalPosition:=fLocalGoal,
+);
+IF fbTestMove.tElapsed > T#1s OR (stPositionStateGood.bUpdated AND fbTestMove.bSetDone) THEN
+    AssertTrue(
+        Condition:=F_AtPositionState(
+            stMotionStage:=stMotionStage,
+            stPositionState:=stPositionStateGood,
+        ),
+        Message:='Within delta counted as outside range',
+    );
+    AssertFalse(
+        Condition:=fbTestMove.tElapsed > T#1s,
+        Message:='Timeout in multi cycle test',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestAtPositionStateLeave
+(*
+    A move away from a state should be not at the state, even before we've left
+*)
+VAR
+END_VAR
+TEST('TestAtPositionStateLeave');
+IF nTestCounter <> 6 THEN
+    RETURN;
+END_IF
+
+fbTestMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=TRUE,
+    fStartPosition:=stPositionStateGood.fPosition,
+    fGoalPosition:=stPositionStateGood.fPosition + 100 * stPositionStateGood.fDelta,
+    fVelocity:=0.001,
+    bHWEnable:=TRUE,
+);
+
+IF fbTestMove.tElapsed > T#5s OR (stPositionStateGood.bUpdated AND fbTestMove.bMotionStarted) THEN
+    AssertTrue(
+        Condition:=fbTestMove.fActPosition < stPositionStateGood.fPosition + stPositionStateGood.fDelta,
+        Message:='We must be at the state location still to properly run this test.',
+    );
+    AssertFalse(
+        Condition:=F_AtPositionState(
+            stMotionStage:=stMotionStage,
+            stPositionState:=stPositionStateGood,
+        ),
+        Message:='Leaving state is not at state once the move starts',
+    );
+    AssertFalse(
+        Condition:=fbTestMove.tElapsed > T#5s,
+        Message:='Timeout in multi cycle test',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestAtPositionStateTooHigh
+VAR
+    fLocalGoal: LREAL;
+END_VAR
+TEST('TestAtPositionStateTooHigh');
+IF nTestCounter <> 3 THEN
+    RETURN;
+END_IF
+
+fLocalGoal := stPositionStateGood.fPosition + 2*stPositionStateGood.fDelta;
+fbTestMove(
+    stMotionStage:=stMotionstage,
+    bExecute:=TRUE,
+    fStartPosition:=fLocalGoal,
+    fGoalPosition:=fLocalGoal,
+);
+IF fbTestMove.tElapsed > T#1s OR (stPositionStateGood.bUpdated AND fbTestMove.bSetDone) THEN
+    AssertFalse(
+        Condition:=F_AtPositionState(
+            stMotionStage:=stMotionStage,
+            stPositionState:=stPositionStateGood,
+        ),
+        Message:='Above delta counted as in range',
+    );
+    AssertFalse(
+        Condition:=fbTestMove.tElapsed > T#1s,
+        Message:='Timeout in multi cycle test',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestAtPositionStateTooLow
+VAR
+    fLocalGoal: LREAL;
+END_VAR
+TEST('TestAtPositionStateTooLow');
+IF nTestCounter <> 2 THEN
+    RETURN;
+END_IF
+
+fLocalGoal := stPositionStateGood.fPosition - 2*stPositionStateGood.fDelta;
+fbTestMove(
+    stMotionStage:=stMotionstage,
+    bExecute:=TRUE,
+    fStartPosition:=fLocalGoal,
+    fGoalPosition:=fLocalGoal,
+);
+IF fbTestMove.tElapsed > T#1s OR (stPositionStateGood.bUpdated AND fbTestMove.bSetDone) THEN
+    AssertFalse(
+        Condition:=F_AtPositionState(
+            stMotionStage:=stMotionStage,
+            stPositionState:=stPositionStateGood,
+        ),
+        Message:='Below delta counted as in range',
+    );
+    AssertFalse(
+        Condition:=fbTestMove.tElapsed > T#1s,
+        Message:='Timeout in multi cycle test',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestAtPositionStateTweak
+(*
+    A small tweak move within the delta of a position state should be OK
+*)
+VAR
+
+END_VAR
+TEST('TestAtPositionStateTweak');
+IF nTestCounter <> 5 THEN
+    RETURN;
+END_IF
+
+fbTestMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=TRUE,
+    fStartPosition:=stPositionStateGood.fPosition,
+    fGoalPosition:=stPositionStateGood.fPosition + 0.9 * stPositionStateGood.fDelta,
+    fVelocity:=0.001,
+    bHWEnable:=TRUE,
+);
+
+IF fbTestMove.tElapsed > T#5s OR (stPositionStateGood.bUpdated AND fbTestMove.bMotionStarted) THEN
+    AssertTrue(
+        Condition:=F_AtPositionState(
+            stMotionStage:=stMotionStage,
+            stPositionState:=stPositionStateGood,
+        ),
+        Message:='Small tweak in range should count as at state',
+    );
+    AssertFalse(
+        Condition:=fbTestMove.tElapsed > T#5s,
+        Message:='Timeout in multi cycle test',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestAtPositionStateWithoutInternal
+(*
+    If a position state is never updated by the internal FB, it is never the right state.
+*)
+VAR
+
+END_VAR
+TEST('TestAtPositionStateWithoutInternal');
+IF nTestCounter <> 0 THEN
+    RETURN;
+END_IF
+
+fbTestMove(
+    stMotionStage:=stMotionstage,
+    bExecute:=TRUE,
+    fStartPosition:=stPositionStateInactive.fPosition,
+    fGoalPosition:=stPositionStateInactive.fPosition,
+);
+IF fbTestMove.tElapsed > T#1s OR (stPositionStateInvalid.bUpdated AND fbTestMove.bSetDone) THEN
+    // Check for a different state to be bUpdated for timing purposes, this one never gets bUpdated
+    AssertFalse(
+        Condition:=F_AtPositionState(
+            stMotionStage:=stMotionStage,
+            stPositionState:=stPositionStateInactive,
+        ),
+        Message:='This is the control group, internal was not run so this should not work',
+    );
+    AssertFalse(
+        Condition:=fbTestMove.tElapsed > T#1s,
+        Message:='Timeout in multi cycle test',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestPosOverLowerBoundNo
+VAR
+    stPositionState: ST_PositionState;
+END_VAR
+TEST('TestPosOverLowerBoundNo');
+stPositionState.fPosition := 10;
+stPositionState.fDelta := 1;
+
+AssertFalse(
+    Condition:=F_PosOverLowerBound(
+        fPosition:=8.5,
+        stPositionState:=stPositionState,
+    ),
+    Message:='Decided 8.5 > 9.0',
+);
+TEST_FINISHED();
+END_METHOD
+
+METHOD PRIVATE TestPosOverLowerBoundYes
+VAR
+    stPositionState: ST_PositionState;
+END_VAR
+TEST('TestPosOverLowerBoundYes');
+stPositionState.fPosition := 10;
+stPositionState.fDelta := 1;
+
+AssertTrue(
+    Condition:=F_PosOverLowerBound(
+        fPosition:=9.1,
+        stPositionState:=stPositionState,
+    ),
+    Message:='Decided 9.0 > 9.1',
+);
+TEST_FINISHED();
+END_METHOD
+
+METHOD PRIVATE TestPosUnderUpperBoundNo
+VAR
+    stPositionState: ST_PositionState;
+END_VAR
+TEST('TestPosUnderUpperBoundNo');
+stPositionState.fPosition := 10;
+stPositionState.fDelta := 1;
+
+AssertFalse(
+    Condition:=F_PosUnderUpperBound(
+        fPosition:=12.0,
+        stPositionState:=stPositionState,
+    ),
+    Message:='Decided 11.0 > 12.0',
+);
+TEST_FINISHED();
+END_METHOD
+
+METHOD PRIVATE TestPosUnderUpperBoundYes
+VAR
+    stPositionState: ST_PositionState;
+END_VAR
+TEST('TestPosUnderUpperBoundYes');
+stPositionState.fPosition := 10;
+stPositionState.fDelta := 1;
+
+AssertTrue(
+    Condition:=F_PosUnderUpperBound(
+        fPosition:=10.9,
+        stPositionState:=stPositionState,
+    ),
+    Message:='Decided 10.9 > 11.0',
+);
+TEST_FINISHED();
+END_METHOD
+
+METHOD PRIVATE TestPosWithinDeltaJustRight
+VAR
+    stPositionState: ST_PositionState;
+END_VAR
+TEST('TestPosWithinDeltaJustRight');
+stPositionState.fPosition := 20;
+stPositionState.fDelta := 1;
+
+AssertTrue(
+    Condition:=F_PosWithinDelta(
+        fPosition:=20.2,
+        stPositionState:=stPositionState,
+    ),
+    Message:='Decided 20.2 not within 19 to 21 bounds',
+);
+TEST_FINISHED();
+END_METHOD
+
+METHOD PRIVATE TestPosWithinDeltaTooHigh
+VAR
+    stPositionState: ST_PositionState;
+END_VAR
+TEST('TestPosWithinDeltaTooHigh');
+stPositionState.fPosition := 20;
+stPositionState.fDelta := 1;
+
+AssertFalse(
+    Condition:=F_PosWithinDelta(
+        fPosition:=25.0,
+        stPositionState:=stPositionState,
+    ),
+    Message:='Decided 21.0 > 25.0',
+);
+TEST_FINISHED();
+END_METHOD
+
+METHOD PRIVATE TestPosWithinDeltaTooLow
+VAR
+    stPositionState: ST_PositionState;
+END_VAR
+TEST('TestPosWithinDeltaTooLow');
+stPositionState.fPosition := 20;
+stPositionState.fDelta := 1;
+
+AssertFalse(
+    Condition:=F_PosWithinDelta(
+        fPosition:=12.0,
+        stPositionState:=stPositionState,
+    ),
+    Message:='Decided 12.0 > 19.0',
+);
+TEST_FINISHED();
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_CalculateFrequency_3702_v0_01

+
FUNCTION_BLOCK FB_CalculateFrequency_3702_v0_01
+VAR CONSTANT
+    ///200 samples/period
+    cBufferSize: INT := 1000;
+END_VAR
+VAR_INPUT
+    En: BOOL;
+    bCalculate: BOOL;
+    aBufferValue: ARRAY[0..(cBuffersize - 1)] OF INT;
+    aBufferDcTime: ARRAY[0..(cBuffersize - 1)] OF UDINT;
+    ///If curve has a DC offset
+    nDCOffset: INT := 0;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bError: BOOL;
+    fActFrequency: LREAL;
+END_VAR
+VAR
+    nIndex: INT;
+    nFirstZeroCrossing: INT;
+    nLastZeroCrossing: INT;
+    rTimeFirst: REAL := 0;
+    rTimeLast: REAL := 0;
+    rTimeRes: REAL := 0;
+    nCrossings: INT := 0;
+END_VAR
+VAR_TEMP
+    rRange: REAL := 0;
+    rTimeSpan: REAL := 0;
+END_VAR
+EnO:=En;
+bError:=FALSE;
+nCrossings:=0;
+IF En AND bCalculate THEN
+    //Serach for crossings of nDCOffset
+    FOR nIndex:=1 TO cBuffersize-1 DO
+            IF((aBufferValue[nIndex]>nDCOffset AND aBufferValue[nIndex-1]<=nDCOffset) OR (aBufferValue[nIndex]<nDCOffset AND aBufferValue[nIndex-1]>=nDCOffset))    THEN
+                    IF(nCrossings=0) THEN
+                            nFirstZeroCrossing:=nIndex;
+                    END_IF
+                    nLastZeroCrossing:=nIndex;
+                    nCrossings:=nCrossings+1;
+            END_IF
+    END_FOR
+
+    IF nFirstZeroCrossing < nLastZeroCrossing  AND  nCrossings>2 THEN
+            //interpolate zero crossings for higher accuracy
+            rTimeRes:=UDINT_TO_REAL(aBufferDcTime[1]-aBufferDcTime[0]); //Buffer must contain more than 2 values
+            rRange:=INT_TO_REAL(ABS(aBufferValue[nFirstZeroCrossing-1]-aBufferValue[nFirstZeroCrossing]));
+            rTimeFirst:=UDINT_TO_REAL( aBufferDcTime[nFirstZeroCrossing-1])+ABS(INT_TO_REAL(aBufferValue[nFirstZeroCrossing-1])/rRange*rTimeRes);
+            rRange:=INT_TO_REAL(ABS(aBufferValue[nLastZeroCrossing-1]-aBufferValue[nLastZeroCrossing]));
+            rTimeLast:=UDINT_TO_REAL( aBufferDcTime[nLastZeroCrossing-1])+ABS(INT_TO_REAL(aBufferValue[nLastZeroCrossing-1])/rRange*rTimeRes);
+
+            //Time span first to last (considering that max one time counter overflow have occured in the total time range of the time buffer)
+            IF rTimeFirst<rTimeLast THEN
+                    rTimeSpan:=rTimeLast-rTimeFirst;
+            ELSE //overflow of counter once (only 32bit timestamp =4.29seconds)
+                    rTimeSpan:=4294967296.0-rTimeFirst+rTimeLast;
+            END_IF
+
+            fActFrequency:=1000000000.0/rTimeSpan*(nCrossings-1)/2; //two crossings per period => Average frequency over buffer.
+    ELSE
+            fActFrequency:=0;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_CauseNCError

+
FUNCTION_BLOCK FB_CauseNCError
+(*
+    Simulate an NC error.
+    This will look like a real NC error for everyone, including TwinCAT itself.
+*)
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_INPUT
+    bExecute: BOOL;
+    nErrorCode: UDINT;
+END_VAR
+VAR_OUTPUT
+    bBusy: BOOL;
+    bDone: BOOL;
+END_VAR
+VAR
+    rtExec: R_TRIG;
+    adsWrite: ADSWRITE;
+    mcReadDriveAddress: MC_ReadDriveAddress;
+END_VAR
+rtExec(CLK:=bExecute);
+IF NOT bExecute THEN
+    bDone := FALSE;
+END_IF
+IF rtExec.Q THEN
+    bBusy := TRUE;
+END_IF
+IF bBusy AND NOT mcReadDriveAddress.Done THEN
+    mcReadDriveAddress(
+        Axis:=Axis,
+        Execute:=TRUE,
+        DriveAddress=>Axis.DriveAddress);
+END_IF
+IF bBusy AND mcReadDriveAddress.Done THEN
+    bBusy := TRUE;
+    adsWrite(
+        PORT:=501,
+        IDXGRP:=16#4200 + Axis.DriveAddress.NcDriveId,
+        IDXOFFS:=16#0019,
+        LEN:=SIZEOF(nErrorCode),
+        SRCADDR:=ADR(nErrorCode),
+        WRITE:=TRUE,
+        BUSY=>bBusy);
+    IF NOT bBusy THEN
+        bDone := TRUE;
+        adsWrite(WRITE:=FALSE);
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_DriveVirtual

+
///#########################################################
+///Function block to run a virtual drive with Nc
+/// Library:
+/// Tc2_MC2.lib
+///
+/// Global Variables:
+///
+/// Data types:
+///
+/// External functions:
+///
+///###########################################################
+FUNCTION_BLOCK FB_DriveVirtual
+VAR
+    sVersion: STRING:='1.0.3';
+END_VAR
+VAR_INPUT
+    En: BOOL;
+    bEnable: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+    /////   nCommandLocal...
+    /////   0 = Jog
+    /////   1 = MoveVelocity
+    /////   2 = MoveRelative
+    /////   3 = MoveAbsolut
+    /////   4 = MoveModulo
+    /////   10 = Homing
+    /////   20 = SuperInp >>>ToBe
+    /////   30 = Gear
+    nCommand: UINT;
+    nCmdData: UINT;
+    fVelocity: LREAL;
+    fPosition: LREAL;
+    fAcceleration: LREAL;
+    fDeceleration: LREAL;
+    bJogFwd: BOOL;
+    bJogBwd: BOOL;
+    bLimitFwd: BOOL;
+    bLimitBwd: BOOL;
+    fOverride: LREAL := 100;
+    bHomeSensor: BOOL;
+    fHomePosition:LREAL;
+    nHomeRevOffset: UINT;
+    MasterAxis: AXIS_REF;
+    bPowerSelf: BOOL;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bEnabled: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    bHomed: BOOL;
+    nErrorId: UDINT;
+    nMotionAxisID:UDINT:=0;  //Axis id in Motion (NC)
+    Status: ST_AxisStatus;
+    fActVelocity: LREAL;
+    fActPosition: LREAL;
+    fActDiff: LREAL;
+    sErrorMessage:STRING;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR
+    nCommandLocal: UINT;
+    nCmdDataLocal: UINT;
+    bFirstScan: BOOL := TRUE;
+    fbReset: MC_Reset;
+    fbPower: MC_Power;
+    fbHalt: MC_Halt;
+    fbJog: MC_Jog;
+    fbMoveVelocity: MC_MoveVelocity;
+    fbMoveRelative: MC_MoveRelative;
+    fbMoveAbsolute: MC_MoveAbsolute;
+    fbMoveModulo: MC_MoveModulo;
+    fbHomeVirtual:FB_HomeVirtual;
+    fbGearInDyn: MC_GearInDyn;
+    fbGearOut: MC_GearOut;
+    fbExecuteRiseEdge: R_TRIG;
+    stAxisStatus: DUT_AxisStatus_v0_01;
+END_VAR
+EnO:=En;
+
+// Transfer nCommand and nCmdData to local copies at rising edge of bExecute (avoid issues if nCommand or nCmdData are changed during a command)
+fbExecuteRiseEdge(CLK:=bExecute);
+IF fbExecuteRiseEdge.Q THEN
+  nCmdDataLocal:=nCmdData;
+  nCommandLocal:=nCommand;
+END_IF
+
+bHomed:=fbHomeVirtual.bHomed; //Add in DUT_AxisStatus later
+bDone:=FALSE;
+
+(*Reset*)
+fbReset(
+    Execute:=bReset AND Axis.Status.Error,
+    Axis:=Axis,
+    Done=> ,
+    Busy=> ,
+    Error=> ,
+    ErrorID=> );
+
+(*Power*)
+IF bPowerSelf THEN
+fbPower(
+    Axis:=Axis,
+    Enable:=bEnable,
+    Enable_Positive:=bEnable AND bLimitFwd,
+    Enable_Negative:=bEnable AND bLimitBwd,
+    Override:=fOverride,
+    BufferMode:= ,
+    Status=> ,
+    Busy=> ,
+    Active=> ,
+    Error=> ,
+    ErrorID=> );
+END_IF
+
+(*Halt*)
+fbHalt(
+    Execute:=NOT bExecute  AND (((fbMoveVelocity.Busy OR fbPower.Busy) AND (nCommandLocal=1)) OR (fbMoveRelative.Busy AND (nCommandLocal=2)) OR (fbMoveAbsolute.Busy AND (nCommandLocal=3)) OR (fbMoveModulo.Busy AND (nCommandLocal=4)) OR (fbHomeVirtual.bBusy AND (nCommandLocal=10))),
+    Deceleration:=fDeceleration,
+    Jerk:=0,
+    BufferMode:= ,
+    Options:= ,
+    Axis:=Axis ,
+    Done=> ,
+    Busy=> ,
+    Active=> ,
+    CommandAborted=> ,
+    Error=> ,
+    ErrorID=> );
+
+(*Jog (Command = 0)*)
+fbJog(
+    JogForward:=bJogFwd AND (nCommandLocal=0) ,
+    JogBackwards:=bJogBwd AND (nCommandLocal=0) ,
+    Mode:=UINT_TO_INT(nCmdDataLocal),
+    Position:= ,
+    Velocity:=fVelocity,
+    Acceleration:=fAcceleration,
+    Deceleration:=fDeceleration,
+    Jerk:=0,
+    Axis:=Axis,
+    Done=> ,
+    Busy=> ,
+    Active=> ,
+    CommandAborted=> ,
+    Error=> ,
+    ErrorID=> );
+
+(*MoveVelocity (Command = 1)*)
+fbMoveVelocity(
+    Execute:=bExecute AND (nCommandLocal=1),
+    Velocity:=ABS(fVelocity),
+    Acceleration:=fAcceleration,
+    Deceleration:=fDeceleration,
+    Jerk:=0,
+    Direction:=SEL(fVelocity<0, MC_Positive_Direction, MC_Negative_Direction),
+    BufferMode:= ,
+    Options:= ,
+    Axis:=Axis,
+    InVelocity=> ,
+    Busy=> ,
+    Active=> ,
+    CommandAborted=> ,
+    Error=> ,
+    ErrorID=> );
+
+(*MoveRelative (Command = 2)*)
+fbMoveRelative(
+    Execute:=bExecute AND (nCommandLocal=2),
+    Distance:=fPosition,
+    Velocity:=ABS(fVelocity),
+    Acceleration:=fAcceleration,
+    Deceleration:=fDeceleration,
+    Jerk:=0,
+    BufferMode:= ,
+    Options:= ,
+    Axis:=Axis,
+    Done=> ,
+    Busy=> ,
+    Active=> ,
+    CommandAborted=> ,
+    Error=> ,
+    ErrorID=> );
+
+IF nCommandLocal=2 THEN
+    bDone:=fbMoveRelative.Done;
+END_IF
+
+(*MoveAbsolute (Command = 3)*)
+fbMoveAbsolute(
+    Execute:=bExecute AND (nCommandLocal=3),
+    Position:=fPosition,
+    Velocity:=ABS(fVelocity),
+    Acceleration:=fAcceleration,
+    Deceleration:=fDeceleration,
+    Jerk:=0,
+    BufferMode:= ,
+    Options:= ,
+    Axis:=Axis,
+    Done=> ,
+    Busy=> ,
+    Active=> ,
+    CommandAborted=> ,
+    Error=> ,
+    ErrorID=> );
+
+IF nCommandLocal=3 THEN
+    bDone:=fbMoveAbsolute.Done;
+END_IF
+
+(*MoveModulo (Command = 4)*)
+fbMoveModulo(
+    Execute:=bExecute AND (nCommandLocal=4),
+    Position:=fPosition,
+    Velocity:=ABS(fVelocity),
+    Acceleration:=fAcceleration,
+    Deceleration:=fDeceleration,
+    Jerk:=0,
+    Direction:=UINT_TO_INT(nCmdDataLocal),
+    BufferMode:= ,
+    Options:= ,
+    Axis:=Axis,
+    Done=> ,
+    Busy=> ,
+    Active=> ,
+    CommandAborted=> ,
+    Error=> ,
+    ErrorID=> );
+
+IF nCommandLocal=4 THEN
+    bDone:=fbMoveModulo.Done;
+END_IF
+
+(*Home (Command = 10)*)
+fbHomeVirtual(
+    bExecute:= nCommandLocal=10 AND bExecute,
+    fHomePosition:=fHomePosition,
+    bHomeSensor:=bHomeSensor,
+    bLimitBwd:=bLimitBwd,
+    bLimitFwd:=bLimitFwd,
+    nCmdData:=nCmdDataLocal,
+    bReset:=bReset,
+    nHomeRevOffset:=nHomeRevOffset,
+    Axis:=Axis
+    );
+
+IF nCommandLocal=10 THEN
+    bDone:=fbHomeVirtual.bDone;
+END_IF
+
+(*Gear (Command = 30)*)
+fbGearInDyn(
+    Enable:=bExecute  AND (nCommandLocal=30),
+    GearRatio:=SEL(nCmdDataLocal>0, 1,fVelocity),
+    Acceleration:=fAcceleration,
+    Deceleration:=fDeceleration,
+    Jerk:=0.0,
+    BufferMode:= ,
+    Options:= ,
+    Master:=MasterAxis,
+    Slave:=Axis,
+    InGear=> ,
+    Busy=> ,
+    Active=> ,
+    CommandAborted=> ,
+    Error=> ,
+    ErrorID=> );
+
+fbGearOut(
+    Execute:=NOT bExecute AND Axis.Status.NotMoving AND (nCommandLocal=30),
+    Slave:=Axis,
+    Error=>,
+    Done=>,
+    ErrorID=>);
+
+
+IF nCommandLocal=30 THEN
+    bDone:=Axis.Status.Coupled;
+END_IF
+
+(*Busy*)
+bBusy:=Axis.Status.HasJob OR Axis.Status.HomingBusy OR fbHomeVirtual.bBusy;
+
+(*Enabled*)
+bEnabled:=fbPower.Status;
+
+(*Error from functions and Nc*)
+IF fbPower.Error AND fbPower.Active THEN
+    bError:=fbPower.Enable;
+    nErrorId:=fbPower.ErrorID;
+ELSIF fbHalt.Error AND fbHalt.Active THEN
+    bError:=fbHalt.Execute;
+    nErrorId:=fbHalt.ErrorID;
+ELSIF fbJog.Error AND nCommandLocal=0 (*fbJog.Active*) THEN
+    bError:=fbJog.JogForward OR fbJog.JogBackwards;
+    nErrorId:=fbJog.ErrorID;
+ELSIF fbMoveVelocity.Error AND nCommandLocal=1(*fbMoveVelocity.Active*) THEN
+    bError:=fbMoveVelocity.Execute;
+    nErrorId:=fbMoveVelocity.ErrorID;
+ELSIF fbMoveRelative.Error AND nCommandLocal=2 (*fbMoveRelative.Active*) THEN
+    bError:=fbMoveRelative.Execute;
+    nErrorId:=fbMoveRelative.ErrorID;
+ELSIF fbMoveAbsolute.Error AND nCommandLocal=3 (*fbMoveAbsolute.Active*) THEN
+    bError:=fbMoveAbsolute.Execute;
+    nErrorId:=fbMoveAbsolute.ErrorID;
+ELSIF fbMoveModulo.Error AND nCommandLocal=4 (*fbMoveModulo.Active*) THEN
+    bError:=fbMoveModulo.Execute;
+    nErrorId:=fbMoveModulo.ErrorID;
+ELSIF fbHomeVirtual.bError AND nCommandLocal=10 (*fbHome.Active*) THEN
+    bError:=fbHomeVirtual.bError;
+    nErrorId:=fbHomeVirtual.nErrorID;
+ELSIF fbGearInDyn.Error AND nCommandLocal=30 (*fbGearInDyn.Active*) THEN
+    bError:=fbGearInDyn.Enable;
+    nErrorId:=fbGearInDyn.ErrorID;
+ELSIF fbGearOut.Error AND nCommandLocal=30 AND Axis.Status.Coupled THEN
+    bError:=fbGearOut.Execute;
+    nErrorId:=fbGearOut.ErrorID;
+ELSIF Axis.Status.Error  THEN
+    bError:=TRUE;
+    nErrorId:=Axis.Status.ErrorID;
+ELSIF fbHomeVirtual.bError THEN
+    bError:=TRUE;
+    nErrorId:=fbHomeVirtual.nErrorId;
+ELSE
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF;
+
+(*Converese nErrorID to string*)
+sErrorMessage:=WORD_TO_HEXSTR(in:=TO_WORD(nErrorID) , iPrecision:= 4, bLoCase:=0 );
+
+(*Status from Nc*)
+Status:=Axis.Status;
+
+(*Axis id in motion "motor"*)
+nMotionAxisID:=axis.NcToPlc.AxisId;
+
+(*Actual Velocity*)
+fActVelocity:=Axis.NcToPlc.ActVelo;
+
+(*Actual Position*)
+IF Axis.Status.OpMode.Modulo THEN
+    fActPosition:=Axis.NcToPlc.ModuloActPos;
+ELSE
+    fActPosition:=Axis.NcToPlc.ActPos;
+END_IF
+
+(*Actual Position*)
+fActDiff:=Axis.NcToPlc.PosDiff;
+
+
+//Status struct for EPICS communication
+stAxisStatus.bEnable:=bEnable;
+stAxisStatus.bEnabled:=bEnabled;
+stAxisStatus.bError:=bError;
+stAxisStatus.bExecute:=bExecute;
+stAxisStatus.bHomeSensor:=bHomeSensor;
+stAxisStatus.bJogBwd:=bJogBwd;
+stAxisStatus.bJogFwd:=bJogFwd;
+stAxisStatus.bLimitBwd:=bLimitBwd;
+stAxisStatus.bLimitFwd:=bLimitFwd;
+stAxisStatus.bReset:=bReset;
+stAxisStatus.fAcceleration:=fAcceleration;
+stAxisStatus.fActDiff:=fActDiff;
+stAxisStatus.fActPosition:=fActPosition;
+stAxisStatus.fActVelocity:=fActVelocity;
+stAxisStatus.fDeceleration:=fDeceleration;
+stAxisStatus.fOverride:=fOverride;
+stAxisStatus.fPosition:=fPosition;
+stAxisStatus.fVelocity:=fVelocity;
+stAxisStatus.nCmdData:=nCmdData;  //Or nCmdDataLocal
+stAxisStatus.nCommand:=nCommand;  //Or nCommandLocal
+stAxisStatus.nErrorId:=nErrorId;
+stAxisStatus.bBusy:=bBusy;
+stAxisStatus.bHomed:=bHomed;
+
+IF bFirstScan THEN
+    bFirstScan:=FALSE;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_EL1252ASM_v1_00

+
FUNCTION_BLOCK FB_EL1252ASM_v1_00
+VAR_INPUT
+    En: BOOL;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    Di_1: BOOL;
+    Di_2: BOOL;
+    Di_1_LatchTimePos: ULINT;
+    Di_2_LatchTimePos: ULINT;
+    Di_1_LatchTimeNeg: ULINT;
+    Di_2_LatchTimeNeg: ULINT;
+    ///Below bits can be used but then they must be enabled in the COE of the card. Nicklas suggested to not use these (since something wss written that you then only were allowed to read the latch time onece (some kkind of auto reset??))
+    ///Di_1_LatchNeg:BOOL;
+    ///     Di_1_LatchPos:BOOL;
+    ///     Di_2_LatchNeg:BOOL;
+    ///     Di_2_LatchPos:BOOL;
+    Error: BOOL;
+END_VAR
+VAR
+    Channel_1_Input AT %I*: BOOL;
+    Channel_2_Input AT %I*: BOOL;
+    ///Latch_Status1 AT %I*: USINT;
+    ///     Latch_Status2 AT %I*: USINT;
+    Latch_LatchPos1 AT %I*: ULINT;
+    Latch_LatchNeg1 AT %I*: ULINT;
+    Latch_LatchPos2 AT %I*: ULINT;
+    Latch_LatchNeg2 AT %I*: ULINT;
+    WcState_WcState AT %I*: BOOL;
+    InfoData_State AT %I*: UINT;
+END_VAR
+EnO:=En;
+
+IF En AND (WcState_WcState OR InfoData_State<>16#8) THEN //InfoData_State==0 => in OP mode
+    Error:=TRUE;
+ELSE
+    Error:=FALSE;
+END_IF
+
+IF En THEN
+    IF Error=FALSE THEN
+            Di_1:=Channel_1_Input;
+            Di_2:=Channel_2_Input;
+    (*      Di_1_LatchPos:=Latch_Status1.0;
+            Di_1_LatchNeg:=Latch_Status1.1;
+            Di_2_LatchPos:=Latch_Status2.0;
+            Di_2_LatchNeg:=Latch_Status2.1;*)
+            Di_1_LatchTimePos:=Latch_LatchPos1;
+            Di_2_LatchTimePos:=Latch_LatchPos2;
+            Di_1_LatchTimeNeg:=Latch_LatchNeg1;
+            Di_2_LatchTimeNeg:=Latch_LatchNeg2;
+
+    ELSE
+            Di_1:=FALSE;
+            Di_2:=FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_EncErrorFFO

+
FUNCTION_BLOCK FB_EncErrorFFO
+(*
+    Example usage of FB_NCErrorFFO that only counts encoder errors as faults.
+*)
+VAR_IN_OUT
+    // Motion stage to monitor
+    stMotionStage: ST_MotionStage;
+    // FFO to trip
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    // Reset the fault
+    bReset: BOOL;
+    // Auto reset the fault
+    bAutoReset: BOOL;
+END_VAR
+VAR_OUTPUT
+    // Quick way for nearby code to check if this block has tripped the FFO.
+    bTripped: BOOL;
+END_VAR
+VAR
+    fbNCErrorFFO: FB_NCErrorFFO := (
+        nLowErrorId := 16#4400,
+        nHighErrorId := 16#44FF,
+        sDesc := 'Encoder error');
+END_VAR
+fbNCErrorFFO(
+    stMotionStage := stMotionStage,
+    fbFFHWO := fbFFHWO,
+    bReset := bReset,
+    bAutoReset := bAutoReset,
+    bTripped => bTripped);
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_EncoderValue

+
FUNCTION_BLOCK FB_EncoderValue
+(*
+    Process the encoder value for ST_MotionStage
+
+    A few different problems this is trying to solve:
+        1. Different encoders show as different types in the IO,
+           but we want a consistent type for checks and for PVs
+        2. Some inverted encoders display as very high numbers
+           as they count down from max int instead of up from 0
+        3. Some encoders have raw signed values, others unsigned.
+
+    To this end, we figure out which encoder is linked and process
+    the value appropriately.
+*)
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+IF stMotionStage.nRawEncoderULINT <> 0 THEN
+    IF stMotionStage.nRawEncoderULINT < 4294967296 THEN
+        stMotionStage.nEncoderCount := ULINT_TO_UDINT(stMotionStage.nRawEncoderULINT);
+    ELSE
+        stMotionStage.nEncoderCount := ULINT_TO_UDINT(18446744073709551615 - stMotionStage.nRawEncoderULINT);
+    END_IF
+ELSIF stMotionStage.nRawEncoderUINT <> 0 THEN
+    stMotionStage.nEncoderCount := UINT_TO_UDINT(stMotionStage.nRawEncoderUINT);
+ELSIF stMotionStage.nRawEncoderINT <> 0 THEN
+    stMotionStage.nEncoderCount := INT_TO_UDINT(stMotionStage.nRawEncoderINT);
+ELSE
+    stMotionStage.nEncoderCount := 0;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_EncSaveRestore

+
FUNCTION_BLOCK FB_EncSaveRestore
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR_INPUT
+    bEnable: BOOL;
+END_VAR
+VAR_OUTPUT
+END_VAR
+VAR
+    fbSetPos: MC_SetPosition;
+    timer: TON;
+    bInit: BOOL;
+    bLoad: BOOL;
+    nLatchError: UDINT;
+    bEncError: BOOL;
+    tRetryDelay: TIME := T#1s;
+    nMaxRetries: UINT := 10;
+    nCurrTries: UINT := 0;
+    bWaitRetry: BOOL;
+    tonRetry: TON;
+END_VAR
+VAR PERSISTENT
+    bSaved: BOOL;
+    fPosition: LREAL;
+END_VAR
+IF bEnable THEN
+    // Trigger a load if anything was saved at all
+    IF NOT bInit THEN
+        bInit := TRUE;
+        bLoad S= bSaved;
+        fbSetPos.Options.ClearPositionLag := TRUE;
+    END_IF
+
+    // Set our position if bLoad is true
+    fbSetPos(
+        Axis:=stMotionStage.Axis,
+        Execute:=bLoad,
+        Position:=fPosition);
+
+    // Only load once, at startup
+    bLoad R= fbSetPos.Done OR fbSetPos.Error;
+
+    IF fbSetPos.Error THEN
+        // Keep the error latched, it can disappear if Execute is set to FALSE
+        nLatchError := fbSetPos.ErrorID;
+        nCurrTries := nCurrTries + 1;
+        IF nCurrTries >= nMaxRetries THEN
+            // Alert the user that something has gone wrong
+            stMotionStage.bError := TRUE;
+            stMotionStage.nErrorId := nLatchError;
+            stMotionStage.sCustomErrorMessage := 'Error loading previously saved position.';
+        ELSE
+            // Reset the FB for the next retry
+            fbSetPos(
+                Axis:=stMotionStage.Axis,
+                Execute:=FALSE,
+                Position:=fPosition);
+            // Try again
+            bWaitRetry := TRUE;
+        END_IF
+    END_IF
+
+    tonRetry(
+        IN := bWaitRetry,
+        PT := tRetryDelay);
+
+    bLoad S= tonRetry.Q;
+    bWaitRetry R= tonRetry.Q;
+
+    // Check ST_MotionStage for an encoder error (range 0x44nn)
+    bEncError := stMotionStage.bError AND stMotionStage.nErrorId >= 16#4400 AND stMotionStage.nErrorId <= 16#44FF;
+
+    // Do not save if we're currently loading or if there is an encoder error
+    IF NOT bLoad AND NOT bEncError AND NOT bWaitRetry THEN
+        fPosition := stMotionStage.stAxisStatus.fActPosition;
+        // This persistent variable lets us check if anything was saved
+        // It will be TRUE at startup if we have saved values
+        bSaved := TRUE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_EpicsInOut

+
{attribute 'obsolete' := 'Use FB_PositionState1D_InOut instead'}
+FUNCTION_BLOCK FB_EpicsInOut
+// Example usage of FB_PositionStateManager for a simple IN/OUT axis. See NOTE: comments.
+// Also usable as a drop-in for these cases (no need to roll your own in/out)
+VAR_IN_OUT
+    // Motor to apply states to
+    stMotionStage: ST_MotionStage;
+    // Information about the OUT position
+    stOut: ST_PositionState; // NOTE: Do not pragma these, let it happen in the manager.
+    // Information about the IN parameter
+    stIn: ST_PositionState;
+END_VAR
+VAR_INPUT
+    // If TRUE, the motor will be moved when enumSet is changed
+    bEnable: BOOL;
+    // When changed, sets the destination and starts a move
+    {attribute 'pytmc' := '
+        pv: SET
+        io: io
+    '}
+    enumSet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumSet
+END_VAR
+VAR_OUTPUT
+    // If TRUE, we are in an error state
+    bError: BOOL; // NOTE: do not pragma these, already has pragma in manager
+    // Error code
+    nErrorId: UDINT;
+    // Message associated with bError = TRUE
+    sErrorMessage: STRING;
+    // If TRUE, we are currently moving between states
+    bBusy: BOOL;
+    // If TRUE, we asked for a move between states, it completed successfully, and there is no ongoing move
+    bDone: BOOL;
+    // The current state readback
+    {attribute 'pytmc' := '
+        pv: GET
+        io: i
+    '}
+    enumGet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumGet
+END_VAR
+VAR
+    bInit: BOOL;
+    arrStates: ARRAY[1..15] OF ST_PositionState;
+
+    {attribute 'pytmc' := '
+        pv:
+        io: io
+    '}
+    fbStateManager: FB_PositionStateManager; // NOTE: Please copy this pragma exactly to pick up the standard PVs
+END_VAR
+// Fist cycle setup
+IF NOT bInit THEN
+    stOut.sName := 'OUT';
+    stIn.sName := 'IN';
+    bInit := TRUE;
+END_IF
+
+// Stuff first two values of the 15 element array for the manager
+arrStates[1] := stOut;
+arrStates[2] := stIn;
+
+// Call the function block every cycle
+fbStateManager(
+    stMotionStage := stMotionStage,
+    arrStates := arrStates,
+    setState := enumSet,
+    bEnable := bEnable,
+    bError => bError,
+    nErrorId => nErrorId,
+    sErrorMessage => sErrorMessage,
+    bBusy => bBusy,
+    bDone => bDone,
+    getState => enumGet); // Cannot do this assignment if enumGet has attribute strict
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_ErrorList

+
FUNCTION_BLOCK FB_ErrorList
+
+VAR_INPUT
+    En : BOOL;                                                                                      //Enable input
+    bReset : BOOL;                                                                          //Delete all Error entry
+    lErrorID : ULINT;                                                                       //ErrorID to be acknoledged
+    bACK : BOOL;                                                                            //Acknoledge the given error and delete it from the list
+END_VAR
+
+VAR_OUTPUT
+    EnO : BOOL;                                                                                     //Enable output
+    nNoError: UINT;                                                                         //Number of Errors
+    nNoOverflow : INT;                                                                      //Number of Overflows
+    pErrorSystem : POINTER TO ST_ErrorSystem;                       //Pointer to ErrorSystem
+END_VAR
+
+VAR
+    nFreePos : UINT;                                                                        //Number of free position in the list
+    nListCnt1 : UINT;                                                                       //work variable
+    ErrorSystem : ST_ErrorSystem;                                           //Data structure of the Error list
+END_VAR
+(*
+* ================================================================================
+*                                   DESCRIPTION
+* ================================================================================
+* This Function Block implements the core structure of the Error/Warning Handling
+* system. It realizes the datastructure containing every Error Entry, collect
+* statistics about the usage and manage the Error Entries.
+* Note: The system is under development, most of the functionalities are not
+* implemented or existing functionalities may change with time.
+* ================================================================================
+*)
+EnO := En;
+
+//Ponter to ErrorSystem
+pErrorSystem := ADR(ErrorSystem);
+
+//Number of overflows
+nNoOverflow := ErrorSystem.nNoOverflows;
+
+IF bReset THEN
+    MEMSET ( ADR(ErrorSystem.aErrorData[0]), 0, GVL_ErrorSystem.cSizeOfErrorData * SIZEOF(DUT_TerminalError));
+    ErrorSystem.lNextErrorID := 1;
+END_IF
+
+//Number of errors in the system
+nNoError := 0;
+FOR nListCnt1 := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO
+    IF ErrorSystem.aErrorData[nListCnt1].Error_ID <> 0  THEN
+            nNoError := nNoError+1;
+    END_IF
+END_FOR
+ErrorSystem.nNoErrors := nNoError;
+
+//Number of free position in the list
+nFreePos := GVL_ErrorSystem.cSizeOfErrorData - nNoError;
+
+//Acknoledge specified Error entry
+IF bACK THEN
+    FOR nListCnt1 := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO
+            IF ErrorSystem.aErrorData[nListCnt1].Error_ID = lErrorID THEN
+                    ErrorSystem.aErrorData[nListCnt1].ErrorState := DUT_ErrorState.Acknowledged;
+            END_IF
+    END_FOR
+END_IF
+
+//Deleting acknoledged errors
+FOR nListCnt1 := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO
+    IF ErrorSystem.aErrorData[nListCnt1].ErrorState = DUT_ErrorState.Acknowledged THEN
+            MEMMOVE (ADR(ErrorSystem.aErrorData[nListCnt1]), ADR(ErrorSystem.aErrorData[nListCnt1+1]), (GVL_ErrorSystem.cSizeOfErrorData - 1 - nListCnt1) * SIZEOF(DUT_TerminalError));
+            MEMSET(ADR(ErrorSystem.aErrorData[GVL_ErrorSystem.cSizeOfErrorData - 1]), 0, SIZEOF(DUT_TerminalError));
+    END_IF
+END_FOR
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_GantryAutoCoupling

+
FUNCTION_BLOCK FB_GantryAutoCoupling
+VAR_INPUT
+    nGantryTol : LINT;
+END_VAR
+VAR_OUTPUT
+    bGantryAlreadyCoupled : BOOL;
+END_VAR
+VAR_IN_OUT
+    Master : ST_MotionStage;
+    MasterEnc : ST_RenishawAbsEnc;
+    Slave : ST_MotionStage;
+    SlaveEnc : ST_RenishawAbsEnc;
+    bExecuteCouple : BOOL;
+    bExecuteDecouple : BOOL;
+END_VAR
+VAR
+    gantry_diff_limit : FB_GantryDiffVirtualLimitSwitch;
+    couple : MC_GEARIN;
+    decouple : MC_GEAROUT;
+    bInitComplete : BOOL;
+    fbSetEnables : FB_SetEnables;
+END_VAR
+// Designate Master and SLave Axes
+Master.bGantryAxis := TRUE;
+Slave.bGantryAxis := TRUE;
+
+Master.nGantryTol := nGantryTol;
+Slave.nGantryTol := Master.nGantryTol;
+
+// Activate Gantry Virtual Limit Switch
+gantry_diff_limit(Penc:=MasterEnc, SEnc:=SlaveEnc, GantDiffTol:=Master.nGantryTol,
+                  PLimFwd=>Master.bGantryForwardEnable, PLimBwd=>Master.bGantryBackwardEnable,
+                  SLimFwd=>Slave.bGantryForwardEnable, SLimBwd=>Slave.bGantryBackwardEnable);
+
+// Coupling Status Bit
+bGantryAlreadyCoupled := Master.Axis.NcToPlc.CoupleState=1 AND Slave.Axis.NcToPlc.CoupleState=3;
+
+fbSetEnables(stMotionStage:=Master);
+fbSetEnables(stMotionStage:=Slave);
+
+IF bGantryAlreadyCoupled THEN
+    Master.bGantryForwardEnable := Master.bGantryForwardEnable AND Slave.bAllForwardEnable;
+    Slave.bGantryForwardEnable := Master.bAllForwardEnable AND Slave.bGantryForwardEnable;
+
+    Master.bGantryBackwardEnable := Master.bGantryBackwardEnable AND Slave.bAllBackwardEnable;
+    Slave.bGantryBackwardEnable := Master.bAllBackwardEnable AND Slave.bGantryBackwardEnable;
+END_IF
+
+
+// Coupling states
+// Auto-coupling at init and auto-reset of coupling boolean
+bExecuteCouple S= NOT bInitComplete;
+
+bExecuteCouple R= couple.Busy OR bGantryAlreadyCoupled;
+couple(Master:=Master.Axis, Slave:=Slave.Axis, Execute:=bExecuteCouple);
+
+bInitComplete S= bGantryAlreadyCoupled;
+
+// Decoupling with auto-reset of coupling boolean
+bExecuteDecouple R= decouple.Busy OR NOT bGantryAlreadyCoupled;
+decouple(Slave:=Slave.Axis, Execute:=bExecuteDecouple);
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_GantryDiffVirtualLimitSwitch

+
FUNCTION_BLOCK FB_GantryDiffVirtualLimitSwitch
+VAR_INPUT
+    PEnc: ST_RenishawAbsEnc; // Primary axis encoder (usually the upstream one)
+    SEnc: ST_RenishawAbsEnc; // Secondary axis encoder (couples to the primary)
+
+    GantDiffTol: LINT;        // Gantry differenace tolerance in encoder counts
+END_VAR
+VAR_OUTPUT
+    PLimFwd: BOOL; // Primary axis forward direction enable
+    PLimBwd: BOOL; // Primary axis reverse direction enable
+    SLimFwd: BOOL; // Secondary axis forward direction enable
+    SLimBwd: BOOL; // Secondary axis reverse direction enable
+END_VAR
+VAR
+    GantryDiff: LINT;
+END_VAR
+(* Gantry Difference Virtual Limit Switch
+A. Wallace 2017-2-15
+
+Determines which direction is disabled due to it increasing the gantry difference.
+Refer to the ESD for actual conventions.
+
+A positive gantry error refers to a CCW clocked assembly:
+eg. for X
+X1 upstream, X2 downstream. Primary axis is always upstream.
+Gantry difference > 0 when
+X2>X1
+Therefore
+X2 positive direction disabled
+X1 negative direction disabled
+
+Call before FB_MotionStage fb calls for the gantry axes.
+*)
+
+GantryDiff := ( ULINT_TO_LINT(PEnc.Count) - ULINT_TO_LINT(PEnc.Ref) ) - ( ULINT_TO_LINT(SEnc.Count) - ULINT_TO_LINT(SEnc.Ref) );
+
+IF ABS(GantryDiff) > GantDiffTol THEN
+    IF GantryDiff < 0  THEN
+        PLimBwd := FALSE;
+        SLimFwd := FALSE;
+    ELSE
+        PLimBwd := TRUE;
+        SLimFwd := TRUE;
+    END_IF
+    IF GantryDiff > 0 THEN
+        PLimFwd := FALSE;
+        SLimBwd := FALSE;
+    ELSE
+        PLimFwd := TRUE;
+        SLimBwd := TRUE;
+    END_IF
+ELSE
+    //If there is no fault, all directions are enabled
+    PLimFwd := TRUE;
+    PLimBwd := TRUE;
+    SLimFwd := TRUE;
+    SLimBwd := TRUE;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_HomeDirect

+
FUNCTION_BLOCK FB_HomeDirect
+VAR_INPUT
+    En: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+    fHomePosition:LREAL;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bHomed:BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR
+    fbHome: MC_Home;
+END_VAR
+En:=EnO;
+IF bReset THEN
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF
+
+fbHome(
+    Execute:=bExecute,
+    Position:=fHomePosition,
+    HomingMode:=MC_Direct,
+    bCalibrationCam:=FALSE,
+    Axis:=Axis
+    );
+
+bBusy:=fbHome.Busy;
+bDone:=fbHome.Done;
+bHomed:=Axis.Status.Homed;
+
+bError:=fbHome.Error;
+
+IF fbHome.Error THEN
+  nErrorId:=fbHome.ErrorID;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_HomeFinish

+
FUNCTION_BLOCK FB_HomeFinish
+VAR_INPUT
+    En: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+    nCmdData: UINT;
+    bSofLimEnableLow: BOOL:=TRUE;
+    bSofLimEnableHigh: BOOL:=TRUE;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR
+    fbHomewriteSoftLimEnable:FB_HomeWriteSoftLimEnable;
+    fbExecuteRiseEdge: R_TRIG;
+    bExecuteWriteNC:BOOL:=FALSE;
+    nState:INT:=0;
+END_VAR
+En:=EnO;
+IF bReset THEN
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF
+
+IF NOT bExecute THEN
+  bExecuteWriteNC:=FALSE;
+  fbHomewriteSoftLimEnable.bSofLimEnableLow:=bSofLimEnableLow;
+  fbHomewriteSoftLimEnable.bSofLimEnableHigh:=bSofLimEnableHigh;
+  nState:=0;
+END_IF
+
+fbExecuteRiseEdge(CLK:=bExecute);
+IF fbExecuteRiseEdge.Q THEN
+  bExecuteWriteNC:=TRUE;
+  fbHomewriteSoftLimEnable.bSofLimEnableLow:=bSofLimEnableLow;
+  fbHomewriteSoftLimEnable.bSofLimEnableHigh:=bSofLimEnableHigh;
+END_IF
+
+// Write to NC (disable soft limits)
+fbHomewriteSoftLimEnable(
+    En:=En,
+    bExecute:=bExecuteWriteNC AND bExecute,
+    Axis:=Axis,
+    bReset:=bReset,
+);
+
+bBusy:=fbHomewriteSoftLimEnable.bBusy;
+bDone:=fbHomewriteSoftLimEnable.bDone;
+
+bError:=fbHomewriteSoftLimEnable.bError;
+IF fbHomewriteSoftLimEnable.bError THEN
+  nErrorId:=fbHomewriteSoftLimEnable.nErrorId;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_HomePrepare

+
FUNCTION_BLOCK FB_HomePrepare
+VAR_INPUT
+    En: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+    nCmdData: UINT;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+    bSofLimEnableLowOriginal: BOOL:=TRUE;
+    bSofLimEnableHighOriginal: BOOL:=TRUE;
+    fVelocityToCam: LREAL:=0;
+    fVelocityFromCam: LREAL:=0;
+END_VAR
+VAR
+    fbHomeReadSoftLimEnable:FB_HomeReadSoftLimEnable;
+    fbHomeDisableSoftLimEnable:FB_HomeWriteSoftLimEnable;
+    fbHomeReadNCVelocities: FB_HomeReadNcVelocities;
+    fbHomeResetCalibrationFlag:MC_Home;   //Only used for reset of calibration flag
+    fbExecuteRiseEdge: R_TRIG;
+    bExecuteReadNC:BOOL:=FALSE;
+    bExecuteWriteNC:BOOL:=FALSE;
+    nState:INT:=0;
+END_VAR
+En:=EnO;
+IF bReset THEN
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF
+
+IF NOT bExecute THEN
+  bExecuteReadNC:=FALSE;
+  bExecuteWriteNC:=FALSE;
+  nState:=0;
+END_IF
+
+fbExecuteRiseEdge(CLK:=bExecute);
+IF fbExecuteRiseEdge.Q THEN
+  bExecuteReadNC:=TRUE;
+END_IF
+
+// Read from NC
+fbHomeReadNCVelocities(
+  En:=En,
+  bExecute:=bExecuteReadNC, // Actualy not needed for sequence 15 (set position only, no movement))
+  bReset:=bReset,
+  Axis:=Axis,
+);
+
+fbHomeReadSoftLimEnable(
+    En:=En,
+    bExecute:=bExecuteReadNC AND bExecute,
+    Axis:=Axis,
+    bReset:=bReset,
+);
+
+// Reset calibration flag
+fbHomeResetCalibrationFlag(
+  Execute:=bExecuteReadNC,
+  HomingMode:=MC_ResetCalibration,
+  Axis:=Axis
+);
+
+bSofLimEnableLowOriginal:=fbHomeReadSoftLimEnable.bSofLimEnableLow;
+bSofLimEnableHighOriginal:=fbHomeReadSoftLimEnable.bSofLimEnableHigh;
+
+fVelocityToCam:=fbHomeReadNCVelocities.fVelocityToCam;
+fVelocityFromCam:=fbHomeReadNCVelocities.fVelocityFromCam;
+
+IF bExecuteReadNC AND bExecute AND fbHomeReadSoftLimEnable.bDone THEN
+    fbHomeDisableSoftLimEnable.bSofLimEnableHigh:=FALSE;
+    fbHomeDisableSoftLimEnable.bSofLimEnableLow:=FALSE;
+    bExecuteWriteNC:=TRUE; //Always write (only needed if enabled actually)
+END_IF
+
+// Write to NC (disable soft limits)
+fbHomeDisableSoftLimEnable(
+    En:=En,
+    bExecute:=bExecuteWriteNC AND bExecute,
+    Axis:=Axis,
+    bReset:=bReset,
+);
+
+bBusy:=fbHomeReadSoftLimEnable.bBusy OR fbHomeDisableSoftLimEnable.bBusy OR fbHomeReadNCVelocities.bBusy OR fbHomeResetCalibrationFlag.Busy;
+bDone:=fbHomeReadSoftLimEnable.bDone AND fbHomeDisableSoftLimEnable.bDone AND fbHomeReadNCVelocities.bDone AND fbHomeResetCalibrationFlag.Done AND bExecute;
+
+bError:=fbHomeReadSoftLimEnable.bError OR fbHomeDisableSoftLimEnable.bError OR fbHomeReadNCVelocities.bError OR fbHomeResetCalibrationFlag.Error;
+IF fbHomeReadSoftLimEnable.bError THEN
+  nErrorId:=fbHomeReadSoftLimEnable.nErrorId;
+ELSIF fbHomeDisableSoftLimEnable.bError THEN
+  nErrorId:=fbHomeDisableSoftLimEnable.nErrorId;
+ELSIF fbHomeResetCalibrationFlag.Error THEN
+  nErrorId:=fbHomeResetCalibrationFlag.ErrorId;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_HomeReadNcVelocities

+
FUNCTION_BLOCK FB_HomeReadNcVelocities
+VAR_INPUT
+    En: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+    fVelocityToCam: LREAL;
+    fVelocityFromCam: LREAL;
+END_VAR
+VAR
+    fbReadVelocityToCam:FB_ReadFloatParameter;
+    fbReadVelocityFromCam:FB_ReadFloatParameter;
+END_VAR
+En:=EnO;
+IF bReset THEN
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF
+
+fbReadVelocityToCam(
+    bExecute:=bExecute,
+    nDeviceGroup:= 16#4000,
+    nIndexOffset:= 16#6,
+    Axis:= Axis);
+
+fbReadVelocityFromCam(
+    bExecute:=bExecute,
+    nDeviceGroup:= 16#4000,
+    nIndexOffset:= 16#7,
+    Axis:= Axis);
+
+fVelocityToCam:=fbReadVelocityToCam.nData;
+fVelocityFromCam:=fbReadVelocityFromCam.nData;
+
+bBusy:=fbReadVelocityFromCam.bBusy OR fbReadVelocityToCam.bBusy;
+bDone:=fbReadVelocityFromCam.bDone AND fbReadVelocityToCam.bDone AND bExecute;
+
+bError:=fbReadVelocityToCam.bError OR fbReadVelocityFromCam.bError;
+IF fbReadVelocityToCam.bError THEN
+  nErrorId:=fbReadVelocityToCam.nErrorId;
+ELSIF fbReadVelocityFromCam.bError THEN
+  nErrorId:=fbReadVelocityFromCam.nErrorId;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_HomeReadSoftLimEnable

+
FUNCTION_BLOCK FB_HomeReadSoftLimEnable
+VAR_INPUT
+    En: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+    bSofLimEnableLow: BOOL:=TRUE;
+    bSofLimEnableHigh: BOOL:=TRUE;
+END_VAR
+VAR
+    fbReadSoftLimEnableLow:FB_ReadParameterInNc_v1_00;
+    fbReadSoftLimEnableHigh:FB_ReadParameterInNc_v1_00;
+END_VAR
+En:=EnO;
+IF bReset THEN
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF
+
+fbReadSoftLimEnableLow(
+    bExecute:=bExecute,
+    nDeviceGroup:= 16#5000,
+    nIndexOffset:= 16#B,
+    Axis:= Axis);
+
+fbReadSoftLimEnableHigh(
+    bExecute:=bExecute,
+    nDeviceGroup:= 16#5000,
+    nIndexOffset:= 16#C,
+    Axis:= Axis);
+
+bSofLimEnableLow:=DWORD_TO_BOOL(fbReadSoftLimEnableLow.nData);
+bSofLimEnableHigh:=DWORD_TO_BOOL(fbReadSoftLimEnableHigh.nData);
+
+bBusy:=fbReadSoftLimEnableLow.bBusy OR fbReadSoftLimEnableHigh.bBusy;
+bDone:=fbReadSoftLimEnableLow.bDone AND fbReadSoftLimEnableHigh.bDone AND bExecute;
+
+bError:=fbReadSoftLimEnableLow.bError OR fbReadSoftLimEnableHigh.bError;
+IF fbReadSoftLimEnableLow.bError THEN
+  nErrorId:=fbReadSoftLimEnableLow.nErrorId;
+ELSIF fbReadSoftLimEnableHigh.bError THEN
+  nErrorId:=fbReadSoftLimEnableHigh.nErrorId;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_HomeToSwitch

+
FUNCTION_BLOCK FB_HomeToSwitch
+VAR_INPUT
+    En: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+    bCamSensor:BOOL;
+    nSearchDirTwoardsCam: MC_Direction;
+    nSearchDirOffCam: MC_Direction;
+    fHomePosition:LREAL;
+    fVelocityToCamNC: LREAL; //Velcoity when searching for cam
+    fVelocityFromCamNC: LREAL; // Velocity after found cam (searching for next signal transition)
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bHomed:BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR
+    fbHome: MC_Home;
+    fbWriteHomeDirCamToNC:FB_WriteParameterInNc_v1_00;
+    fbWriteHomeDirSyncToNC:FB_WriteParameterInNc_v1_00;
+    fbWriteHomeModeToNC:FB_WriteParameterInNc_v1_00;
+    fbWriteHomeVelocitiesToNC: FB_HomeWriteNcVelocities;
+    bConfigNCDone:BOOL:=FALSE;
+    fbRTrigg: R_TRIG;
+END_VAR
+En:=EnO;
+IF bReset THEN
+    bConfigNCDone:=FALSE;
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF
+
+//Start preparation of NC if rising edge on bExecute
+fbRTrigg(CLK:=bExecute);
+IF fbRTrigg.Q THEN
+    bConfigNCDone:=FALSE;
+END_IF
+
+
+fbWriteHomeDirCamToNC(
+    bExecute:=bExecute AND NOT bConfigNCDone,
+    nDeviceGroup:=16#5000,
+    nIndexOffset:=16#101,   //Direction for Calibration Cam Search
+    nData:=BOOL_TO_DWORD(nSearchDirTwoardsCam=MC_Negative_Direction),//BOOL_TO_DWORD(NOT bSearchDirTwoardsCam),
+    Axis:=Axis
+);
+
+fbWriteHomeDirSyncToNC(
+    bExecute:= bExecute AND NOT bConfigNCDone,
+    nDeviceGroup:=16#5000 ,
+    nIndexOffset:=16#102 , //Direction for Sync Impuls Search
+    nData:=BOOL_TO_DWORD(nSearchDirOffCam=MC_Negative_Direction),//BOOL_TO_DWORD(NOT bSearchDirOffCam),
+    Axis:= Axis
+);
+
+fbWriteHomeModeToNC(
+    bExecute:=bExecute AND NOT bConfigNCDone,
+    nDeviceGroup:=16#5000,
+    nIndexOffset:=16#107,  //Reference Mode
+    nData:=1,
+    Axis:=axis);
+
+fbWriteHomeVelocitiesToNC(
+  En:=En,
+  bExecute:=bExecute AND NOT bConfigNCDone,
+  bReset:=bReset,
+  fVelocityFromCam:=fVelocityFromCamNC,
+  fVelocityToCam:=fVelocityToCamNC,
+  Axis:=Axis);
+
+fbHome.bCalibrationCam:=bCamSensor;
+
+fbHome(
+    Execute:=bExecute AND bConfigNCDone(* AND NOT bError*),
+    Position:=fHomePosition,
+    HomingMode:=0,
+    Axis:=Axis
+    );
+bBusy:=(fbHome.Busy OR (NOT bConfigNCDone AND bExecute));
+bDone:=fbHome.Done AND bConfigNCDone;
+bHomed:=Axis.Status.Homed;
+
+IF (NOT bConfigNCDone) AND fbWriteHomeDirCamToNC.bDone AND fbWriteHomeDirSyncToNC.bDone AND fbWriteHomeModeToNC.bDone AND fbWriteHomeVelocitiesToNC.bDone THEN
+  bConfigNCDone:=TRUE;
+END_IF
+
+//For some reason MC_HOME gives an Error for one cycle of NC-Task 1 SVB (10ms default..) so filter with bExecute
+bError:=(fbHome.Error AND bExecute) OR fbWriteHomeDirCamToNC.bError OR fbWriteHomeDirSyncToNC.bError OR fbWriteHomeModeToNC.bError OR fbWriteHomeVelocitiesToNC.bError;
+
+IF (fbHome.Error AND bExecute) THEN
+  nErrorId:=fbHome.ErrorID;
+ELSIF fbWriteHomeDirCamToNC.bError THEN
+  nErrorId:=fbWriteHomeDirCamToNC.nErrorId;
+ELSIF fbWriteHomeDirSyncToNC.bError THEN
+  nErrorId:=fbWriteHomeDirSyncToNC.nErrorId;
+ELSIF fbWriteHomeModeToNC.bError THEN
+  nErrorId:=fbWriteHomeModeToNC.nErrorId;
+ELSIF fbWriteHomeVelocitiesToNC.bError THEN
+  nErrorId:=fbWriteHomeVelocitiesToNC.nErrorId;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_HomeVirtual

+
FUNCTION_BLOCK FB_HomeVirtual
+VAR_INPUT
+    En: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+    nCmdData: UINT;
+    bLimitFwd: BOOL;
+    bLimitBwd: BOOL;
+    bHomeSensor: BOOL;
+    fHomePosition:LREAL;
+    nHomeRevOffset: UINT;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bHomed:BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR
+    fbHomeToSwitch: FB_HomeToSwitch;
+    fbHomeDirect: FB_HomeDirect; //Only used for direct homing (set of position)
+    fbMoveVelocity:MC_MoveVelocity;
+    fbHomePrepare:FB_HomePrepare;
+    fbHomeFinish:FB_HomeFinish;
+    fbExecuteRiseEdge: R_TRIG;
+    nHomingState:INT:=0;
+    bExecuteHomeToSwitch:BOOL:=FALSE;
+    bExecuteMoveVelocity:BOOL:=FALSE;
+    bExecutePrepare: BOOL:=FALSE;
+    bExecuteFinish: BOOL:=FALSE;
+    bExecuteHomeDirect: BOOL;
+    nCmdDataLocal: UINT;  //Ensure that nCmdData is not changed during sequence
+    bSequenceReady:BOOL:=TRUE;
+    bRestoreNCDataNeeded: BOOL:=FALSE;
+END_VAR
+EnO:=En;
+
+IF bReset THEN
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF
+
+// Reset when bExecute is low
+IF NOT bExecute THEN
+  nHomingState:=0;
+  bSequenceReady:=TRUE;
+  bExecuteHomeToSwitch:=FALSE;
+  bExecuteHomeDirect:=FALSE;
+  bExecuteMoveVelocity:=FALSE;
+  bExecutePrepare:=FALSE;
+  bExecuteFinish:=FALSE;
+END_IF
+
+//Reset at rinsing edge of bExecute
+fbExecuteRiseEdge(CLK:=bExecute);
+IF fbExecuteRiseEdge.Q THEN
+  nCmdDataLocal:=nCmdData; //Ensure that nCmdData is not changed during sequence (nCmdData will only be read at a rising edge of bExecute)
+  bSequenceReady:=FALSE;
+  bExecutePrepare:=TRUE;
+  bRestoreNCDataNeeded:=FALSE;
+  //Check if valid nCmdDataLocal
+  CASE nCmdDataLocal OF
+    1:
+    2:
+    3:
+    4:
+    15:
+    ELSE //nCmdData not valid
+      bError:=TRUE;
+      nErrorId:=16#4FFF;
+  END_CASE
+END_IF
+
+//############# Prepare for homing (Read from NC and reset homed flag)
+fbHomePrepare(
+  En:=En,
+  bExecute:=bExecutePrepare AND NOT bError, // Not needed for sequence 15 (set position only, no movement))
+  bReset:=bReset,
+  Axis:=Axis,
+);
+
+//############# Homing Sequences:
+CASE nCmdDataLocal OF
+
+   1: // Home to low limit switch
+       CASE nHomingState OF
+              0:
+                bHomed:=Axis.Status.Homed;
+            // Wait for read of velocities from NC and reset of calibration flag
+            IF fbHomePrepare.bDone AND bExecute AND NOT bSequenceReady THEN
+                      bRestoreNCDataNeeded:=TRUE;
+                      IF bLimitBwd THEN
+                nHomingState:=1;
+              ELSE
+                            nHomingState:=2;  //Standing on limit switch go direct to state 2
+              END_IF
+            END_IF
+              1: // wait for reach low limit then trigger fbHomeToSwitch
+                bHomed:=FALSE;
+                    bSequenceReady:=FALSE;
+                    fbMoveVelocity.Velocity:=ABS(fbHomePrepare.fVelocityToCam);
+            fbMoveVelocity.Direction:=MC_Negative_Direction;
+            bExecuteMoveVelocity:=bExecute;  // Execute MC_MoveVelocity
+                IF NOT bLimitBwd AND NOT fbMoveVelocity.Busy AND Axis.Status.NotMoving THEN //MC_MoveVelocity.Busy goes down when ramp down initiates (not ends).
+                      nHomingState:=2;
+                END_IF
+              2: // Wait for fbHomeToSwitch
+                bHomed:=FALSE;
+                bSequenceReady:=FALSE;
+            bExecuteMoveVelocity:=FALSE;
+            bExecuteHomeToSwitch:=TRUE;
+            fbHomeToSwitch.nSearchDirTwoardsCam:=MC_Positive_Direction;
+            fbHomeToSwitch.nSearchDirOffCam:=MC_Positive_Direction;
+            fbHomeToSwitch.fVelocityToCamNC:=fbHomePrepare.fVelocityToCam; // High speed
+            fbHomeToSwitch.fVelocityFromCamNC:=fbHomePrepare.fVelocityFromCam;  // Low speed
+                fbHomeToSwitch.bCamSensor:=NOT bLimitBwd;
+            IF fbHomeToSwitch.bDone THEN
+                      nHomingState:=3;
+                      bExecuteFinish:=TRUE;
+                      fbHomeFinish.bSofLimEnableHigh:=fbHomePrepare.bSofLimEnableHighOriginal;
+                      fbHomeFinish.bSofLimEnableLow:=fbHomePrepare.bSofLimEnableLowOriginal;
+            END_IF;
+          3: // restore softlimit enable
+            bHomed:=FALSE;
+                bSequenceReady:=FALSE;
+            IF fbHomeFinish.bDone THEN
+                      bRestoreNCDataNeeded:=FALSE;
+              bSequenceReady:=TRUE;
+                      nHomingState:=0;
+                      bHomed:=Axis.Status.Homed;
+            END_IF;
+       END_CASE;
+
+   2: // Home to high limit switch
+       CASE nHomingState OF
+              0:
+                bHomed:=Axis.Status.Homed;
+            // Wait for read of velocities from NC and reset of calibration flag
+            IF fbHomePrepare.bDone AND bExecute AND NOT bSequenceReady THEN
+                      bRestoreNCDataNeeded:=TRUE;
+                      IF bLimitFwd THEN
+                nHomingState:=1;
+              ELSE
+                            nHomingState:=2;  //Standing on limit switch go direct to state 2
+              END_IF
+            END_IF
+              1: // wait for reach low limit then trigger fbHomeToSwitch
+                bHomed:=FALSE;
+                    bSequenceReady:=FALSE;
+                    fbMoveVelocity.Velocity:=ABS(fbHomePrepare.fVelocityToCam);
+            fbMoveVelocity.Direction:=MC_Positive_Direction;
+            bExecuteMoveVelocity:=bExecute;  // Execute MC_MoveVelocity
+                IF NOT bLimitFwd AND NOT fbMoveVelocity.Busy AND Axis.Status.NotMoving THEN //MC_MoveVelocity.Busy goes down when ramp down initiates (not ends).
+                      nHomingState:=2;
+                END_IF
+              2: // Wait for fbHomeToSwitch
+                bHomed:=FALSE;
+                bSequenceReady:=FALSE;
+            bExecuteMoveVelocity:=FALSE;
+            bExecuteHomeToSwitch:=TRUE;
+            fbHomeToSwitch.nSearchDirTwoardsCam:=MC_Negative_Direction;
+            fbHomeToSwitch.nSearchDirOffCam:=MC_Negative_Direction;
+            fbHomeToSwitch.fVelocityToCamNC:=fbHomePrepare.fVelocityToCam; // High speed
+            fbHomeToSwitch.fVelocityFromCamNC:=fbHomePrepare.fVelocityFromCam;  // Low speed
+                fbHomeToSwitch.bCamSensor:=NOT bLimitFwd;
+            IF fbHomeToSwitch.bDone THEN
+                      nHomingState:=3;
+                      bExecuteFinish:=TRUE;
+                      fbHomeFinish.bSofLimEnableHigh:=fbHomePrepare.bSofLimEnableHighOriginal;
+                      fbHomeFinish.bSofLimEnableLow:=fbHomePrepare.bSofLimEnableLowOriginal;
+            END_IF;
+          3: // restore softlimit enable
+            bHomed:=FALSE;
+                bSequenceReady:=FALSE;
+            IF fbHomeFinish.bDone THEN
+                      bRestoreNCDataNeeded:=FALSE;
+              bSequenceReady:=TRUE;
+                      nHomingState:=0;
+                      bHomed:=Axis.Status.Homed;
+            END_IF;
+       END_CASE;
+
+   3: // Home on bHomeSensor via bLimitBwd
+       CASE nHomingState OF
+              0:
+                bHomed:=Axis.Status.Homed;
+            // Wait for read of velocities from NC and reset of calibration flag
+            IF fbHomePrepare.bDone AND bExecute AND NOT bSequenceReady THEN
+                      bRestoreNCDataNeeded:=TRUE;
+                      IF bLimitBwd THEN
+                nHomingState:=1;
+              ELSE
+                            nHomingState:=2;  //Standing on limit switch go direct to state 2
+              END_IF
+            END_IF
+              1: // wait for reach low limit then trigger fbHomeToSwitch
+                bHomed:=FALSE;
+                    bSequenceReady:=FALSE;
+                    fbMoveVelocity.Velocity:=ABS(fbHomePrepare.fVelocityToCam);
+            fbMoveVelocity.Direction:=MC_Negative_Direction;
+            bExecuteMoveVelocity:=bExecute;  // Execute MC_MoveVelocity
+                IF NOT bLimitBwd AND NOT fbMoveVelocity.Busy AND Axis.Status.NotMoving THEN //MC_MoveVelocity.Busy goes down when ramp down initiates (not ends).
+                      nHomingState:=2;
+                END_IF
+              2: // Wait for fbHomeToSwitch
+                bHomed:=FALSE;
+                bSequenceReady:=FALSE;
+            bExecuteMoveVelocity:=FALSE;
+            bExecuteHomeToSwitch:=TRUE;
+            fbHomeToSwitch.nSearchDirTwoardsCam:=MC_Positive_Direction;
+            fbHomeToSwitch.nSearchDirOffCam:=MC_Positive_Direction;
+            fbHomeToSwitch.fVelocityToCamNC:=fbHomePrepare.fVelocityToCam; // High speed
+            fbHomeToSwitch.fVelocityFromCamNC:=fbHomePrepare.fVelocityFromCam;  // Low speed
+                fbHomeToSwitch.bCamSensor:=bHomeSensor;
+            IF fbHomeToSwitch.bDone THEN
+                      nHomingState:=3;
+                      bExecuteFinish:=TRUE;
+                      fbHomeFinish.bSofLimEnableHigh:=fbHomePrepare.bSofLimEnableHighOriginal;
+                      fbHomeFinish.bSofLimEnableLow:=fbHomePrepare.bSofLimEnableLowOriginal;
+            END_IF;
+          3: // restore softlimit enable
+            bHomed:=FALSE;
+                bSequenceReady:=FALSE;
+            IF fbHomeFinish.bDone THEN
+                  bRestoreNCDataNeeded:=FALSE;
+              bSequenceReady:=TRUE;
+                      nHomingState:=0;
+                      bHomed:=Axis.Status.Homed;
+            END_IF;
+       END_CASE;
+    4:  // Home on bHomeSensor via bLimitFwd
+       CASE nHomingState OF
+              0:
+                bHomed:=Axis.Status.Homed;
+            // Wait for read of velocities from NC and reset of calibration flag
+            IF fbHomePrepare.bDone AND bExecute AND NOT bSequenceReady THEN
+                      bRestoreNCDataNeeded:=TRUE;
+                      IF bLimitFwd THEN
+                nHomingState:=1;
+              ELSE
+                            nHomingState:=2;  //Standing on limit switch go direct to state 2
+              END_IF
+            END_IF
+              1: // wait for reach low limit then trigger fbHomeToSwitch
+                bHomed:=FALSE;
+                    bSequenceReady:=FALSE;
+                    fbMoveVelocity.Velocity:=ABS(fbHomePrepare.fVelocityToCam);
+            fbMoveVelocity.Direction:=MC_Positive_Direction;
+            bExecuteMoveVelocity:=bExecute;  // Execute MC_MoveVelocity
+                IF NOT bLimitFwd AND NOT fbMoveVelocity.Busy AND Axis.Status.NotMoving THEN //MC_MoveVelocity.Busy goes down when ramp down initiates (not ends).
+                      nHomingState:=2;
+                END_IF
+              2: // Wait for fbHomeToSwitch
+                bHomed:=FALSE;
+                bSequenceReady:=FALSE;
+            bExecuteMoveVelocity:=FALSE;
+            bExecuteHomeToSwitch:=TRUE;
+            fbHomeToSwitch.nSearchDirTwoardsCam:=MC_Negative_Direction;
+            fbHomeToSwitch.nSearchDirOffCam:=MC_Negative_Direction;
+            fbHomeToSwitch.fVelocityToCamNC:=fbHomePrepare.fVelocityToCam; // High speed
+            fbHomeToSwitch.fVelocityFromCamNC:=fbHomePrepare.fVelocityFromCam;  // Low speed
+                fbHomeToSwitch.bCamSensor:=bHomeSensor;
+            IF fbHomeToSwitch.bDone THEN
+                      nHomingState:=3;
+                      bExecuteFinish:=TRUE;
+                      fbHomeFinish.bSofLimEnableHigh:=fbHomePrepare.bSofLimEnableHighOriginal;
+                      fbHomeFinish.bSofLimEnableLow:=fbHomePrepare.bSofLimEnableLowOriginal;
+            END_IF;
+          3: // Restore softlimit enable
+            bHomed:=FALSE;
+                bSequenceReady:=FALSE;
+            IF fbHomeFinish.bDone THEN
+                      bRestoreNCDataNeeded:=FALSE;
+              bSequenceReady:=TRUE;
+                      nHomingState:=0;
+                      bHomed:=Axis.Status.Homed;
+            END_IF;
+       END_CASE;
+
+   15: //Set current position (simplest homing sequence)
+     bExecuteHomeDirect:=bExecute;
+     bHomed:=Axis.Status.Homed;
+     IF fbHomeDirect.bDone THEN  //Homing ready
+       bExecuteHomeDirect:=FALSE;
+       bSequenceReady:=TRUE;
+     END_IF
+
+ELSE
+  fbHomeToSwitch.bCamSensor:=FALSE;
+  bHomed:=Axis.Status.Homed;
+END_CASE;
+
+// Main homing block
+fbHomeToSwitch(
+    bExecute:=bExecuteHomeToSwitch AND bExecute AND NOT bError AND NOT bExecuteHomeDirect AND NOT bExecuteMoveVelocity,
+    bReset:=bReset,
+    fHomePosition:=fHomePosition,
+    Axis:=Axis
+);
+
+// Approach limit switch (error if MC_Home is used)
+fbMoveVelocity(
+    Execute:= bExecuteMoveVelocity AND bExecute AND NOT bError AND NOT bExecuteHomeToSwitch AND NOT bExecuteHomeDirect,
+    Axis:=Axis
+);
+
+// No sequence, just set position value (nCmdDataLocal=15). Can not run if fbHomeToSwitch is executed
+fbHomeDirect(
+    bExecute:=bExecuteHomeDirect AND bExecute AND NOT bError  AND NOT bExecuteHomeToSwitch AND NOT bExecuteMoveVelocity,
+    bReset:=bReset,
+    fHomePosition:=fHomePosition,
+    Axis:=Axis
+);
+
+
+//############# Finish homing
+
+IF NOT bexecute AND bRestoreNCDataNeeded THEN  //If homing is aborted restore is needed
+    bExecuteFinish:=TRUE;
+    IF fbHomeFinish.bDone THEN
+      bExecuteFinish:=FALSE;
+      bRestoreNCDataNeeded:=FALSE;
+    END_IF
+END_IF
+
+fbHomeFinish(
+  En:=En,
+  bExecute:=bExecuteFinish,
+  bReset:=bReset,
+  Axis:=Axis,
+);
+
+// Error handling
+IF NOT bError THEN
+  IF fbHomeToSwitch.bError THEN
+    bError:=fbHomeToSwitch.bError;
+    nErrorId:=fbHomeToSwitch.nErrorId;
+  ELSIF fbHomeDirect.bError THEN
+    bError:=fbHomeDirect.bError;
+    nErrorId:=fbHomeDirect.nErrorId;
+  ELSIF fbMoveVelocity.Error THEN
+    bError:=fbMoveVelocity.Error;
+    nErrorId:=fbMoveVelocity.ErrorId;
+  END_IF;
+END_IF
+
+// Done and busy bit
+bDone:=bSequenceReady AND bExecute;
+bBusy:=NOT bSequenceReady;
+
+RETURN;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_HomeWriteNcVelocities

+
FUNCTION_BLOCK FB_HomeWriteNcVelocities
+VAR_INPUT
+    En: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+    fVelocityToCam: LREAL;
+    fVelocityFromCam: LREAL;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR
+    fbExecuteRiseEdge: R_TRIG;
+    fbWriteVelocityToCam:FB_WriteFloatParameter;
+    fbWriteVelocityFromCam:FB_WriteFloatParameter;
+END_VAR
+En:=EnO;
+IF bReset THEN
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF
+
+fbExecuteRiseEdge(CLK:=bExecute);
+
+fbWriteVelocityToCam(
+    bExecute:=bExecute,
+    nDeviceGroup:= 16#4000,
+    nIndexOffset:= 16#6,
+    nData:=fVelocityToCam,
+    Axis:= Axis);
+
+fbWriteVelocityFromCam(
+    bExecute:=bExecute,
+    nDeviceGroup:= 16#4000,
+    nIndexOffset:= 16#7,
+    nData:=fVelocityFromCam,
+    Axis:= Axis);
+
+bBusy:=fbWriteVelocityFromCam.bBusy OR fbWriteVelocityToCam.bBusy;
+bDone:=fbWriteVelocityFromCam.bDone AND fbWriteVelocityToCam.bDone AND bExecute;
+
+bError:=fbWriteVelocityToCam.bError OR fbWriteVelocityFromCam.bError;
+IF fbWriteVelocityToCam.bError THEN
+  nErrorId:=fbWriteVelocityToCam.nErrorId;
+ELSIF fbWriteVelocityFromCam.bError THEN
+  nErrorId:=fbWriteVelocityFromCam.nErrorId;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_HomeWriteSoftLimEnable

+
FUNCTION_BLOCK FB_HomeWriteSoftLimEnable
+VAR_INPUT
+    En: BOOL;
+    bReset: BOOL;
+    bExecute: BOOL;
+    bSofLimEnableLow: BOOL:=TRUE;
+    bSofLimEnableHigh: BOOL:=TRUE;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR
+    fbExecuteRiseEdge: R_TRIG;
+    fbWriteSoftLimEnableLow:FB_WriteParameterInNc_v1_00;
+    fbWriteSoftLimEnableHigh:FB_WriteParameterInNc_v1_00;
+END_VAR
+En:=EnO;
+IF bReset THEN
+    bError:=FALSE;
+    nErrorId:=0;
+END_IF
+
+fbExecuteRiseEdge(CLK:=bExecute);
+
+fbWriteSoftLimEnableLow(
+    bExecute:=bExecute,
+    nDeviceGroup:= 16#5000,
+    nIndexOffset:= 16#B,
+    nData:=BOOL_TO_DWORD(bSofLimEnableLow),
+    Axis:= Axis);
+
+fbWriteSoftLimEnableHigh(
+    bExecute:=bExecute,
+    nDeviceGroup:= 16#5000,
+    nIndexOffset:= 16#C,
+    nData:=BOOL_TO_DWORD(bSofLimEnableHigh),
+    Axis:= Axis);
+
+bBusy:=fbWriteSoftLimEnableLow.bBusy OR fbWriteSoftLimEnableHigh.bBusy;
+bDone:=fbWriteSoftLimEnableLow.bDone AND fbWriteSoftLimEnableHigh.bDone AND bExecute;
+
+bError:=fbWriteSoftLimEnableHigh.bError OR fbWriteSoftLimEnableLow.bError;
+IF fbWriteSoftLimEnableHigh.bError THEN
+  nErrorId:=fbWriteSoftLimEnableHigh.nErrorId;
+ELSIF fbWriteSoftLimEnableLow.bError THEN
+  nErrorId:=fbWriteSoftLimEnableLow.nErrorId;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_LogMotionError

+
FUNCTION_BLOCK FB_LogMotionError
+(*
+    If the motion struct has an error, log it.
+
+    The log condition is:
+    - When bError goes TRUE (catch transition from no error to error)
+    - When the error message changes while bError is TRUE (catch transition from error a to error b)
+
+    Includes the motor name and the NC error id in the json blob
+*)
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR_INPUT
+    bEnable: BOOL;
+END_VAR
+VAR
+    fbLogMessage: FB_LogMessage;
+    rtNewError: R_TRIG;
+    bChangedError: BOOL;
+    sPrevErr: STRING;
+    fbJson: FB_JsonSaxWriter;
+END_VAR
+rtNewError(CLK:=stMotionStage.bError);
+bChangedError := stMotionStage.sErrorMessage <> '' AND stMotionStage.sErrorMessage <> sPrevErr;
+sPrevErr := stMotionStage.sErrorMessage;
+
+IF bEnable AND (rtNewError.Q OR bChangedError) THEN
+    fbJson.StartObject();
+    fbJson.AddKey('schema');
+    fbJson.AddString('ST_MotionStage.bError');
+    fbJson.AddKey('dut_name');
+    fbJson.AddString(stMotionStage.sName);
+    fbJson.AddKey('axis_name');
+    fbJson.AddString(stMotionStage.stAxisParameters.sAxisName);
+    fbJson.AddKey('axis_id');
+    fbJson.AddUdint(stMotionStage.stAxisParameters.AxisId);
+    fbJson.AddKey('err_id');
+    fbJson.AddUdint(stMotionStage.nErrorId);
+    fbJson.AddKey('position');
+    fbJson.AddLreal(stMotionStage.stAxisStatus.fActPosition);
+    fbJson.AddKey('position_lag');
+    fbJson.AddLreal(stMotionStage.stAxisStatus.fActDiff);
+    fbJson.EndObject();
+    fbLogMessage.sJson := fbJson.GetDocument();
+    fbLogMessage(
+        sMsg := stMotionStage.sErrorMessage,
+        eSevr := TcEventSeverity.Error,
+        eSubsystem := E_Subsystem.MOTION,
+    );
+    fbJson.ResetDocument();
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_MicroStepCountTest

+
FUNCTION_BLOCK FB_MicroStepCountTest
+VAR_INPUT
+    bExecute: BOOL;
+    fStepSize: LREAL;
+    nSteps: UINT;
+    fMicroStep: LREAL;
+    fVelocity: LREAL;
+    tSettleTime: TIME;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR_OUTPUT
+    nStepsCounted: UINT;
+    nTheorySteps: UINT;
+    fPercent: LREAL;
+    fEstMicroSize: LREAL;
+END_VAR
+VAR
+    fbMoveRel: MC_MoveRelative;
+    fbSettleTimer: TON;
+    bDoMove: BOOL;
+    nStepCounter: UINT;
+
+    arrPosBuffer: ARRAY [0..99] OF LREAL;
+    fAvgPos: LREAL;
+    nArrIndex: UINT;
+    nLoopIndex: UINT;
+
+    fStartPos: LREAL;
+    fPrevPos: LREAL;
+    fStepChange: LREAL;
+
+    fStepSum: LREAL;
+END_VAR
+// Motion FB
+fbMoveRel(Axis:=Axis,
+    Execute:=bDoMove,
+    Distance:=fStepSize,
+    Velocity:=fVelocity);
+
+// Settle time
+fbSettleTimer(IN:=fbMoveRel.Done,
+    PT:=tSettleTime);
+
+// Re-enable the move for next cycle
+bDoMove := bExecute AND nStepCounter < nSteps;
+
+// Calculate rolling average
+arrPosBuffer[nArrIndex] := Axis.NcToPlc.ActPos;
+fAvgPos := 0;
+FOR nLoopIndex := 0 TO 99 DO
+    fAvgPos := fAvgPos + arrPosBuffer[nLoopIndex];
+END_FOR;
+fAvgPos := fAvgPos / 100;
+nArrIndex := (nArrIndex + 1) MOD 100;
+
+// Initialize starting variables
+IF NOT bExecute THEN
+    fStartPos := fAvgPos;
+    fPrevPos := fAvgPos;
+END_IF
+
+// Check results
+IF fbSettleTimer.Q THEN
+    fStepChange := fAvgPos - fPrevPos;
+    // Invert fStepChange if we were doing negative steps
+    IF fStepSize < 0 THEN
+        fStepChange := fStepChange * -1;
+    END_IF
+    IF fStepChange > fMicroStep * 0.5 THEN
+        nStepsCounted := nStepsCounted + 1;
+        fStepSum := fStepSum + fStepChange;
+        fEstMicroSize := fStepSum / nStepsCounted;
+    END_IF
+    nTheorySteps := DINT_TO_UINT(TRUNC(ABS((fStartPos - fAvgPos) / fMicroStep)));
+    IF nTheorySteps > 0 THEN
+        fPercent := 100 * nStepsCounted / nTheorySteps;
+    END_IF
+    fPrevPos := fAvgPos;
+    nStepCounter := nStepCounter + 1;
+    // Reset the move block
+    bDoMove := FALSE;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_MiscStatesErrorFFO

+
FUNCTION_BLOCK FB_MiscStatesErrorFFO
+(*
+    A catch-all for miscellaneous state FFOs that are not better organized elsewhere.
+    Contains the following fast faults:
+    - ffBeamParamsOK: trip the beam if the beam parameters are not safe enough for our current (known) state
+    - ffZeroRate: trip the beam if we've asked for zero rate (as a shortcut)
+    - ffUnknown: trip the beam if we're at an unknown state and our transition id is not asserted.
+    - ffDebounce: trip the beam (no autoreset) if ffBeamParamsOK fast faults fault on and off multiple times too quickly.
+      This solves an issue where ffBeamParamsOK might solve its own problem and creating a blinking fast fault issue.
+
+    The inputs are mostly outputs of non-pmps function blocks and heavily-reused info like state details.
+*)
+VAR_IN_OUT
+    // The arbiter to request beam states from
+    fbArbiter: FB_Arbiter;
+    // The fast fault output to fault to
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    // A name to link to these fast faults
+    sDeviceName: STRING;
+    // Current requested beam details: either a known state or the transition beam
+    stCurrentBeamReq: ST_BeamParams;
+    // TRUE if we're at a known state (doesn't matter which)
+    bKnownState: BOOL;
+    // Lookup ID of the transition beam
+    nTransitionID: DWORD;
+END_VAR
+VAR_OUTPUT
+END_VAR
+VAR CONSTANT
+    // Number of consecutive trips before we debounce
+    nMaxTrips: UINT := 5;
+    // Decrease trip count by 1 after this much time has passed
+    tTripReset: TIME := T#1s;
+END_VAR
+VAR
+    // If the beam parameters are wrong, it is a fault! This encompasses all unknown arbiter-related errors.
+    ffBeamParamsOk: FB_FastFault;
+    // If we asked for zero rate (NC or SC) then we can cut the beam early. This is somewhat redundant.
+    ffZeroRate: FB_FastFault;
+    // Trip the beam for unknown state
+    ffUnknown: FB_FastFault;
+    // Trip the beam (no autoreset) if ffBeamParamsOK faults/resets multiple times too quickly.
+    ffDebounce: FB_FastFault;
+
+    // Number of consecutive trips so far
+    nTripCount: UINT;
+    // Increase by 1 whenever there is a fault (rising edge)
+    ftTripCount: F_TRIG;
+    // Decrease trip count by 1 each timeout
+    tonTripCount: TON;
+    // TRUE on only the first cycle
+    bFirstCycle: BOOL := TRUE;
+END_VAR
+ffBeamParamsOk(
+    i_xOK:=F_SafeBPCompare(PMPS_GVL.stCurrentBeamParameters, stCurrentBeamReq),
+    i_xAutoReset:=TRUE,
+    i_DevName:=sDeviceName,
+    i_Desc:='Beam parameter mismatch',
+    i_TypeCode:=E_MotionFFType.BP_MISMATCH,
+    io_fbFFHWO:=fbFFHWO);
+
+CASE PMPS_GVL.stCurrentBeamParameters.nMachineMode OF
+    // NC mode
+    1: ffZeroRate.i_xOK := stCurrentBeamReq.nRate > 0;
+    // SC mode
+    2: ffZeroRate.i_xOK := stCurrentBeamReq.nBCRange > 0;
+ELSE
+    // Ambiguous or new mode
+    ffZeroRate.i_xOK := stCurrentBeamReq.nRate > 0 AND stCurrentBeamReq.nBCRange > 0;
+END_CASE
+
+ffZeroRate(
+    i_xAutoReset := TRUE,
+    i_DevName := sDeviceName,
+    i_Desc := 'Device requesting zero rate',
+    i_TypeCode := E_MotionFFType.ZERO_RATE,
+    io_fbFFHWO := fbFFHWO,
+);
+
+ffUnknown(
+    i_xOK := bknownState OR fbArbiter.CheckRequestInPool(nReqID:=nTransitionID),
+    i_xAutoReset := TRUE,
+    i_DevName := sDeviceName,
+    i_Desc := 'Unknown position between moves',
+    i_TypeCode := E_MotionFFType.NOT_A_STATE,
+    io_fbFFHWO := fbFFHWO,
+);
+
+ftTripCount(CLK:=ffBeamParamsOk.i_xOK);
+
+IF ftTripCount.Q THEN
+    nTripCount := nTripCount + 1;
+END_IF
+
+tonTripCount(
+    IN:=NOT tonTripCount.Q,
+    PT:=tTripReset,
+);
+IF tonTripCount.Q AND nTripCount > 0 THEN
+    nTripCount := nTripCount - 1;
+END_IF
+
+// This is required for non-autoresetting FBs to come up in a beam permitted state
+ffDebounce.i_xReset S= bFirstCycle;
+ffDebounce(
+    i_xOK := nTripCount < 5,
+    i_xAutoReset := FALSE,
+    i_DevName := sDeviceName,
+    i_Desc := 'Tripped beam parameter mismatch off/on too many times, hold off',
+    i_TypeCode := E_MotionFFType.TOO_MANY_TRIPS,
+    io_fbFFHWO := fbFFHWO,
+);
+ffDebounce.i_xReset R= bFirstCycle;
+bFirstCycle := FALSE;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_MiscStatesErrorFFO_Test

+
FUNCTION_BLOCK FB_MiscStatesErrorFFO_Test EXTENDS TcUnit.FB_TestSuite
+(*
+    Unit tests for FB_MiscStatesErrorFFO
+*)
+VAR
+END_VAR
+TestBeamParamsNotOk();
+TestZeroRate();
+TestUnknownState();
+TestTransitionState();
+TestDebounce();
+
+END_FUNCTION_BLOCK
+
+METHOD TestBeamParamsNotOk
+VAR_INST
+    fbMiscFFO: FB_MiscStatesErrorFFO;
+    fbArbiter: FB_Arbiter(1);
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+
+    stBeamReq: ST_BeamParams;
+END_VAR
+TEST('TestBeamParamsNotOk');
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Started with a fault',
+);
+
+// Trigger only a beam parameter mismatch
+// Do not trip zero rate, unknown state, or debounce
+PMPS_GVL.stCurrentBeamParameters := PMPS_GVL.cstFullBeam;
+stBeamReq := PMPS_GVL.cstFullBeam;
+stBeamReq.nTran := 0.5;
+fbMiscFFO(
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stCurrentBeamReq:=stBeamReq,
+    bKnownState:=TRUE,
+    nTransitionID:=1,
+);
+
+fbFFHWO.EvaluateOutput();
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Did not fault with bad attenuator state',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestDebounce
+VAR_INST
+    fbMiscFFO: FB_MiscStatesErrorFFO;
+    fbArbiter: FB_Arbiter(5);
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+VAR
+    nIter: DINT;
+END_VAR
+TEST('TestDebounce');
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Started with a fault prior to first FB run-through',
+);
+// Ask for full beam: there should be no faults of any kind
+fbMiscFFO(
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stCurrentBeamReq:=PMPS_GVL.cstFullBeam,
+    bKnownState:=TRUE,
+    nTransitionID:=5,
+);
+fbFFHWO.EvaluateOutput();
+
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Started with a fault prior to trip checks',
+);
+
+// Trip and untrip the beam fast fault once, show no fault
+TripUntrip(
+    fbMiscFFO:=fbMiscFFO,
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+);
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Control group failed: one trip/untrip should not be enough to debounce',
+);
+// Trip and untrip the beam fast fault like 10 times, show fault
+FOR nIter := 1 TO 10 DO
+    TripUntrip(
+        fbMiscFFO:=fbMiscFFO,
+        fbArbiter:=fbArbiter,
+        fbFFHWO:=fbFFHWO,
+    );
+END_FOR
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Debouncer failed to debounce',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestTransitionState
+VAR_INST
+    fbMiscFFO: FB_MiscStatesErrorFFO;
+    fbArbiter: FB_Arbiter(4);
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestTransitionState');
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Started with a fault',
+);
+
+// Trigger no faults, we're at an unknown state but it's a transition state
+// Do not trip bad beam, zero rate, or debounce
+fbArbiter.AddRequest(
+    nReqID:=4,
+    stReqBP:=PMPS_GVL.cstFullBeam,
+    sDevName:='UnitTest',
+);
+PMPS_GVL.stCurrentBeamParameters := PMPS_GVL.cstFullBeam;
+fbMiscFFO(
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stCurrentBeamReq:=PMPS_GVL.cstFullBeam,
+    bKnownState:=FALSE,
+    nTransitionID:=4,
+);
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Faulted in unknown states even though we were moving normally',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestUnknownState
+VAR_INST
+    fbMiscFFO: FB_MiscStatesErrorFFO;
+    fbArbiter: FB_Arbiter(3);
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestUnknownState');
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Started with a fault',
+);
+
+// Trigger only an unknown states
+// Do not trip bad beam, zero rate, or debounce
+PMPS_GVL.stCurrentBeamParameters := PMPS_GVL.cstFullBeam;
+fbMiscFFO(
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stCurrentBeamReq:=PMPS_GVL.cstFullBeam,
+    bKnownState:=FALSE,
+    nTransitionID:=3,
+);
+
+fbFFHWO.EvaluateOutput();
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Did not fault with unknown state',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestZeroRate
+VAR_INST
+    fbMiscFFO: FB_MiscStatesErrorFFO;
+    fbArbiter: FB_Arbiter(2);
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+
+    stNoBeam: ST_BeamParams;
+END_VAR
+TEST('TestBeamZeroRate');
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Started with a fault',
+);
+
+// Trigger only a zero rate
+// Do not trip beam parameter mismatch, unknown state, or debounce
+PMPS_GVL.stCurrentBeamParameters := stNoBeam;
+fbMiscFFO(
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stCurrentBeamReq:=PMPS_GVL.cst0RateBeam,
+    bKnownState:=TRUE,
+    nTransitionID:=2
+);
+
+fbFFHWO.EvaluateOutput();
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Did not fault with zero rate',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TripUntrip
+VAR_IN_OUT
+    fbMiscFFO: FB_MiscStatesErrorFFO;
+    fbArbiter: FB_Arbiter;
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR
+    stBeamReq: ST_BeamParams;
+END_VAR
+// Use anything other than 0 rate, which is its own check
+stBeamReq := PMPS_GVL.cstFullBeam;
+stBeamReq.nTran := 0.5;
+// Trip: too much beam!
+PMPS_GVL.stCurrentBeamParameters := PMPS_GVL.cstFullBeam;
+fbMiscFFO(
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stCurrentBeamReq:=stBeamReq,
+    bKnownState:=TRUE,
+    nTransitionID:=5,
+);
+fbFFHWO.EvaluateOutput();
+
+// Untrip: correct beam!
+PMPS_GVL.stCurrentBeamParameters := stBeamReq;
+fbMiscFFO(
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stCurrentBeamReq:=stBeamReq,
+    bKnownState:=TRUE,
+    nTransitionID:=5,
+);
+fbFFHWO.EvaluateOutput();
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_MotionBPTM

+
FUNCTION_BLOCK FB_MotionBPTM
+(*
+    This function block handles the beam parameter transition manager for a group of motors moving together to a destination with shared beam state.
+    stGoalParams and stTransParams are required arguments and must not share IDs with other state parameters in the PLC.
+
+    This is a building block not intended for use outside of lcls-twincat-motion.
+*)
+VAR_IN_OUT
+    // Array of motors that will move for this beam transition
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    // The arbiter to request beam states from
+    fbArbiter: FB_Arbiter;
+    // The fast fault output to fault to
+    fbFFHWO: FB_HardwareFFOutput;
+    // The parameters we want to transition to
+    stGoalParams: ST_DbStateParams;
+    // The parameters we want to use during the transition
+    stTransParams: ST_DbStateParams;
+END_VAR
+VAR_INPUT
+    // The number of motors we're actually using
+    nActiveMotorCount: UINT;
+    // Set to TRUE to use the BPTM, FALSE to stop using the BPTM.
+    bEnable: BOOL;
+    // TRUE if we're at the physical state that matches the goal parameters
+    bAtState: BOOL;
+    // A device name to use in the GUI
+    sDeviceName: STRING;
+    // How long to wait for parameters before timing out
+    tArbiterTimeout: TIME := T#1s;
+    // Whether to fault and move on timeout (TRUE) or to wait (FALSE)
+    bMoveOnArbiterTimeout: BOOL := TRUE;
+    // Set to TRUE when it is safe to reset the BPTM timeout fast fault, to reset it early.
+    bResetBPTMTimeout: BOOL;
+END_VAR
+VAR_OUTPUT
+    // This becomes TRUE when the motors are allowed to move to their destinations.
+    bTransitionAuthorized: BOOL;
+    // This becomes TRUE once the full beam transition is done.
+    bDone: BOOL;
+    // TRUE if we're using a bad motor count
+    bMotorCountError: BOOL;
+END_VAR
+VAR
+    bptm: BeamParameterTransitionManager;
+    bDoneMoving: BOOL;
+    nPrevID: UDINT;
+    nIndex: DINT;
+
+    bInternalAuth: BOOL;
+    bDoneResetQueued: BOOL;
+
+    tonArbiter: TON;
+    bArbiterTimeout: BOOL;
+    ffBPTMTimeoutAndMove: FB_FastFault;
+    ffBPTMError: FB_FastFault;
+END_VAR
+CheckCount();
+IF NOT bMotorCountError THEN
+    SetDoneMoving();
+    IF bEnable THEN
+        RunBPTM();
+        HandleTimeout();
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+ACTION CheckCount:
+// Make sure the motor count is valid (positive, nonzero, less or equal to the max)
+bMotorCountError S= nActiveMotorCount <= 0;
+bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS;
+END_ACTION
+
+ACTION HandleTimeout:
+// Measure the time that the bptm is busy
+tonArbiter(
+    IN:=bptm.bBusy,
+    PT:=tArbiterTimeout,
+    Q=>bArbiterTimeout,
+);
+bTransitionAuthorized := bInternalAuth OR (bArbiterTimeout AND bMoveOnArbiterTimeout);
+
+// Trip the beam for BPTM timeouts if we want to move
+// Only reset at safe beam OR at no bptm errors (some other FF should catch additional issues)
+ffBPTMTimeoutAndMove.i_xOK := NOT (bArbiterTimeout AND bMoveOnArbiterTimeout);
+ffBPTMTimeoutAndMove.i_xReset S= bResetBPTMTimeout OR (bptm.bDone AND NOT bptm.bError);
+ffBPTMTimeoutAndMove(
+    i_DevName := sDeviceName,
+    i_Desc := 'BPTM Timeout',
+    i_TypeCode := E_MotionFFType.BPTM_TIMEOUT,
+    io_fbFFHWO := fbFFHWO,
+);
+END_ACTION
+
+ACTION RunBPTM:
+bptm(
+    fbArbiter:=fbArbiter,
+    i_sDeviceName:=sDeviceName,
+    i_TransitionAssertionID:=stTransParams.nRequestAssertionID,
+    i_stTransitionAssertion:=stTransParams.stBeamParams,
+    i_nRequestedAssertionID:=stGoalParams.nRequestAssertionID,
+    i_stRequestedAssertion:=stGoalParams.stBeamParams,
+    i_xDoneMoving:=bDoneMoving AND bAtState,
+    stCurrentBeamParameters:=PMPS_GVL.stCurrentBeamParameters,
+    q_xTransitionAuthorized=>bInternalAuth,
+    bDone=>bDone,
+);
+
+// Trip the beam for BPTM Errors
+ffBPTMError.i_xOK := NOT bptm.bError;
+ffBPTMError.i_xReset S= bptm.bDone AND NOT bptm.bError;
+ffBPTMError(
+    i_DevName := sDeviceName,
+    i_Desc := 'BPTM error, state transition failed',
+    i_TypeCode := E_MotionFFType.BPTM_ERROR,
+    io_fbFFHWO := fbFFHWO,
+);
+END_ACTION
+
+ACTION SetDoneMoving:
+// Set bDoneMoving if all the motors are done
+bDoneMoving := TRUE;
+FOR nIndex := 1 TO nActiveMotorCount DO
+    bDoneMoving := bDoneMoving AND NOT astMotionStage[nIndex].bBusy AND NOT astMotionStage[nIndex].bExecute;
+END_FOR
+// Reset bDoneMoving if the goal has changed to reset bptm's motor done for an in-place transition
+// This allows us to change to a new beam state without requiring a motor state change
+// BPTM only checks for this "done" transition after the transition has been authorized, so we may need to wait
+bDoneResetQueued S= nPrevID <> stGoalParams.nRequestAssertionID;
+bDoneMoving R= bDoneResetQueued AND bptm.q_xTransitionAuthorized;
+bDoneResetQueued R= bptm.q_xTransitionAuthorized;
+nPrevID := stGoalParams.nRequestAssertionID;
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_MotionBPTM_Test

+
FUNCTION_BLOCK FB_MotionBPTM_Test EXTENDS TcUnit.FB_TestSuite
+(*
+    Test the functionality of the motion bptm,
+    Which is just a bptm wrapped up with a set of n motors.
+    We're basically just making sure that we push the done button at the appropriate time.
+    Direct tests of BPTM itself are reserved for the pmps library.
+
+    The BPTM takes care of these executions across multiple cycles,
+    so these tests must implement timeouts.
+*)
+VAR
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    stGoal1: ST_DbStateParams;
+    stGoal2: ST_DbStateParams;
+    stTrans: ST_DbStateParams;
+    stNoBeam: ST_BeamParams;
+END_VAR
+stGoal1.stBeamParams := PMPS_GVL.cstFullBeam;
+stGoal1.nRequestAssertionID := 1;
+stGoal1.sPmpsState := 'stGoal1';
+stGoal2.stBeamParams := PMPS_GVL.cstFullBeam;
+stGoal2.stBeamParams.nTran := 0.5;
+stGoal2.nRequestAssertionID := 2;
+stGoal2.sPmpsState := 'stGoal2';
+stTrans.stBeamParams := PMPS_GVL.cst0RateBeam;
+stTrans.nRequestAssertionID := 3;
+stTrans.sPmpsState := 'stTrans';
+
+// Just put a blanket global no beam so these won't wait for any changes ever
+PMPS_GVL.stCurrentBeamParameters := stNoBeam;
+TestInit();
+Test3dMove();
+TestNoMove();
+TestCount();
+
+END_FUNCTION_BLOCK
+
+METHOD AssertInPool
+VAR_IN_OUT
+    fbArbiter: FB_Arbiter;
+    stDbStateParams: ST_DbStateParams;
+END_VAR
+VAR_INPUT
+    bInPool: BOOL;
+    sContext: STRING;
+END_VAR
+IF bInPool THEN
+    AssertTrue(
+        fbArbiter.CheckRequestInPool(stDbStateParams.nRequestAssertionID),
+        CONCAT(CONCAT(stDbStateParams.sPmpsState, ' Beam parameters were not in the pool '), sContext),
+    );
+ELSE
+    AssertFalse(
+        fbArbiter.CheckRequestInPool(stDbStateParams.nRequestAssertionID),
+        CONCAT(CONCAT(stDbStateParams.sPmpsState, ' Beam parameters unexpectedly found in the pool '), sContext),
+    );
+END_IF
+END_METHOD
+
+METHOD SetMotorDone
+VAR_INPUT
+END_VAR
+// Force post-move state
+astMotionStage[1].bBusy := FALSE;
+astMotionStage[1].bDone := TRUE;
+astMotionStage[2].bBusy := FALSE;
+astMotionStage[2].bDone := TRUE;
+astMotionStage[3].bBusy := FALSE;
+astMotionStage[3].bDone := TRUE;
+END_METHOD
+
+METHOD SetMotorMoving
+VAR_INPUT
+END_VAR
+// Force a moving but not done state
+astMotionStage[1].bBusy := TRUE;
+astMotionStage[1].bDone := FALSE;
+astMotionStage[2].bBusy := TRUE;
+astMotionStage[2].bDone := FALSE;
+astMotionStage[3].bBusy := TRUE;
+astMotionStage[3].bDone := FALSE;
+END_METHOD
+
+METHOD SetMotorStartup
+VAR_INPUT
+END_VAR
+// Force some sort of default looking state
+astMotionStage[1].bBusy := FALSE;
+astMotionStage[1].bDone := FALSE;
+astMotionStage[2].bBusy := FALSE;
+astMotionStage[2].bDone := FALSE;
+astMotionStage[3].bBusy := FALSE;
+astMotionStage[3].bDone := FALSE;
+END_METHOD
+
+METHOD Test3dMove : BOOL
+(*
+    Can we safely do a 3d move?
+*)
+VAR_INST
+    fbBptm: FB_MotionBPTM;
+    fbArbiter: FB_Arbiter(2);
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbSubSysIO : FB_DummyArbIO;
+
+    nState: UINT;
+    tonTimer: TON;
+END_VAR
+TEST('Test3DMove');
+
+tonTimer(
+    IN:=TRUE,
+    PT:=T#5s,
+);
+IF tonTimer.Q THEN
+    nState := 4;
+END_IF
+
+CASE nState OF
+    0:
+        // Establish baseline at Goal1
+        SetMotorStartup();
+        fbBptm(
+            astMotionStage:=astMotionStage,
+            fbArbiter:=fbArbiter,
+            fbFFHWO:=fbFFHWO,
+            stGoalParams:=stGoal1,
+            stTransParams:=stTrans,
+            nActiveMotorCount:=3,
+            bEnable:=TRUE,
+            bAtState:=TRUE,
+        );
+        IF fbBptm.bDone THEN
+            nState := 1;
+        END_IF
+    1:
+        // Request a move
+        SetMotorStartup();
+        fbBptm(
+            astMotionStage:=astMotionStage,
+            fbArbiter:=fbArbiter,
+            fbFFHWO:=fbFFHWO,
+            stGoalParams:=stGoal2,
+            stTransParams:=stTrans,
+            nActiveMotorCount:=3,
+            bEnable:=TRUE,
+            bAtState:=FALSE,
+        );
+        IF fbBptm.bTransitionAuthorized THEN
+            // We should have transition and goal 2 asserts in
+            AssertInPool(fbArbiter, stGoal1, FALSE, 'with trans auth');
+            AssertInPool(fbArbiter, stGoal2, TRUE, 'with trans auth');
+            AssertInPool(fbArbiter, stTrans, TRUE, 'with trans auth');
+            nState := 2;
+        END_IF
+    2:
+        // Simulate a move
+        SetMotorMoving();
+        fbBptm(
+            astMotionStage:=astMotionStage,
+            fbArbiter:=fbArbiter,
+            fbFFHWO:=fbFFHWO,
+            stGoalParams:=stGoal2,
+            stTransParams:=stTrans,
+            nActiveMotorCount:=3,
+            bEnable:=TRUE,
+            bAtState:=FALSE,
+        );
+        // Same situation as before
+        AssertInPool(fbArbiter, stGoal1, FALSE, 'after move started');
+        AssertInPool(fbArbiter, stGoal2, TRUE, 'after move started');
+        AssertInPool(fbArbiter, stTrans, TRUE, 'after move started');
+        nState := 3;
+    3:
+        // Move is done
+        SetMotorDone();
+        fbBptm(
+            astMotionStage:=astMotionStage,
+            fbArbiter:=fbArbiter,
+            fbFFHWO:=fbFFHWO,
+            stGoalParams:=stGoal2,
+            stTransParams:=stTrans,
+            nActiveMotorCount:=3,
+            bEnable:=TRUE,
+            bAtState:=TRUE,
+        );
+        IF fbBptm.bDone THEN
+            // Dropped the transition assert
+            AssertInPool(fbArbiter, stGoal1, FALSE, 'with move complete');
+            AssertInPool(fbArbiter, stGoal2, TRUE, 'with move complete');
+            AssertInPool(fbArbiter, stTrans, FALSE, 'with move complete');
+            nState := 4;
+        END_IF
+    4:
+        AssertFalse(
+            tonTimer.Q,
+            'Timeout in test',
+        );
+        TEST_FINISHED();
+END_CASE
+
+fbSubSysIO(
+    LA:=fbArbiter,
+    FFO:=fbFFHWO,
+);
+END_METHOD
+
+METHOD TestCount
+(*
+    FB Should just error out if we forgot to give a count
+*)
+VAR_INST
+    fbBptm: FB_MotionBPTM;
+    fbArbiter: FB_Arbiter(1);
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+
+    tonWait: TON;
+END_VAR
+TEST('TestCount');
+
+SetMotorStartup();
+fbBptm(
+    astMotionStage:=astMotionStage,
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stGoalParams:=stGoal1,
+    stTransParams:=stTrans,
+    bEnable:=True,
+    bAtState:=True,
+);
+AssertTrue(
+    fbBptm.bMotorCountError,
+    'Did not properly error on missing motor count',
+);
+
+tonWait(
+    IN:=TRUE,
+    PT:=T#1s,
+);
+IF tonWait.Q THEN
+    // Should have no arbiter activity at all
+    AssertInPool(fbArbiter, stGoal1, FALSE, 'with bad count');
+    AssertInPool(fbArbiter, stGoal2, FALSE, 'with bad count');
+    AssertInPool(fbArbiter, stTrans, FALSE, 'with bad count');
+
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestInit : BOOL
+(*
+    If we initialize with still motors, do we get an arbiter request at the current goal? Hopefully we do.
+*)
+VAR_INST
+    fbBptm: FB_MotionBPTM;
+    fbArbiter: FB_Arbiter(1);
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbSubSysIO : FB_DummyArbIO;
+
+    tonTimer: TON;
+END_VAR
+TEST('TestInit');
+
+SetMotorStartup();
+fbBptm(
+    astMotionStage:=astMotionStage,
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stGoalParams:=stGoal1,
+    stTransParams:=stTrans,
+    nActiveMotorCount:=3,
+    bEnable:=True,
+    bAtState:=True,
+);
+fbSubSysIO(
+    LA:=fbArbiter,
+    FFO:=fbFFHWO,
+);
+
+tonTimer(
+    IN:=TRUE,
+    PT:=T#5s,
+);
+IF tonTimer.Q OR fbBptm.bDone THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    // We should have a request in the pool for goal 1 but not for transition
+    // If no request are in the pool, we may come up in a no protection state!
+    // If both requests are in the pool, we may come up in a too much blocking beam state!
+    AssertInPool(fbArbiter, stGoal1, TRUE, 'at startup');
+    AssertInPool(fbArbiter, stTrans, FALSE, 'at startup');
+
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestNoMove
+(*
+    In place transitions should work at startup and also at done positions.
+*)
+VAR_INST
+    fbBptm: FB_MotionBPTM;
+    fbArbiter: FB_Arbiter(1);
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbSubSysIO : FB_DummyArbIO;
+
+    nState: UINT;
+    tonTimer: TON;
+END_VAR
+TEST('TestNoMove');
+
+tonTimer(
+    IN:=TRUE,
+    PT:=T#5s,
+);
+IF tonTimer.Q THEN
+    nState := 3;
+END_IF
+
+CASE nState OF
+    0:
+        SetMotorStartup();
+        fbBptm(
+            astMotionStage:=astMotionStage,
+            fbArbiter:=fbArbiter,
+            fbFFHWO:=fbFFHWO,
+            stGoalParams:=stGoal1,
+            stTransParams:=stTrans,
+            nActiveMotorCount:=3,
+            bEnable:=True,
+            bAtState:=True,
+        );
+        IF fbBptm.bDone THEN
+            nState := 1;
+        END_IF
+    1:
+        SetMotorStartup();
+        // NOTE: we kept bAtState TRUE the whole time, so this should be a completed in-place transition
+        fbBptm(
+            astMotionStage:=astMotionStage,
+            fbArbiter:=fbArbiter,
+            fbFFHWO:=fbFFHWO,
+            stGoalParams:=stGoal2,
+            stTransParams:=stTrans,
+            nActiveMotorCount:=3,
+            bEnable:=True,
+            bAtState:=True,
+        );
+        IF fbBptm.bDone THEN
+            // Only Goal2 should be in the pool
+            AssertInPool(fbArbiter, stGoal1, FALSE, 'after switching goals (1)');
+            AssertInPool(fbArbiter, stGoal2, TRUE, 'after switching goals (1)');
+            AssertInPool(fbArbiter, stTrans, FALSE, 'after switching goals (1)');
+            nState := 2;
+        END_IF
+    2:
+        // Repeat from a done position!
+        SetMotorDone();
+        fbBptm(
+            astMotionStage:=astMotionStage,
+            fbArbiter:=fbArbiter,
+            fbFFHWO:=fbFFHWO,
+            stGoalParams:=stGoal1,
+            stTransParams:=stTrans,
+            nActiveMotorCount:=3,
+            bEnable:=True,
+            bAtState:=True,
+        );
+        IF fbBptm.bDone THEN
+            // Only Goal1 should be in the pool
+            AssertInPool(fbArbiter, stGoal1, TRUE, 'after switching goals (2)');
+            AssertInPool(fbArbiter, stGoal2, FALSE, 'after switching goals (2)');
+            AssertInPool(fbArbiter, stTrans, FALSE, 'after switching goals (2)');
+            nState := 3;
+        END_IF
+    3:
+        AssertFalse(
+            tonTimer.Q,
+            'Timeout in test',
+        );
+        TEST_FINISHED();
+END_CASE
+
+fbSubSysIO(
+    LA:=fbArbiter,
+    FFO:=fbFFHWO,
+);
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_MotionClearAsserts

+
FUNCTION_BLOCK FB_MotionClearAsserts
+(*
+    Clear all of the PMPS asserts related to a states mover.
+*)
+VAR_IN_OUT
+    // All states to deactivate: transition + the static position states
+    astDbStateParams: ARRAY[0..GeneralConstants.MAX_STATES] OF ST_DbStateParams;
+    // The arbiter who made the PMPS assert requests
+    fbArbiter: FB_ARBITER;
+END_VAR
+VAR_INPUT
+    // Clear asserts on rising edge
+    bExecute: BOOL;
+END_VAR
+VAR_OUTPUT
+END_VAR
+VAR
+    rtExec: R_TRIG;
+    nIter: DINT;
+END_VAR
+rtExec(CLK:=bExecute);
+IF rtExec.Q THEN
+    FOR nIter := 0 TO GeneralConstants.MAX_STATES DO
+        fbArbiter.RemoveRequest(astDbStateParams[nIter].nRequestAssertionID);
+    END_FOR
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_MotionClearAsserts_Test

+
FUNCTION_BLOCK FB_MotionClearAsserts_Test EXTENDS TcUnit.FB_TestSuite
+VAR
+END_VAR
+TestBasic();
+
+END_FUNCTION_BLOCK
+
+METHOD TestBasic
+VAR
+    nIter: UINT;
+END_VAR
+VAR_INST
+    fbClear: FB_MotionClearAsserts;
+    astDbStateParams: ARRAY[0..GeneralConstants.MAX_STATES] OF ST_DbStateParams;
+    fbArbiter: FB_Arbiter(1);
+END_VAR
+TEST('TestBasic');
+
+FOR nIter := 0 TO GeneralConstants.MAX_STATES DO
+    astDbStateParams[nIter].nRequestAssertionID := 100 + nIter;
+    fbArbiter.AddRequest(
+        nReqID:=100 + nIter,
+        stReqBP:=PMPS_GVL.cstFullBeam,
+        sDevName:='UnitTest',
+    );
+END_FOR
+
+FOR nIter := 0 TO GeneralConstants.MAX_STATES DO
+    AssertTrue(
+        fbArbiter.CheckRequestInPool(100 + nIter),
+        CONCAT(CONCAT('State ', UDINT_TO_STRING(nIter)), ' was not in the pool'),
+    );
+END_FOR
+
+fbClear(
+    astDbStateParams:=astDbStateParams,
+    fbArbiter:=fbArbiter,
+    bExecute:=TRUE,
+);
+
+FOR nIter := 0 TO GeneralConstants.MAX_STATES DO
+    AssertFalse(
+        fbArbiter.CheckRequestInPool(100 + nIter),
+        CONCAT(CONCAT('State ', UDINT_TO_STRING(nIter)), ' was not cleared from the pool'),
+    );
+END_FOR
+
+TEST_FINISHED();
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_MotionHoming

+
FUNCTION_BLOCK FB_MotionHoming
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR_INPUT
+    bExecute: BOOL;
+END_VAR
+VAR_OUTPUT
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorID: UDINT;
+END_VAR
+VAR
+    fbSetPos: MC_SetPosition;
+    fbJog: MC_Jog;
+    rtExec: R_TRIG;
+    ftExec: F_TRIG;
+    nHomeStateMachine: INT := IDLE;
+    nStateAfterStop: INT;
+    nMoves: INT;
+    bFirstDirection: BOOL;
+    bAtHome: BOOL;
+    bMove: BOOL;
+    nErrCount: INT;
+    bInterrupted: BOOL;
+END_VAR
+VAR CONSTANT
+    IDLE: INT := 0;
+    NEXT_MOVE: INT := 1;
+    CHECK_FWD: INT := 2;
+    CHECK_BWD: INT := 3;
+    FINAL_MOVE: INT := 4;
+    FINAL_SETPOS: INT := 5;
+    ERROR: INT := 6;
+    WAIT_STOP: INT := 7;
+
+    (*
+        This is a simpler way of disabling the soft limits that ends up being really obvious if something has gone wrong.
+        If you turn the limits off/on, not only do you need to keep track of if you had soft limits set,
+        but you need to always restore this properly or risk some issue.
+        Instead, I set position to a ridiculous value that can always move forward or backward.
+        If this gets stuck for any reason it's very clear that something has gone wrong,
+        rather than a silent failure of the soft limit marks.
+    *)
+    FWD_START: LREAL := -99999999;
+    BWD_START: LREAL :=  99999999;
+END_VAR
+fbSetPos.Options.ClearPositionLag := TRUE;
+rtExec(CLK:=bExecute);
+ftExec(CLK:=bExecute);
+
+bError R= NOT bExecute;
+IF NOT bError THEN
+    nErrorID := 0;
+END_IF
+
+CASE stMotionStage.nHomingMode OF
+    E_EpicsHomeCmd.LOW_LIMIT:
+        bFirstDirection := FALSE;
+        bAtHome := NOT stMotionStage.bLimitBackwardEnable;
+        bMove := TRUE;
+    E_EpicsHomeCmd.HIGH_LIMIT:
+        bFirstDirection := TRUE;
+        bAtHome := NOT stMotionStage.bLimitForwardEnable;
+        bMove := TRUE;
+    E_EpicsHomeCmd.HOME_VIA_LOW:
+        bFirstDirection := FALSE;
+        bAtHome := stMotionStage.bHome;
+        bMove := TRUE;
+    E_EpicsHomeCmd.HOME_VIA_HIGH:
+        bFirstDirection := TRUE;
+        bAtHome := stMotionStage.bHome;
+        bMove := TRUE;
+    E_EpicsHomeCmd.ABSOLUTE_SET:
+        fbSetPos(
+            Axis:=stMotionStage.Axis,
+            Execute:=bExecute,
+            Position:=stMotionStage.fHomePosition);
+        bBusy := rtExec.Q;
+        bDone := NOT rtExec.Q;
+        bMove := FALSE;
+    E_EpicsHomeCmd.NONE:
+        bMove := FALSE;
+        bBusy := rtExec.Q;
+        bDone := NOT rtExec.Q;
+    ELSE
+        bMove := FALSE;
+END_CASE
+
+IF bMove THEN
+    IF bBusy AND ftExec.Q THEN
+        nHomeStateMachine := ERROR;
+        bInterrupted := TRUE;
+    END_IF
+    CASE nHomeStateMachine OF
+        // Wait for a rising edge
+        IDLE:
+            bBusy := FALSE;
+            nErrCount := 0;
+            fbSetPos(
+                Axis:=stMotionStage.Axis,
+                Execute:=FALSE);
+            fbJog(
+                Axis:=stMotionStage.Axis,
+                JogForward:=FALSE,
+                JogBackwards:=FALSE);
+            IF rtExec.Q THEN
+                nHomeStateMachine := NEXT_MOVE;
+                nMoves := 0;
+                bDone := FALSE;
+                bBusy := TRUE;
+                bError := FALSE;
+                nErrorID := 0;
+                bInterrupted := FALSE;
+            END_IF
+        // Figure out whether to move forward, move backward, or give up
+        NEXT_MOVE:
+            fbSetPos(
+                Axis:=stMotionStage.Axis,
+                Execute:=FALSE);
+            fbJog(
+                Axis:=stMotionStage.Axis,
+                JogForward:=FALSE,
+                JogBackwards:=FALSE);
+            CASE nMoves OF
+                0:
+                    IF bFirstDirection THEN
+                        nStateAfterStop := CHECK_FWD;
+                    ELSE
+                        nStateAfterStop := CHECK_BWD;
+                    END_IF
+                1:
+                    IF NOT bFirstDirection THEN
+                        nStateAfterStop := CHECK_FWD;
+                    ELSE
+                        nStateAfterStop := CHECK_BWD;
+                    END_IF
+                ELSE
+                    nStateAfterStop := ERROR;
+            END_CASE
+            nMoves := nMoves + 1;
+            IF bAtHome THEN
+                nStateAfterStop := FINAL_MOVE;
+            END_IF
+            nHomeStateMachine := WAIT_STOP;
+        // Move forward until we find the home signal or reach end of travel
+        CHECK_FWD:
+            fbSetPos(
+                Axis:=stMotionStage.Axis,
+                Execute:=TRUE,
+                Position:=FWD_START);
+            fbJog(
+                Axis:=stMotionStage.Axis,
+                JogForward:=stMotionStage.bLimitForwardEnable AND NOT bATHome,
+                JogBackwards:=FALSE,
+                Mode:=E_JogMode.MC_JOGMODE_CONTINOUS,
+                Velocity:=stMotionStage.stAxisParameters.fRefVeloSearch);
+            IF NOT fbJog.JogForward THEN
+                nHomeStateMachine := NEXT_MOVE;
+            ELSIF fbJog.Error THEN
+                fbJog(
+                    Axis:=stMotionStage.Axis,
+                    JogForward:=FALSE,
+                    JogBackwards:=FALSE);
+                nErrCount := nErrCount + 1;
+                IF nErrCount >= 3 THEN
+                    nHomeStateMachine := ERROR;
+                END_IF
+            END_IF
+        // Move backward until we find the home signal or reach end of travel
+        CHECK_BWD:
+            fbSetPos(
+                Axis:=stMotionStage.Axis,
+                Execute:=TRUE,
+                Position:=BWD_START);
+            fbJog(
+                Axis:=stMotionStage.Axis,
+                JogForward:=FALSE,
+                JogBackwards:=stMotionStage.bLimitBackwardEnable AND NOT bATHome,
+                Mode:=E_JogMode.MC_JOGMODE_CONTINOUS,
+                Velocity:=stMotionStage.stAxisParameters.fRefVeloSearch);
+            IF NOT fbJog.JogBackwards THEN
+                nHomeStateMachine := NEXT_MOVE;
+            ELSIF fbJog.Error THEN
+                fbJog(
+                    Axis:=stMotionStage.Axis,
+                    JogForward:=FALSE,
+                    JogBackwards:=FALSE);
+                nErrCount := nErrCount + 1;
+                IF nErrCount >= 3 THEN
+                    nHomeStateMachine := ERROR;
+                END_IF
+            END_IF
+        // Set position to get within soft lims, move slowly off signal
+        FINAL_MOVE:
+            fbSetPos(
+                Axis:=stMotionStage.Axis,
+                Execute:=TRUE,
+                Position:=stMotionStage.fHomePosition);
+            IF bAtHome THEN
+                fbJog(
+                    Axis:=stMotionStage.Axis,
+                    JogForward:=NOT bFirstDirection,
+                    JogBackwards:=bFirstDirection,
+                    Mode:=E_JogMode.MC_JOGMODE_CONTINOUS,
+                    Velocity:=stMotionStage.stAxisParameters.fRefVeloSync);
+            ELSIF fbJog.Error THEN
+                fbJog(
+                    Axis:=stMotionStage.Axis,
+                    JogForward:=FALSE,
+                    JogBackwards:=FALSE);
+                nErrCount := nErrCount + 1;
+                IF nErrCount >= 3 THEN
+                    nHomeStateMachine := ERROR;
+                END_IF
+            ELSE
+                fbJog(
+                    Axis:=stMotionStage.Axis,
+                    JogForward:=FALSE,
+                    JogBackwards:=FALSE);
+                fbSetPos(
+                    Axis:=stMotionStage.Axis,
+                    Execute:=FALSE);
+                nHomeStateMachine := WAIT_STOP;
+                nStateAfterStop := FINAL_SETPOS;
+            END_IF
+        FINAL_SETPOS:
+            fbSetPos(
+                Axis:=stMotionStage.Axis,
+                Execute:=TRUE,
+                Position:=stMotionStage.fHomePosition);
+            nHomeStateMachine := IDLE;
+            bBusy := FALSE;
+            bDone := TRUE;
+        ERROR:
+            bError := TRUE;
+            nErrorID := fbJog.ErrorID;
+            nHomeStateMachine := FINAL_SETPOS;
+            fbSetPos(
+                Axis:=stMotionStage.Axis,
+                Execute:=FALSE);
+            IF bInterrupted THEN
+                stMotionStage.sCustomErrorMessage := 'Homing interrupted';
+            ELSE
+                stMotionStage.sCustomErrorMessage := 'Homing failure';
+            END_IF
+        WAIT_STOP:
+            IF stMotionStage.Axis.Status.NotMoving THEN
+                nHomeStateMachine := nStateAfterStop;
+            END_IF
+    END_CASE
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_MotionPneumaticActuator

+
(*This function blcok implements a pnuematic actuator. That can be signle or double acting by setting the ibSingleCntrl accordingly*)
+(* with double acting ibCntrlHold signal should be false, while with single acting the signal should be true*)
+FUNCTION_BLOCK FB_MotionPneumaticActuator
+VAR_INPUT
+    (*EPS Interlock Bits*)
+    ibInsertOK: BOOL; (*Actuator can be Inserted*)
+    ibRetractOK: BOOL; (*ACtuator can be retracted*)
+    ibPMPS_OK:BOOL; (*to be linked the Arbiter bit*)
+    ibSingleCntrl:BOOL;(* TRUE if Actuator requires one Output signal to be activated, FALSE if its double acting i.e two outputs are required*)
+    ibCntrlHold:BOOL; (* Control Signal must retain its value, must be TRUE in the case of single acting*)
+    ibOverrideInterlock:BOOL; (*if true interlocks are ignored*)
+    // Reset fault
+    {attribute 'pytmc' := '
+    pv: FFO_Reset
+    '}
+    i_xReset: BOOL;
+    {attribute 'pytmc' := '
+    pv: FFO_AutoReset
+    '}
+    i_xAutoReset: BOOL;
+END_VAR
+VAR_OUTPUT
+    {attribute 'pytmc' := '
+    pv:
+    '}
+    stPneumaticActuator    :    ST_MotionPneumaticActuator;
+    {attribute 'pytmc' := '
+     pv: MPS_OK
+     field: ZNAM FALSE
+     field: ONAM TRUE
+     field: DESC TRUE if MPS signal is OK
+    '}
+    xMPS_OK:BOOL;
+END_VAR
+VAR_IN_OUT
+    io_fbFFHWO    :    FB_HardwareFFOutput;
+END_VAR
+VAR
+    // PMPS
+    fbFF    :    FB_FastFault :=(
+        i_DevName := 'MPA',
+        i_Desc := 'Fault occurs when the device is moving',
+        i_TypeCode := E_MotionFFType.PNEUMATIC_MOVE);
+
+    (*Init*)
+    xFirstPass    :    BOOL;
+    fbFSInit        :    R_TRIG;
+
+    (* Timeouts*)
+    tTimeOutDuration: TIME:= T#10S;
+    tInserttimeout: TON;
+    tRetracttimeout:TON;
+    (*Limit switch latch timer*)
+    tLimitSwitchLatchDuration: TIME:=T#1S;
+    tInsertLimitSwitch:TON;
+    tRetractLimitSwitch:TON;
+
+    (*Logging*)
+    fbLogger : FB_LogMessage := (eSubsystem:=E_SubSystem.MOTION);
+    ePrevState : E_PnuematicActuatorPositionState;
+    tAction : R_TRIG; // Primary action of this device (Insert_DO, Retract_DO, etc.)
+    tOverrideActivated : R_TRIG;
+
+    (*IO*)
+    i_xInsertedLS    AT%I*: BOOL;
+    i_xRetractedLS    AT%I*: BOOL;
+    q_xInsert_DO    AT%Q*: BOOL;
+    q_xRetract_DO    AT%Q*: BOOL;
+
+END_VAR
+(*Initialize*)
+fbFSInit( CLK := TRUE, Q => xFirstPass);
+IF xFirstPass THEN
+    stPneumaticActuator.eState := E_PnuematicActuatorPositionState.INVALID;
+    stPneumaticActuator.bRetract_SW := FALSE;
+    stPneumaticActuator.bInsert_SW := FALSE;
+END_IF
+
+(*Soft IO Mapping to EPICS PVs*)
+ACT_IO();
+
+(* Manage States*)
+IF stPneumaticActuator.i_bInLimitSwitch AND  stPneumaticActuator.i_bOutLimitSwitch THEN
+    stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.INVALID;
+ELSIF NOT stPneumaticActuator.i_bInLimitSwitch AND stPneumaticActuator.i_bOutLimitSwitch THEN
+    stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.RETRACTED;
+ELSIF stPneumaticActuator.i_bInLimitSwitch AND NOT stPneumaticActuator.i_bOutLimitSwitch THEN
+    stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.INSERTED;
+ELSIF NOT stPneumaticActuator.i_bInLimitSwitch AND NOT stPneumaticActuator.i_bOutLimitSwitch THEN
+    stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.MOVING;
+ELSE
+    stPneumaticActuator.eState:=E_PnuematicActuatorPositionState.INVALID ;
+END_IF
+
+(*Set the Done/Busy signal*)
+stPneumaticActuator.bDone := (stPneumaticActuator.bRetract_SW AND stPneumaticActuator.eState=E_PnuematicActuatorPositionState.RETRACTED)
+                            OR (stPneumaticActuator.bInsert_SW AND stPneumaticActuator.eState=E_PnuematicActuatorPositionState.INSERTED);
+stPneumaticActuator.bBusy := (stPneumaticActuator.bRetract_SW AND stPneumaticActuator.eState<>E_PnuematicActuatorPositionState.RETRACTED)
+                            OR (stPneumaticActuator.bInsert_SW AND stPneumaticActuator.eState<>E_PnuematicActuatorPositionState.INSERTED);
+(*MPS FAULT*)
+(* MPS Faults when the actuator is in motion*)
+xMPS_OK := (stPneumaticActuator.eState=E_PnuematicActuatorPositionState.RETRACTED) OR (stPneumaticActuator.eState=E_PnuematicActuatorPositionState.INSERTED);
+(*PMPS PERMISSION*)
+// yet to be implemented
+
+(* Can't have bRetract_SW and  bInsert_SW both be true*)
+If (stPneumaticActuator.bRetract_SW) AND (stPneumaticActuator.bInsert_SW) THEN
+    stPneumaticActuator.bRetract_SW := FALSE;
+    stPneumaticActuator.bInsert_SW := FALSE;
+END_IF
+//Redundant??
+(*Check if both digital outputs active at the same time, and clear all*)
+IF stPneumaticActuator.q_bInsert THEN
+    stPneumaticActuator.q_bRetract := FALSE;
+    stPneumaticActuator.bRetract_SW:= FALSE;
+END_IF;
+IF stPneumaticActuator.q_bRetract THEN
+    stPneumaticActuator.q_bInsert := FALSE;
+    stPneumaticActuator.bInsert_SW:= FALSE;
+END_IF;
+
+(*Actuate the device*)
+stPneumaticActuator.q_bRetract := stPneumaticActuator.bRetractOK AND stPneumaticActuator.bRetract_SW AND NOT stPneumaticActuator.bInsert_SW ;
+stPneumaticActuator.q_bInsert := stPneumaticActuator.bInsertOK AND stPneumaticActuator.bInsert_SW AND NOT stPneumaticActuator.bRetract_SW ;
+
+(*Reset the Control signal when command has been executed and give time to ensure the actuator is fully seated in either direction*)
+IF (NOT ibSingleCntrl AND NOT ibCntrlHold) THEN
+   IF (stPneumaticActuator.bRetract_SW AND stPneumaticActuator.i_bOutLimitSwitch AND tRetractLimitSwitch.Q ) THEN stPneumaticActuator.q_bRetract := FALSE; END_IF
+   IF (stPneumaticActuator.bInsert_SW AND stPneumaticActuator.i_bInLimitSwitch AND tInsertLimitSwitch.Q) THEN stPneumaticActuator.q_bInsert := FALSE; END_IF
+END_IF
+
+(*Timers*)
+tInserttimeout(IN:= stPneumaticActuator.q_bInsert, PT := tTimeOutDuration );
+tRetracttimeout(IN:= stPneumaticActuator.q_bRetract, PT := tTimeOutDuration);
+tInsertLimitSwitch(IN:= stPneumaticActuator.i_bInLimitSwitch, PT := tLimitSwitchLatchDuration);
+tRetractLimitSwitch(IN:= stPneumaticActuator.i_bOutLimitSwitch, PT := tLimitSwitchLatchDuration);
+
+
+///Check moving postion timout
+IF NOT stPneumaticActuator.i_bInLimitSwitch AND tInserttimeout.Q THEN
+    stPneumaticActuator.bError := TRUE;
+    stPneumaticActuator.sErrorMessage:= 'Actuator insert timeout';
+ELSIF NOT stPneumaticActuator.i_bOutLimitSwitch AND tRetracttimeout.Q THEN
+    stPneumaticActuator.bError := TRUE;
+    stPneumaticActuator.sErrorMessage:= 'Actuator retract timeout';
+END_IF
+// Reset error
+stPneumaticActuator.bError R= stPneumaticActuator.bReset;
+
+(*FAST FAULT*)
+fbFF(i_xOK := xMPS_OK,
+    i_xReset := i_xReset,
+    i_xAutoReset := i_xAutoReset,
+    io_fbFFHWO := io_fbFFHWO);
+
+(*Soft IO Mapping to Epics pvs*)
+ACT_IO();
+
+END_FUNCTION_BLOCK
+
+ACTION ACT_IO:
+(*Inputs*)
+stPneumaticActuator.i_bInLimitSwitch :=  i_xInsertedLS;
+stPneumaticActuator.i_bOutLimitSwitch := i_xRetractedLS;
+
+(*outputs*)
+q_xInsert_DO:=stPneumaticActuator.q_bInsert;
+q_xRetract_DO:=stPneumaticActuator.q_bRetract;
+
+(*EPICS*)
+stPneumaticActuator.bRetractOK := ibRetractOK;
+stPneumaticActuator.bInsertOK := ibInsertOK;
+END_ACTION
+
+ACTION ACT_Logger:
+// Log Valve timeouts
+IF (tInserttimeout.Q OR tRetracttimeout.Q) THEN fbLogger(sMsg:=stPneumaticActuator.sErrorMessage, eSevr:=TcEventSeverity.Warning); END_IF
+
+// Log Actuator commands
+// Log valve open
+tAction(CLK:= (stPneumaticActuator.q_bRetract OR stPneumaticActuator.q_bInsert));
+IF tAction.Q THEN
+   IF(stPneumaticActuator.q_bRetract) THEN fbLogger(sMsg:='Actuator commanded retract', eSevr:=TcEventSeverity.Info); END_IF
+   IF(stPneumaticActuator.q_bInsert) THEN fbLogger(sMsg:='Actuator commanded insert', eSevr:=TcEventSeverity.Info); END_IF
+END_IF
+
+
+// State Logging
+IF ePrevState <> stPneumaticActuator.eState THEN
+      CASE stPneumaticActuator.eState OF
+        E_PnuematicActuatorPositionState.INVALID:
+            fbLogger(sMsg:='Actuator invalid position.', eSevr:=TcEventSeverity.Critical);
+          E_PnuematicActuatorPositionState.MOVING:
+            fbLogger(sMsg:='Actuator moving', eSevr:=TcEventSeverity.Warning);
+        E_PnuematicActuatorPositionState.RETRACTED:
+            fbLogger(sMsg:='Actuator Retracted.', eSevr:=TcEventSeverity.Info);
+        E_PnuematicActuatorPositionState.INSERTED:
+            fbLogger(sMsg:='Actuator Inserted.', eSevr:=TcEventSeverity.Info);
+      END_CASE
+      ePrevState := stPneumaticActuator.eState;
+  END_IF
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_MotionReadPMPSDBND

+
FUNCTION_BLOCK FB_MotionReadPMPSDBND
+(*
+    When we read the JSON PMPS database file, update the lookup parameters for one state mover.
+    It is a building block not meant for use outside of lcls-twincat-motion.
+
+    This is intended to support one N-dimensional state motion function block.
+    The keys for the database lookup can be set on any of the motor's position states.
+    Each of them have an allocated state.stPMPS.sPmpsState STRING parameter.
+    If there is a conflict and two of the motors disagree on parameter lookups, that will
+    be a fast fault.
+
+    When the global JSON read function block is no longer busy and has no errors,
+    we will assume that the file has been read and we will update the parameters here.
+
+    This will also re-read in the event that the input position state keys change in any way,
+    provided that we've read once before.
+*)
+VAR_IN_OUT
+    // Each motor's respective position states along its direction. These will not be modified.
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Hardware output to fault to if there is a problem.
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    // The database lookup key for the transition state. This has no corresponding ST_PositionState.
+    sTransitionKey: STRING;
+    // A name to use for fast faults, etc.
+    sDeviceName: STRING;
+    // For debug: set this to TRUE in online mode to read the database immediately.
+    bReadNow: BOOL;
+END_VAR
+VAR_OUTPUT
+    // The raw lookup results from this FB. Index 0 is the transition beam, the rest of the indices match the state positions.
+    astDbStateParams: ARRAY[0..GeneralConstants.MAX_STATES] OF ST_DbStateParams;
+    // TRUE if we've had at least one successful read.
+    bFirstReadDone: BOOL;
+    // This will be set to TRUE if there was an error reading from the database.
+    bError: BOOL;
+END_VAR
+VAR
+    ffError: FB_FastFault;
+    fbReadPmpsDb: FB_JsonDocToSafeBP;
+    ftDbBusy: F_TRIG;
+    ftRead: F_TRIG;
+    bReadPmpsDb: BOOL;
+    nIterMotor: DINT;
+    nIterState: DINT;
+    nIterState2: DINT;
+    sLoopNewKey: STRING;
+    sLoopPrevKey: STRING;
+    abStateError: ARRAY[0..GeneralConstants.MAX_STATES] OF BOOL;
+    asLookupKeys: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING;
+    asPrevLookupKeys: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING;
+    bNewKeys: BOOL;
+    sTempBackfill: STRING;
+END_VAR
+SelectLookupKeys();
+ReadDatabase();
+RunFastFaults();
+BackfillInfo();
+
+END_FUNCTION_BLOCK
+
+ACTION BackfillInfo:
+// Put the results of the PMPS lookup back to the motion states
+// This is purely for debugging purposes, as only the astDbStateParams output is used by the libraries.
+
+// Copy everything except for the lookup key: avoid clobbering the user's original keys
+// Do it this way instead of one element at a time to be forwards-compatible with any future additions to the db struct
+FOR nIterState := 1 TO GeneralConstants.MAX_STATES DO
+    FOR nIterMotor := 1 TO MotionConstants.MAX_STATE_MOTORS DO
+        sTempBackfill := astPositionState[nIterMotor][nIterState].stPMPS.sPmpsState;
+        astPositionState[nIterMotor][nIterState].stPMPS := astDbStateParams[nIterState];
+        astPositionState[nIterMotor][nIterState].stPMPS.sPmpsState := sTempBackfill;
+    END_FOR
+END_FOR
+END_ACTION
+
+ACTION ReadDatabase:
+// Read the database at the right timing
+ftDbBusy(CLK:=MOTION_GVL.fbPmpsFileReader.bBusy);
+IF ftDbBusy.Q THEN
+    bReadPmpsDb S= NOT MOTION_GVL.fbPmpsFileReader.bError;
+END_IF
+
+bReadPmpsDb S= bFirstReadDone AND bNewKeys;
+bReadPmpsDb S= bReadNow;
+bReadNow := FALSE;
+
+fbReadPmpsDb(
+    bExecute:=bReadPmpsDb,
+    jsonDoc:=PMPS_GVL.BP_jsonDoc,
+    sDeviceName:=sDeviceName,
+    io_fbFFHWO:=fbFFHWO,
+    arrStates:=astDbStateParams,
+);
+bReadPmpsDb R= NOT fbReadPmpsDb.bBusy;
+
+ftRead(CLK:=fbReadPmpsDb.bBusy);
+bFirstReadDone S= ftRead.Q AND NOT fbReadPmpsDb.bError;
+END_ACTION
+
+ACTION RunFastFaults:
+ffError(
+    i_xOK:=NOT bError,
+    i_xAutoReset:=TRUE,
+    i_DevName:=sDeviceName,
+    i_Desc:='Programmer error selecting state names in ND motion FB',
+    i_TypeCode:=E_MotionFFType.INTERNAL_ERROR,
+    io_fbFFHWO:=fbFFHWO,
+);
+END_ACTION
+
+ACTION SelectLookupKeys:
+// Fill the lookup key information in astDbStateParams based on the strings from astPositionState and sTransitionKey.
+
+// Start by emptying any pre-existing values
+FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO
+    asLookupKeys[nIterState] := '';
+    abStateError[nIterState] := FALSE;
+END_FOR
+
+// Transition key is simple
+asLookupKeys[0] := sTransitionKey;
+
+// The other keys might be at different points in the astPositionState array.
+// Try all of the posibilities, set error if we end up overwriting something.
+
+// Outer loop: index of each motor at this position state
+FOR nIterMotor := 1 TO MotionConstants.MAX_STATE_MOTORS DO
+    // Inner loop: index of each position state for this motor
+    FOR nIterState := 1 TO GeneralConstants.MAX_STATES DO
+        sLoopNewKey := astPositionState[nIterMotor][nIterState].stPMPS.sPmpsState;
+        IF sLoopNewKey <> '' THEN
+            // We have a new key, start doing things
+            sLoopPrevKey := asLookupKeys[nIterState];
+            IF sLoopPrevKey = '' OR sLoopPrevKey = sLoopNewKey THEN
+                // No key yet, or exactly the same key (redudant programmer)
+                asLookupKeys[nIterState] := sLoopNewKey;
+            ELSE
+                // We already had a different key! Don't just override it, have an error!
+                bError := TRUE;
+                abStateError[nIterState] := TRUE;
+            END_IF
+        END_IF
+    END_FOR
+END_FOR
+
+// Check for duplicated sPmpsState strings
+FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO
+    FOR nIterState2 := 0 TO nIterState DO
+        IF nIterState <> nIterState2 AND asLookupKeys[nIterState] = asLookupKeys[nIterState2] AND asLookupKeys[nIterState] <> '' THEN
+            // Duplicated key, we need an error and a flag in both spots
+            bError := TRUE;
+            abStateError[nIterState] := TRUE;
+            abStateError[nIterState2] := TRUE;
+        END_IF
+    END_FOR
+END_FOR
+
+// Clear the erroneous states so they won't be used as lookups
+IF bError THEN
+    FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO
+        IF abStateError[nIterState] THEN
+            asLookupKeys[nIterState] := '';
+        END_IF
+    END_FOR
+END_IF
+
+// Copy the keys into the db state params
+FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO
+    astDbStateParams[nIterState].sPmpsState := asLookupKeys[nIterState];
+END_FOR
+
+// Check if the keys changed from prev cycle
+bNewKeys := FALSE;
+FOR nIterState := 0 TO GeneralConstants.MAX_STATES DO
+    IF asLookupKeys[nIterState] <> asPrevLookupKeys[nIterState] THEN
+        bNewKeys := TRUE;
+        EXIT;
+    END_IF
+END_FOR
+
+// Save prev keys for next cycle
+asPrevLookupKeys := asLookupKeys;
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_MotionReadPMPSDBND_Test

+
FUNCTION_BLOCK FB_MotionReadPMPSDBND_Test EXTENDS TcUnit.FB_TestSuite
+(*
+    We test the actual db read in the pmps lib
+    Here, we test that the correct keys are ready for the read based on the inputs.
+
+    The user submits a transition key and all of their ST_PositionState instances from all of their motors.
+    Any subset of these instances can have lookup keys.
+
+    If only one state at the index has a lookup key, use that key.
+    If more than one state at the index has the same lookup key, use that key.
+    If states at the same index have different keys, that's an error and a fast fault.
+    If states at different indices have the same keys, that's an error and a fast fault.
+*)
+VAR
+    astCorrectStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    astNonsenseStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    astDuplicatedStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    astHalfFullStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    nIter: UINT;
+END_VAR
+// Set up the state arrays that can be used in test methods
+FOR nIter := 1 TO GeneralConstants.MAX_STATES DO
+    astCorrectStates[nIter].stPMPS.sPmpsState := CONCAT('State', UINT_TO_STRING(nIter));
+    astNonsenseStates[nIter].stPMPS.sPmpsState := CONCAT('asdf', UINT_TO_STRING(nIter));
+    IF UINT_TO_BOOL(nIter MOD 2) THEN
+        astDuplicatedStates[nIter].stPMPS.sPmpsState := 'State0';
+    ELSE
+        astDuplicatedStates[nIter].stPMPS.sPmpsState := 'State1';
+    END_IF
+    IF nIter <= GeneralConstants.MAX_STATES / 2 THEN
+        astHalfFullStates[nIter].stPMPS.sPmpsState := CONCAT('State', UINT_TO_STRING(nIter));
+    END_IF
+END_FOR
+
+TestSolo();
+TestTrio();
+TestNonsense();
+TestDupe();
+TestBackfill();
+TestHalfFull();
+
+END_FUNCTION_BLOCK
+
+METHOD TestBackfill
+VAR_INST
+    fbRead: FB_MotionReadPMPSDBND;
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    stDefaultBP: ST_DbStateParams;
+END_VAR
+TEST('TestBackfill');
+
+astPositionState[1] := astCorrectStates;
+// Pick a few parameters to drop in
+astPositionState[1][3].stPMPS.stBeamParams.nRate := 999;
+astPositionState[2][1].stPMPS.nRequestAssertionID := 777;
+astPositionState[3][2].stPMPS.bBeamParamsLoaded := NOT stDefaultBP.bBeamParamsLoaded;
+fbRead(
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    sTransitionKey:='State0',
+    sDeviceName:='TestBackfill',
+);
+// Everything should be cleared to the defaults: the library should let us know what params got loaded (none)
+AssertEquals_UDINT(
+    Expected:=stDefaultBP.stBeamParams.nRate,
+    Actual:=astPositionState[1][3].stPMPS.stBeamParams.nRate,
+    Message:='nRate of motor 1 state 3 not backfilled',
+);
+AssertEquals_UDINT(
+    Expected:=stDefaultBP.nRequestAssertionID,
+    Actual:=astPositionState[2][1].stPMPS.nRequestAssertionID,
+    Message:='nRequestAssertionID of motor 2 state 3 not backfilled',
+);
+AssertEquals_BOOL(
+    Expected:=stDefaultBP.bBeamParamsLoaded,
+    Actual:=astPositionState[3][2].stPMPS.bBeamParamsLoaded,
+    Message:='bBeamParamsLoaded of motor 3 state 2 not backfilled',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestDupe
+VAR_INST
+    fbRead: FB_MotionReadPMPSDBND;
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestDupe');
+
+astPositionState[1] := astDuplicatedStates;
+fbRead(
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    sTransitionKey:='State0',
+    sDeviceName:='TestTrio',
+);
+fbFFHWO.EvaluateOutput();
+
+AssertTrue(
+    fbRead.bError,
+    'Should have had an error',
+);
+FOR nIter := 0 TO GeneralConstants.MAX_STATES DO
+    AssertEquals_STRING(
+        Expected:='',
+        Actual:=fbRead.astDbStateParams[nIter].sPmpsState,
+        Message:=CONCAT('Errored output should have had no state names: ', UINT_TO_STRING(nIter)),
+    );
+END_FOR
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestHalfFull
+VAR_INST
+    fbRead: FB_MotionReadPMPSDBND;
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestHalfFull');
+
+astPositionState[1] := astHalfFullStates;
+fbRead(
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    sTransitionKey:='State0',
+    sDeviceName:='TestHalfFull',
+);
+fbFFHWO.EvaluateOutput();
+
+AssertFalse(
+    fbRead.bError,
+    'Had an error',
+);
+AssertEquals_STRING(
+    Expected:=fbRead.sTransitionKey,
+    Actual:=fbRead.astDbStateParams[0].sPmpsState,
+    Message:='Output did not have the correct transition state',
+);
+FOR nIter := 1 TO GeneralConstants.MAX_STATES / 2 DO
+    AssertEquals_STRING(
+        Expected:=astCorrectStates[nIter].stPMPS.sPmpsState,
+        Actual:=fbRead.astDbStateParams[nIter].sPmpsState,
+        Message:=CONCAT('Output did not have the correct position state: ', UINT_TO_STRING(nIter)),
+    );
+END_FOR
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestNonsense
+VAR_INST
+    fbRead: FB_MotionReadPMPSDBND;
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestNonsense');
+
+astPositionState[1] := astCorrectStates;
+astPositionState[2] := astNonsenseStates;
+fbRead(
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    sTransitionKey:='State0',
+    sDeviceName:='TestTrio',
+);
+fbFFHWO.EvaluateOutput();
+
+AssertTrue(
+    fbRead.bError,
+    'Should have had an error',
+);
+// Only the transition state should be spared from the nonsense
+AssertEquals_STRING(
+    Expected:='State0',
+    Actual:=fbRead.astDbStateParams[0].sPmpsState,
+    Message:='Transition state should be OK',
+);
+FOR nIter := 1 TO GeneralConstants.MAX_STATES DO
+    AssertEquals_STRING(
+        Expected:='',
+        Actual:=fbRead.astDbStateParams[nIter].sPmpsState,
+        Message:=CONCAT('Errored output should have had no state names: ', UINT_TO_STRING(nIter)),
+    );
+END_FOR
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestSolo
+VAR_INST
+    fbRead: FB_MotionReadPMPSDBND;
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestSolo');
+
+astPositionState[1] := astCorrectStates;
+fbRead(
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    sTransitionKey:='State0',
+    sDeviceName:='TestSolo',
+);
+fbFFHWO.EvaluateOutput();
+
+AssertFalse(
+    fbRead.bError,
+    'Had an error',
+);
+AssertEquals_STRING(
+    Expected:=fbRead.sTransitionKey,
+    Actual:=fbRead.astDbStateParams[0].sPmpsState,
+    Message:='Output did not have the correct transition state',
+);
+FOR nIter := 1 TO GeneralConstants.MAX_STATES DO
+    AssertEquals_STRING(
+        Expected:=astCorrectStates[nIter].stPMPS.sPmpsState,
+        Actual:=fbRead.astDbStateParams[nIter].sPmpsState,
+        Message:=CONCAT('Output did not have the correct position state: ', UINT_TO_STRING(nIter)),
+    );
+END_FOR
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestTrio
+VAR_INST
+    fbRead: FB_MotionReadPMPSDBND;
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestTrio');
+
+astPositionState[1] := astCorrectStates;
+astPositionState[2] := astCorrectStates;
+astPositionState[3] := astCorrectStates;
+fbRead(
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    sTransitionKey:='State0',
+    sDeviceName:='TestTrio',
+);
+fbFFHWO.EvaluateOutput();
+
+AssertFalse(
+    fbRead.bError,
+    'Had an error',
+);
+AssertEquals_STRING(
+    Expected:=fbRead.sTransitionKey,
+    Actual:=fbRead.astDbStateParams[0].sPmpsState,
+    Message:='Output did not have the correct transition state',
+);
+FOR nIter := 1 TO GeneralConstants.MAX_STATES DO
+    AssertEquals_STRING(
+        Expected:=astCorrectStates[nIter].stPMPS.sPmpsState,
+        Actual:=fbRead.astDbStateParams[nIter].sPmpsState,
+        Message:=CONCAT('Output did not have the correct position state: ', UINT_TO_STRING(nIter)),
+    );
+END_FOR
+
+TEST_FINISHED();
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_MotionRequest

+
FUNCTION_BLOCK FB_MotionRequest
+(*
+    Request a move from an axis controlled via EPICS using FB_MotionStage
+    This exists to manage situations where different bits of code may need to move the same motor.
+    With just the ST_MotionStage/FB_MotionStage setup it is possible for two function blocks to
+    fight with and interfere with each other and with the EPICS commands.
+*)
+VAR_IN_OUT
+    // Motor to move
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR_INPUT
+    // Start move on rising edge, stop move on falling edge
+    bExecute: BOOL;
+    // Reset errors on rising edge
+    bReset: BOOL;
+    // Define behavior for when the motor is already moving
+    enumMotionRequest: E_MotionRequest := E_MotionRequest.WAIT;
+    // Goal position
+    fPos: LREAL;
+    // Move velocity
+    fVel: LREAL;
+    // Optional acceleration
+    fAcc: LREAL;
+    // Optional deceleration
+    fDec: LREAL;
+END_VAR
+VAR_OUTPUT
+    // True if in error state
+    bError: BOOL;
+    // Error code
+    nErrorId: UDINT;
+    // What the error code means
+    sErrorMessage: STRING;
+    // If TRUE, we are moving the motor
+    bBusy: BOOL;
+    // If TRUE, we are not moving the motor and our most recent move was successful
+    bDone: BOOL;
+END_VAR
+VAR
+    rtExec: R_TRIG;
+    ftExec: F_TRIG;
+    rtReset: R_TRIG;
+    ftBusy: F_TRIG;
+    nState: UINT := 0;
+    bMyMove: BOOL;
+    bCausedError: BOOL;
+END_VAR
+// Define local constants for our state machine states
+VAR CONSTANT
+    INIT: UINT := 0;
+    WAIT_EXEC: UINT := 1;
+    PICK_REQUEST: UINT := 2;
+    WAIT_OTHER_MOVE: UINT := 3;
+    STOP_OTHER_MOVE: UINT := 4;
+    START_MOVE: UINT := 5;
+    WAIT_MY_MOVE: UINT := 6;
+    STOP_MY_MOVE: UINT := 7;
+    DONE_MOVING: UINT := 8;
+    ERROR: UINT := 9;
+END_VAR
+rtExec(CLK:=bExecute);
+ftExec(CLK:=bExecute);
+rtReset(CLK:=bReset);
+
+// Go back to INIT state on reset
+IF rtReset.Q THEN
+    nState := INIT;
+    stMotionStage.bReset := TRUE;
+END_IF
+IF rtExec.Q OR ftExec.Q THEN
+    bDone := FALSE;
+END_IF
+
+CASE nState OF
+    // Start by setting everything to a known value
+    INIT:
+        nState := WAIT_EXEC;
+        bError := FALSE;
+        sErrorMessage := '';
+        bDone := FALSE;
+        bCausedError := FALSE;
+    // Normal "waiting for move command" state
+    WAIT_EXEC:
+        bMyMove := FALSE;
+        // Looking for a rising edge on bExecute
+        IF rtExec.Q THEN
+            bDone := FALSE;
+            nState := PICK_REQUEST;
+        END_IF
+    // Decide how to handle the request
+    PICK_REQUEST:
+        IF stMotionStage.bBusy THEN
+            CASE enumMotionRequest OF
+                E_MotionRequest.WAIT:
+                    nState := WAIT_OTHER_MOVE;
+                E_MotionRequest.INTERRUPT:
+                    nState := STOP_OTHER_MOVE;
+                E_MotionRequest.ABORT:
+                    nState := ERROR;
+                    bError := TRUE;
+                    nErrorId := 16#7900;
+            END_CASE
+        ELSE
+            nState := START_MOVE;
+        END_IF
+    // Watch the other move, then see if it's our turn
+    WAIT_OTHER_MOVE:
+        IF NOT stMotionStage.bBusy THEN
+            // Try to pick request again next cycle once the move is over
+            nState := PICK_REQUEST;
+        END_IF
+    // Interrupt the other move, then go to start ours
+    STOP_OTHER_MOVE:
+        stMotionStage.bExecute := FALSE;
+        IF NOT stMotionStage.bBusy THEN
+            nState := START_MOVE;
+        END_IF
+    // Set the correct values on ST_MotionStage to start a new absolute move
+    START_MOVE:
+        bMyMove := TRUE;
+        stMotionStage.bExecute := TRUE;
+        stMotionStage.nCommand := E_EpicsMotorCmd.MOVE_ABSOLUTE;
+        stMotionStage.fPosition := fPos;
+        stMotionStage.fVelocity := fVel;
+        stMotionStage.fAcceleration := fAcc;
+        stMotionStage.fDeceleration := fDec;
+        nState := WAIT_MY_MOVE;
+    // Watch our ongoing move, look for the move to end or requests to stop the move from this FB
+    WAIT_MY_MOVE:
+        ftBusy(CLK:=stMotionStage.bBusy);
+        IF ftBusy.Q THEN
+            nState := DONE_MOVING;
+        END_IF
+        // Implement stop on falling trigger
+        IF ftExec.Q THEN
+            nState := STOP_MY_MOVE;
+        END_IF
+    // Request a stop and wait for it to happen
+    STOP_MY_MOVE:
+        stMotionStage.bExecute := FALSE;
+        IF NOT stMotionStage.bBusy THEN
+            nState := DONE_MOVING;
+        END_IF
+    // Pick out the bDone state and return to waiting
+    DONE_MOVING:
+        bDone := stMotionStage.bDone;
+        nState := WAIT_EXEC;
+    // Lock us into the error state until the FB is reset
+    ERROR:
+        bMyMove := FALSE;
+END_CASE
+
+// Transition to the ERROR state if applicable
+IF bMyMove AND stMotionStage.bError THEN
+    nState := ERROR;
+    bError := TRUE;
+    nErrorId := stMotionStage.nErrorId;
+    bCausedError := TRUE;
+END_IF
+sErrorMessage := F_MotionErrorCodeLookup(nErrorId := nErrorId);
+
+CASE nState OF
+INIT, WAIT_EXEC, ERROR:
+    bBusy := FALSE;
+ELSE
+    bBusy := TRUE;
+END_CASE
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_MotionStage

+
FUNCTION_BLOCK FB_MotionStage
+(*
+    Default implementation for PLC behavior when motor IOC asks for a move
+    This can be extended or replaced in your PLC project if you want
+    non-default behavior to arise from the motor record processing
+*)
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR
+    fbDriveVirtual: FB_DriveVirtual;
+    fbMotionHome: FB_MotionHoming;
+    fbSaveRestore: FB_EncSaveRestore;
+    fbLogError: FB_LogMotionError;
+    bExecute: BOOL;
+    bExecMove: BOOL;
+    bExecHome: BOOL;
+    bFwdHit: BOOL;
+    bBwdHit: BOOL;
+    ftExec: F_TRIG;
+    rtExec: R_TRIG;
+    rtUserExec: R_TRIG;
+    rtTarget: R_TRIG;
+    rtHomed: R_TRIG;
+    fbSetEnables: FB_SetEnables;
+    bPosGoal: BOOL;
+    bNegGoal: BOOL;
+    fbEncoderValue: FB_EncoderValue;
+    fbNCParams: FB_MotionStageNCParams;
+    bNewMoveReq: BOOL;
+    bPrepareDisable: BOOL;
+    bMoveCmd: BOOL;
+    rtMoveCmdShortcut: R_TRIG;
+    rtHomeCmdShortcut: R_TRIG;
+END_VAR
+// Start with an accurate status
+stMotionStage.Axis.ReadStatus();
+
+// Check for the plc shortcut commands
+// Used for testing or to circumvent motor record issues
+rtMoveCmdShortcut(CLK:=stMotionStage.bMoveCmd);
+rtHomeCmdShortcut(CLK:=stMotionStage.bHomeCmd);
+// Execute on rising edge
+IF rtMoveCmdShortcut.Q AND NOT stMotionStage.bExecute THEN
+    stMotionStage.bExecute := TRUE;
+    stMotionStage.nCommand := E_EpicsMotorCmd.MOVE_ABSOLUTE;
+ELSIF rtHomeCmdShortcut.Q AND NOT stMotionStage.bExecute THEN
+    stMotionStage.bExecute := TRUE;
+    stMotionStage.nCommand := E_EpicsMotorCmd.HOME;
+END_IF
+// Always reset, even if not rising edge, so command can be issued again
+IF stMotionStage.bMoveCmd OR stMotionStage.bHomeCmd THEN
+    stMotionStage.bMoveCmd := FALSE;
+    stMotionStage.bHomeCmd := FALSE;
+END_IF
+
+// Automatically fill the correct nCmdData for homing
+IF stMotionStage.nCommand = E_EpicsMotorCmd.HOME THEN
+    stMotionStage.nCmdData := stMotionStage.nHomingMode;
+END_IF
+
+// Check if the command wants to cause a move
+bMoveCmd R= stMotionStage.nCmdData = E_EpicsHomeCmd.ABSOLUTE_SET;
+bMoveCmd R= stMotionStage.nCmdData = E_EpicsHomeCmd.NONE;
+bMoveCmd S= stMotionStage.nCommand <> E_EpicsMotorCmd.HOME;
+
+// Handle main execs
+rtUserExec(CLK := stMotionStage.bExecute);
+bNewMoveReq S= rtUserExec.Q AND bMoveCmd;
+bNewMoveReq R= NOT stMotionStage.bExecute;
+bPrepareDisable R= bNewMoveReq;
+
+bPosGoal := stMotionStage.stAxisStatus.fActPosition < stMotionStage.fPosition;
+bNegGoal := stMotionStage.stAxisStatus.fActPosition > stMotionStage.fPosition;
+
+// Moves are automatically allowed if no safety hooks. Otherwise, some other code will set this.
+stMotionStage.bSafetyReady S= stMotionStage.bPowerSelf;
+
+// Handle auto-enable timing
+CASE stMotionStage.nEnableMode OF
+    E_StageEnableMode.ALWAYS:
+        stMotionStage.bEnable := TRUE;
+    E_StageEnableMode.DURING_MOTION:
+        IF bNewMoveReq THEN
+            IF stMotionStage.nCommand = E_EpicsMotorCmd.HOME THEN
+                stMotionStage.bEnable := stMotionStage.bSafetyReady;
+            ELSIF bPosGoal THEN
+                IF stMotionStage.bAllForwardEnable THEN
+                    stMotionStage.bEnable S= stMotionStage.bSafetyReady;
+                ELSIF NOT stMotionStage.bError THEN
+                    // Not an error, just a warning
+                    stMotionStage.sErrorMessage := 'Cannot move past positive limit.';
+                    stMotionStage.bExecute := FALSE;
+                END_IF
+            ELSIF bNegGoal THEN
+                IF stMotionStage.bAllBackwardEnable THEN
+                    stMotionStage.bEnable S= stMotionStage.bSafetyReady;
+                ELSIF NOT stMotionStage.bError THEN
+                    // Not an error, just a warning
+                    stMotionStage.sErrorMessage := 'Cannot move past negative limit.';
+                    stMotionStage.bExecute := FALSE;
+                END_IF
+            ELSE
+                // Super rare condition where we asked for a move to exactly the same floating point we're already at
+                stMotionStage.bEnable S= stMotionStage.bSafetyReady;
+            END_IF
+            IF stMotionStage.bEnable OR stMotionStage.bError THEN
+                bNewMoveReq := FALSE;
+            END_IF
+        END_IF
+END_CASE
+
+// Update all enable booleans
+fbSetEnables(stMotionStage:=stMotionStage);
+
+IF stMotionStage.stAxisStatus.bBusy AND NOT bExecute THEN
+    // Wait for the previous move to end
+    bExecute := FALSE;
+ELSIF bMoveCmd THEN
+    // Do not start the move until we have power and the safety system says it is OK
+    bExecute := stMotionStage.bExecute AND stMotionStage.bAllEnable AND stMotionStage.bEnableDone AND stMotionStage.bSafetyReady;
+ELSE
+    bExecute := stMotionStage.bExecute;
+END_IF
+
+IF bExecute AND NOT stMotionStage.bError THEN
+    // Reset local warnings if things are going well
+    stMotionStage.sErrorMessage := '';
+END_IF
+
+// No moves allowed in error states
+IF stMotionStage.bError THEN
+    bExecute := FALSE;
+END_IF
+
+
+bExecHome := bExecute AND stMotionStage.nCommand = 10;
+bExecMove := bExecute AND NOT bExecHome;
+
+// Handle standard commands using ESS's FB
+fbDriveVirtual(En:=TRUE,
+    bEnable:=stMotionStage.bAllEnable,
+    bReset:=stMotionStage.bReset,
+    bExecute:=bExecMove,
+    nCommand:=INT_TO_UINT(stMotionStage.nCommand),
+    nCmdData:=INT_TO_UINT(stMotionStage.nCmdData),
+    fVelocity:=stMotionStage.fVelocity,
+    fPosition:=stMotionStage.fPosition,
+    fAcceleration:=stMotionStage.fAcceleration,
+    fDeceleration:=stMotionStage.fDeceleration,
+    bLimitFwd:=stMotionStage.bAllForwardEnable,
+    bLimitBwd:=stMotionStage.bAllBackwardEnable,
+    bHomeSensor:=stMotionStage.bHome,
+    fHomePosition:=stMotionStage.fHomePosition,
+    bPowerSelf:=stMotionStage.bPowerSelf,
+    nMotionAxisID=>stMotionStage.nMotionAxisID,
+    Axis:=stMotionStage.Axis);
+
+// Some custom home handling
+fbMotionHome(
+    stMotionStage:=stMotionStage,
+    bExecute:=bExecHome);
+
+// Update status again after the move starts or stops
+stMotionStage.Axis.ReadStatus();
+
+// Check for a new error
+IF NOT stMotionStage.bError THEN
+    stMotionStage.bError := fbDriveVirtual.bError;
+    stMotionStage.nErrorId := fbDriveVirtual.nErrorId;
+END_IF
+IF NOT stMotionStage.bError THEN
+    stMotionStage.bError := fbMotionHome.bError;
+    stMotionStage.nErrorId := fbMotionHome.nErrorId;
+END_IF
+IF NOT stMotionStage.bError AND stMotionStage.bExecute AND NOT stMotionStage.bUserEnable THEN
+    stMotionStage.bError := TRUE;
+    stMotionStage.nErrorId := 1;
+    stMotionStage.sCustomErrorMessage := 'Move requested, but user enable is disabled!';
+END_IF
+
+// Set the error message if we have one
+IF stMotionStage.bError THEN
+    // Hook if other code wants to inject a non-NC error
+    IF stMotionStage.sCustomErrorMessage <> '' THEN
+        stMotionStage.sErrorMessage := stMotionSTage.sCustomErrorMessage;
+    ELSE
+        stMotionStage.sErrorMessage := F_MotionErrorCodeLookup(nErrorId := stMotionStage.nErrorId);
+    END_IF
+END_IF
+
+fbLogError(
+    stMotionStage:=stMotionStage,
+    bEnable:=TRUE);
+
+// When we start, set the busy/done appropriately
+rtExec(CLK:=bExecute);
+IF rtExec.Q THEN
+    stMotionStage.bBusy := TRUE;
+    stMotionStage.bDone := FALSE;
+END_IF
+
+// Force everything off in case of error
+IF stMotionStage.bError THEN
+    stMotionStage.bBusy := FALSE;
+    stMotionStage.bDone := FALSE;
+    stMotionStage.bEnable := FALSE;
+END_IF
+
+// Check the limits and cancel execution if appropriate. Without this block we have infinite error spam
+bFwdHit := stMotionStage.Axis.Status.PositiveDirection AND NOT stMotionStage.bAllForwardEnable;
+bBwdHit := stMotionStage.Axis.Status.NegativeDirection AND NOT stMotionStage.bAllBackwardEnable;
+IF (bFwdHit OR bBwdHit) AND NOT fbMotionHome.bBusy THEN
+    stMotionStage.bExecute := FALSE;
+END_IF
+
+// Check done moving via user stop, fbDriveVirtual and Target Position Monitoring, or from homing.
+ftExec(CLK:=stMotionStage.bExecute);
+rtTarget(CLK:=(stMotionStage.Axis.Status.InTargetPosition AND fbDriveVirtual.bDone AND bExecMove));
+rtHomed(CLK:=fbMotionHome.bDone AND bExecHome);
+IF ftExec.Q OR rtTarget.Q OR rtHomed.Q THEN
+    IF NOT stMotionStage.bDone THEN
+        stMotionStage.bDone := TRUE;
+        stMotionStage.bBusy := FALSE;
+        IF NOT stMotionStage.Axis.Status.Error THEN
+            bExecute := FALSE;
+            stMotionStage.bExecute := FALSE;
+        END_IF
+    END_IF
+END_IF
+
+// Handle auto-disable timing
+bPrepareDisable S= stMotionStage.nEnableMode = E_StageEnableMode.DURING_MOTION AND ftExec.Q;
+// Delay the disable until we reach standstill, else brake issues or other race conditions
+IF bPrepareDisable AND stMotionStage.Axis.Status.MotionState = MC_AXISSTATE_STANDSTILL THEN
+    bPrepareDisable := FALSE;
+    stMotionStage.bEnable := FALSE;
+END_IF
+
+// Get a definitive bEnabled reading
+CASE stMotionStage.Axis.Status.MotionState OF
+    // We are not enabled if there is an issue
+    MC_AXISSTATE_UNDEFINED, MC_AXISSTATE_DISABLED, MC_AXISSTATE_ERRORSTOP:
+        stMotionStage.bEnableDone := FALSE;
+    ELSE
+        stMotionStage.bEnableDone := TRUE;
+END_CASE
+
+// Handle the brake. TRUE means brake disabled/released
+IF stMotionStage.nBrakeMode <> E_StageBrakeMode.NO_BRAKE THEN
+    CASE stMotionStage.Axis.Status.MotionState OF
+        MC_AXISSTATE_UNDEFINED,
+        MC_AXISSTATE_DISABLED,
+        MC_AXISSTATE_ERRORSTOP:
+            stMotionStage.bBrakeRelease := FALSE;
+        MC_AXISSTATE_STANDSTILL:
+            IF stMotionStage.nBrakeMode = E_StageBrakeMode.IF_MOVING THEN
+                stMotionStage.bBrakeRelease := FALSE;
+            ELSE
+                stMotionStage.bBrakeRelease := TRUE;
+            END_IF
+        ELSE
+            stMotionStage.bBrakeRelease := TRUE;
+    END_CASE
+END_IF
+
+// Sync the epics status struct
+stMotionStage.stAxisStatus := fbDriveVirtual.stAxisStatus;
+stMotionStage.stAxisStatus.bEnabled := stMotionStage.bEnableDone;
+
+// Override homing status, dmov as appropriate
+stMotionStage.bHomed := fbMotionHome.bDone AND NOT fbMotionHome.bError;
+stMotionStage.stAxisStatus.bHomed := stMotionStage.bHomed;
+stMotionStage.stAxisStatus.bExecute := bExecute;
+stMotionStage.stAxisStatus.nCommand := 3; // If this is not 3, the IOC stops updating positions during homing
+
+// Fill in auxiliary status info
+stMotionStage.fPosDiff := stMotionStage.Axis.NcToPlc.PosDiff;
+
+// Reset everything when bReset is flagged
+IF stMotionStage.bReset THEN
+    stMotionStage.bEnable := FALSE;
+    stMotionStage.bReset := FALSE;
+    stMotionStage.bExecute := FALSE;
+    stMotionStage.bError := FALSE;
+    stMotionStage.nErrorId := 0;
+    stMotionStage.sErrorMessage := '';
+    stMotionStage.sCustomErrorMessage := '';
+    bExecute := FALSE;
+END_IF
+
+fbEncoderValue(stMotionStage:=stMotionStage);
+fbNCParams(
+    stMotionStage:=stMotionStage,
+    bEnable:=TRUE,
+    tRefreshDelay:=T#1s);
+
+// Save and restore as long as not an absolute encoder
+fbSaveRestore(
+    stMotionStage:=stMotionStage,
+    bEnable:=stMotionStage.nHomingMode <> E_EpicsHomeCmd.NONE);
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_MotionStageNCParams

+
FUNCTION_BLOCK FB_MotionStageNCParams
+(*
+    Read and refresh axis parameters struct on ST_MotionStage
+*)
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR_INPUT
+    bEnable: BOOL;
+    tRefreshDelay: TIME;
+END_VAR
+VAR_OUTPUT
+    bError: BOOL;
+END_VAR
+VAR
+    mcReadParams: MC_ReadParameterSet;
+    timer: TON;
+    bExecute: BOOL := TRUE;
+    nLatchErrId: UDINT;
+END_VAR
+timer(
+    IN:=bEnable AND NOT bExecute,
+    PT:=tRefreshDelay);
+bExecute S= timer.Q;
+mcReadParams(
+    Parameter:=stMotionStage.stAxisParameters,
+    Axis:=stMotionStage.Axis,
+    Execute:=bEnable AND bExecute,
+    Error=>bError);
+IF mcReadParams.ErrorID <> 0 THEN
+    nLatchErrId := 0;
+END_IF
+bExecute R= mcReadParams.Done OR mcReadParams.Error;
+stMotionStage.bAxisParamsInit S= mcReadParams.Done;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_MotionStageSim

+
FUNCTION_BLOCK FB_MotionStageSim
+(*
+    Set all the values needed for a fake motor to be movable
+    via the IOC, then call FB_MotionStage
+*)
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR_INPUT
+    nEnableMode: E_StageEnableMode := E_StageEnableMode.ALWAYS;
+END_VAR
+VAR
+    fbMotionStage: FB_MotionStage;
+    bInit: BOOL;
+END_VAR
+IF NOT bInit THEN
+    bInit := TRUE;
+    // Stand-in for no forward limit
+    stMotionStage.bLimitForwardEnable := TRUE;
+    // Stand-in for no reverse limit
+    stMotionStage.bLimitBackwardEnable := TRUE;
+    // Stand-in for no STO button
+    stMotionStage.bHardwareEnable := TRUE;
+    // Stand-in for no PMPS governer
+    stMotionStage.bPowerSelf := TRUE;
+    // Always keep it enabled for testing ease
+    stMotionStage.nEnableMode := nEnableMode;
+END_IF
+// Call FB_MotionStage to do the thing
+fbMotionStage(stMotionStage := stMotionStage);
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_MotorTestSuite

+
FUNCTION_BLOCK FB_MotorTestSuite EXTENDS TcUnit.FB_TestSuite
+(*
+    Base class for motion tests.
+
+    Contains some helper methods that would otherwise need to be instantiated many times,
+    but in this form can be accessed quickly and succinctly in the test suite.
+*)
+
+
+END_FUNCTION_BLOCK
+
+METHOD SetEnables
+(*
+    Set a motion stage's enables such that it is fully allowed to move.
+*)
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+stMotionStage.bHardwareEnable := TRUE;
+stMotionStage.bLimitBackwardEnable := TRUE;
+stMotionStage.bLimitForwardEnable := TRUE;
+stMotionStage.bPowerSelf := TRUE;
+END_METHOD
+
+METHOD SetEnablesPMPS
+(*
+    Set a motion stage's enables such that only PMPS would be preventing a move.
+*)
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+SetEnables(stMotionStage);
+stMotionStage.bPowerSelf := FALSE;
+END_METHOD
+
+METHOD SetGoodState
+(*
+    Mark a state as valid and ready to use.
+*)
+VAR_IN_OUT
+    stPositionState: ST_PositionState;
+END_VAR
+stPositionState.bMoveOk := TRUE;
+stPositionState.bValid := TRUE;
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_NcAxis

+
///#########################################################
+///Function block to communicate between Nc and Plc.
+///
+/// Library:
+/// Tc2_MC2.lib
+///
+/// Global Variables:
+///
+/// Data types:
+///
+/// External functions:
+///
+///###########################################################
+FUNCTION_BLOCK FB_NcAxis
+VAR
+    sVersion: STRING:='1.0.0';
+END_VAR
+VAR_INPUT
+    En: BOOL;
+END_VAR
+VAR_OUTPUT
+    EnO: BOOL;
+    bError: BOOL;
+    Status: ST_AxisStatus;
+END_VAR
+VAR
+    Axis: AXIS_REF;
+    InfoData_State AT %I*: UINT;
+END_VAR
+EnO:=En;
+
+IF En AND InfoData_State<>16#8 THEN
+    bError:=TRUE;
+ELSE
+    bError:=FALSE;
+END_IF
+
+IF En THEN
+    Axis.ReadStatus();
+    Status:=Axis.Status;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_NCErrorFFO

+
FUNCTION_BLOCK FB_NCErrorFFO
+(*
+    Configure a ST_MotionStage to trigger an FFO when we have an error.
+
+    This can be configured to only apply to specific error ranges,
+    though the default is the normal 16#4XXX NC error range. The error
+    ranges are:
+    16#40XX General Errors
+    16#41XX Channel Errors
+    16#42XX Group Errors
+    16#43XX Axis Errors
+    16#44XX Encoder Errors
+    16#45XX Controller Errors
+    16#46XX Drive Errors
+    16#4AXX Table Errors
+    16#4BXX NC PLC Errors
+    16#4CXX Kinematic Transformation
+
+    There is also a new extended NC error range, but it is sparsely populated.
+    This range is 16#8XXX:
+    16#8100 - 16#811F: Bode plot (diagnosis)
+    16#8120 - 16#8FFF: Further errors
+
+    To configure multiple ranges, simply use multiple instances of this
+    function block.
+*)
+VAR_IN_OUT
+    // Motion stage to monitor
+    stMotionStage: ST_MotionStage;
+    // FFO to trip
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    // Reset the fault
+    bReset: BOOL;
+    // Auto-reset the fault
+    bAutoReset: BOOL;
+    // The lowest error code that will trip the FFO
+    nLowErrorId: UDINT := 16#4000;
+    // The highest error code that will trip the FFO
+    nHighErrorId: UDINT := 16#4FFF;
+    // A description of the fault
+    sDesc: STRING := 'Motor error';
+END_VAR
+VAR_OUTPUT
+    // Quick way for nearby code to check if this block has tripped the FFO.
+    bTripped: BOOL;
+    // Error code sent to PMPS. Is always 16#20XX, where XX is the first two hex in the NC error.
+    nErrorTypeCode: UINT;
+END_VAR
+VAR
+    bInit: BOOL;
+    stBeamParams: ST_BeamParams;
+    fbFF: FB_FastFault;
+    rtTrip: R_TRIG;
+END_VAR
+IF NOT bInit THEN
+    fbFF.i_Desc := sDesc;
+    IF LEN(stMotionStage.sName) > 0 THEN
+        fbFF.i_DevName := stMotionStage.sName;
+    ELSE
+        fbFF.i_DevName := 'Unnamed Motor';
+    END_IF
+    bInit := TRUE;
+END_IF
+
+bTripped := stMotionStage.bError AND stMotionStage.nErrorId >= nLowErrorId AND stMotionStage.nErrorId <= nHighErrorId;
+rtTrip(CLK:=bTripped);
+IF rtTrip.Q THEN
+    nErrorTypeCode := E_MotionFFType.LOW_RESERVED_NC + UDINT_TO_UINT(SHR(stMotionStage.nErrorId, 8));
+    nErrorTypeCode := MIN(nErrorTypeCode, E_MotionFFType.HIGH_RESERVED_NC);
+END_IF
+fbFF(i_xOK := NOT bTripped,
+     i_xReset := bReset,
+     i_xAutoReset := bAutoReset,
+     i_TypeCode:= nErrorTypeCode,
+     io_fbFFHWO := fbFFHWO);
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_NCErrorFFO_Test

+
FUNCTION_BLOCK FB_NCErrorFFO_Test EXTENDS TcUnit.FB_TestSuite
+(*
+    Test the following related FBs:
+    - FB_NCErrorFFO
+    - FB_EncErrorFFO
+
+    These function blocks are designed to trip the beam when there
+    is an NC error reported by stMotionStage.
+*)
+VAR
+    stMotionStage: ST_MotionStage;
+    fbMotionStage: FB_MotionStage;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbCauseNCError: FB_CauseNCError;
+
+    fbNCErrorFFO: FB_NCErrorFFO;
+    fbEncErrorFFO: FB_EncErrorFFO;
+
+    nTestCounter: UINT;
+    bOneTestDone: BOOL;
+    tonTimer: TON;
+END_VAR
+fbMotionStage(stMotionStage:=stMotionStage);
+// Limit to drive errors so I can isolate it from the enc error
+fbNCErrorFFO(
+    stMotionStage:=stMotionStage,
+    fbFFHWO:=fbFFHWO,
+    bAutoReset:=TRUE,
+    nLowErrorId:=16#4500,
+    nHighErrorId:=16#45FF,
+);
+fbEncErrorFFO(
+    stMotionStage:=stMotionStage,
+    fbFFHWO:=fbFFHWO,
+    bAutoReset:=TRUE,
+);
+// Fast fault output is TRUE when there are no issues and FALSE when there is an issue
+fbFFHWO.EvaluateOutput();
+
+TestNC(0);
+TestEnc(1);
+
+IF bOneTestDone THEN
+    bOneTestDone := FALSE;
+    nTestCounter := nTestCounter + 1;
+    tonTimer(IN:=FALSE);
+    fbCauseNCError(
+        Axis:=stMotionStage.Axis,
+        bExecute:=FALSE,
+    );
+    stMotionStage.bReset := TRUE;
+    fbMotionStage(stMotionStage:=stMotionStage);
+END_IF
+// Use this timer to time out any tests that stall
+tonTimer(
+    IN:=TRUE,
+    PT:=T#5s,
+);
+
+END_FUNCTION_BLOCK
+
+METHOD TestEnc
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    nState: UINT;
+END_VAR
+TEST('TestEncError');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+CASE nState OF
+    0:
+        // First cycle: no error, no fault
+        AssertFalse(
+            stMotionStage.bError,
+            'Should have had no error before running this test',
+        );
+        AssertTrue(
+            fbFFHWO.q_xFastFaultOut,
+            'Should have had no fault with no error',
+        );
+        nState := 1;
+    1:
+        // Next time: cause an error
+        fbCauseNCError(
+            Axis:=stMotionStage.Axis,
+            bExecute:=TRUE,
+            nErrorCode:=16#4467, // Invalid encoder position data
+        );
+END_CASE
+
+// Wait for the fault or the timeout, then check everything
+IF tonTimer.Q OR (NOT fbFFHWO.q_xFastFaultOut AND stMotionStage.nErrorID = 16#4467) THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    AssertTrue(
+        stMotionStage.bError,
+        'Did not get motor error in error test',
+    );
+    AssertEquals_UDINT(
+        Expected:=16#4467,
+        Actual:=stMotionStage.nErrorId,
+        Message:='Error causer is broken',
+    );
+    AssertFalse(
+        fbFFHWO.q_xFastFaultOut,
+        Message:='Did not cause a fast fault',
+    );
+    AssertFalse(
+        fbNCErrorFFO.bTripped,
+        Message:='Drive error FB tripped with an enc error',
+    );
+    AssertTrue(
+        fbEncErrorFFO.bTripped,
+        Message:='Enc error fb did not trip with an enc error',
+    );
+    bOneTestDone := TRUE;
+    nState := 0;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestNC
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    nState: UINT;
+END_VAR
+TEST('TestNCError');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+CASE nState OF
+    0:
+        // First cycle: no error, no fault
+        AssertFalse(
+            stMotionStage.bError,
+            'Should have had no error before running this test',
+        );
+        AssertTrue(
+            fbFFHWO.q_xFastFaultOut,
+            'Should have had no fault with no error',
+        );
+        nState := 1;
+    1:
+        // Next time: cause an error
+        fbCauseNCError(
+            Axis:=stMotionStage.Axis,
+            bExecute:=TRUE,
+            nErrorCode:=16#4550, // Position lag monitoring error code
+        );
+END_CASE
+
+// Wait for the fault or the timeout, then check everything
+IF tonTimer.Q OR (NOT fbFFHWO.q_xFastFaultOut AND stMotionStage.nErrorId = 16#4550) THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    AssertTrue(
+        stMotionStage.bError,
+        'Did not get motor error in error test',
+    );
+    AssertEquals_UDINT(
+        Expected:=16#4550,
+        Actual:=stMotionStage.nErrorId,
+        Message:='Error causer is broken',
+    );
+    AssertFalse(
+        fbFFHWO.q_xFastFaultOut,
+        Message:='Did not cause a fast fault',
+    );
+    AssertTrue(
+        fbNCErrorFFO.bTripped,
+        Message:='NC error FB did not trip with a drive error',
+    );
+    AssertFalse(
+        fbEncErrorFFO.bTripped,
+        Message:='Enc error tripped with a drive error',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_PerMotorFFOND

+
FUNCTION_BLOCK FB_PerMotorFFOND
+(*
+    PMPS fast faults that must be done per motor, rather than per state, based purely
+    on the motor status and not other PMPS considerations.
+
+    These currently include:
+    - Fault if the encoder has an error. Every other protection is based on the encoder,
+      so we can't trust anything if the encoder is faulting.
+*)
+VAR_IN_OUT
+    // All motors associated with the state mover.
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    // Fast fault output to fault to.
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    // The number of motors we're actually using
+    nActiveMotorCount: UINT;
+    // Identifying name to use in group fast faults
+    sDeviceName: STRING;
+END_VAR
+VAR_OUTPUT
+    // Set to TRUE if the arrays don't have the same bounds. In this FB, that's an automatic fault.
+    bMotorCountError: BOOL;
+END_VAR
+VAR
+    afbEncError: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF FB_EncErrorFFO;
+    ffProgrammerError: FB_FastFault;
+    nIter: DINT;
+END_VAR
+CheckCount();
+IF NOT bMotorCountError THEN
+    HandleLoops();
+END_IF
+HandleFFO();
+
+END_FUNCTION_BLOCK
+
+ACTION CheckCount:
+// Make sure the motor count is valid (positive, nonzero, less or equal to the max)
+bMotorCountError S= nActiveMotorCount <= 0;
+bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS;
+END_ACTION
+
+ACTION HandleFFO:
+ffProgrammerError(
+    i_xOK:=NOT bMotorCountError,
+    i_xAutoReset:=TRUE,
+    i_DevName:=sDeviceName,
+    i_Desc:='Programmer error picking motor count',
+    i_TypeCode:=E_MotionFFType.INTERNAL_ERROR,
+    io_fbFFHWO:=fbFFHWO,
+);
+END_ACTION
+
+ACTION HandleLoops:
+FOR nIter := 1 TO nActiveMotorCount DO
+    afbEncError[nIter](
+        stMotionstage:=astMotionStage[nIter],
+        fbFFHWO:=fbFFHWO,
+        bAutoReset:=TRUE,
+    );
+END_FOR
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_PerMotorFFOND_Test

+
FUNCTION_BLOCK FB_PerMotorFFOND_Test EXTENDS TcUnit.FB_TestSuite
+(*
+    FFO if an illogical motor count is passed
+    FFO if any motor has what looks like an encoder error
+       - We'll just simulate this without doing it legit
+       - The legit test is done elsewhere
+    More FFOs may be added later and these will need to be tested too
+*)
+VAR
+END_VAR
+TestBlankCount();
+TestTwoMotorEncError();
+
+END_FUNCTION_BLOCK
+
+METHOD TestBlankCount : BOOL
+VAR_INST
+    fbFFO: FB_PerMotorFFOND;
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestBlankCount');
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Started with a fault',
+);
+fbFFO(
+    astMotionStage:=astMotionStage,
+    fbFFHWO:=fbFFHWO,
+);
+fbFFHWO.EvaluateOutput();
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Blank count did not fault',
+);
+AssertTrue(
+    fbFFO.bMotorCountError,
+    'Blank count did not error',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestTwoMotorEncError : BOOL
+VAR_INST
+    fbFFO: FB_PerMotorFFOND;
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestTwoMotorEncError');
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Started with a fault',
+);
+astMotionStage[2].bError := TRUE;
+astMotionStage[2].nErrorId := 16#4467; // Invalid encoder position data
+fbFFO(
+    astMotionStage:=astMotionStage,
+    fbFFHWO:=fbFFHWO,
+    nActiveMotorCount:=2,
+);
+fbFFHWO.EvaluateOutput();
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Encoder error did not fault',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_PMPSJsonTestHelper

+
FUNCTION_BLOCK FB_PMPSJsonTestHelper
+(*
+    Create a JSON doc in memory to match the input structs
+    Assumes 1 device for simplicity
+    Writes to the global pmps json doc
+*)
+VAR_IN_OUT
+    astBeamParams: ARRAY[*] OF ST_DbStateParams;
+END_VAR
+VAR_INPUT
+    bExecute: BOOL;
+    sDevName: STRING;
+END_VAR
+VAR_OUTPUT
+END_VAR
+VAR
+    rtExec: R_TRIG;
+    jsonRoot: SJsonValue;
+    jsonDevice: SJsonValue;
+    ajsonState: ARRAY[0..GeneralConstants.MAX_STATES] OF SJsonValue;
+    fbJson: FB_JsonDomParser;
+
+    nIter: DINT;
+    nId: DINT;
+
+    aseVRange: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING;
+    asRate: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING;
+    asBCRange: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING;
+    asTran: ARRAY[0..GeneralConstants.MAX_STATES] OF STRING;
+END_VAR
+rtExec(CLK:=bExecute);
+IF NOT rtExec.Q THEN
+    RETURN;
+END_IF
+
+jsonRoot := fbJson.NewDocument();
+jsonDevice := fbJson.AddObjectMember(jsonRoot, sDevName);
+FOR nIter := LOWER_BOUND(astBeamParams, 1) TO UPPER_BOUND(astBeamParams, 1) DO
+    ajsonState[nIter] := fbJson.AddObjectMember(jsonDevice, astBeamParams[nIter].sPmpsState);
+
+    nId := nId + 1;
+    fbJson.AddIntMember(
+        v:=ajsonState[nIter],
+        member:='id',
+        value:=nId,
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='beamline',
+        value:='tst',
+    );
+    aseVRange[nIter] := bitmaskToString(astBeamParams[nIter].stBeamParams.neVRange, 32);
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='neVRange',
+        value:=aseVRange[nIter],
+    );
+    asRate[nIter] := UDINT_TO_STRING(astBeamParams[nIter].stBeamParams.nRate);
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='nRate',
+        value:=asRate[nIter],
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='ap_ygap',
+        value:='',
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='ap_xgap',
+        value:='',
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='damage_limit',
+        value:='',
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='notes',
+        value:='',
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='reactive_temp',
+        value:='',
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='reactive_pressure',
+        value:='',
+    );
+    asBCRange[nIter] := bitmaskToString(astBeamParams[nIter].stBeamParams.nBCRange, 15);
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='nBeamClassRange',
+        value:=asBCRange[nIter],
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='name',
+        value:=astBeamParams[nIter].sPmpsState,
+    );
+    asTran[nIter] := REAL_TO_STRING(astBeamParams[nIter].stBeamParams.nTran);
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='nTran',
+        value:=asTran[nIter],
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='ap_name',
+        value:='None',
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='ap_ycenter',
+        value:='',
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='ap_xcenter',
+        value:='',
+    );
+    fbJson.AddStringMember(
+        v:=ajsonState[nIter],
+        member:='pulse_energy',
+        value:='',
+    );
+    fbJson.AddBoolMember(
+        v:=ajsonState[nIter],
+        member:='special',
+        value:=FALSE,
+    );
+END_FOR
+
+PMPS_GVL.BP_jsonDoc := jsonRoot;
+
+END_FUNCTION_BLOCK
+
+METHOD bitmaskToString : STRING
+VAR_INPUT
+    nBitmask: DWORD;
+    nBits: UINT;
+END_VAR
+VAR
+    nIter: UINT;
+END_VAR
+bitmaskToString := '';
+FOR nIter := 1 TO nBits DO
+    bitmaskToString := CONCAT(DWORD_TO_STRING(SHR(nBitmask, nIter - 1) AND 1), bitmaskToString);
+END_FOR
+END_METHOD
+
+
+
+
+

FB_PositionState1D

+
FUNCTION_BLOCK FB_PositionState1D
+(*
+    1-Dimensional position state function block.
+
+    This allows the user to move a motor among some set of named state positions.
+
+    To use a states block, you must define enums that match the state options and give them pytmc pragmas.
+    See FB_PositionState1D_InOut for a simple example.
+    These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables.
+    The enum values must match the array indices in astPositionState.
+
+    A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us
+    to accept a new, possibly conflicting, move request on the next cycle to interrupt the first.
+
+    The motor must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly.
+
+    With no PMPS handling, this FB basically just links the state names with positions in both directions for set and readback.
+*)
+VAR_IN_OUT
+    // The motor to move.
+    stMotionStage: ST_MotionStage;
+    // All possible position states, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input.
+    eEnumSet: UINT;
+    // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output.
+    eEnumGet: UINT;
+END_VAR
+VAR_INPUT
+    // Set this to TRUE to enable input state moves, or FALSE to disable them.
+    bEnable: BOOL;
+    // Normal EPICS inputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stEpicsToPlc: ST_StateEpicsToPlc;
+END_VAR
+VAR_OUTPUT
+    // Normal EPICS outputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPlcToEpics: ST_StatePlcToEpics;
+END_VAR
+VAR
+    fbCore: FB_PositionStateND_Core;
+    astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+astMotionStageMax[1] := stMotionStage;
+astPositionStateMax[1] := astPositionState;
+
+fbCore(
+    astMotionStageMax:=astMotionStageMax,
+    astPositionStateMax:=astPositionStateMax,
+    stEpicsToPlc:=stEpicsToPlc,
+    stPlcToEpics:=stPlcToEpics,
+    eEnumSet:=eEnumSet,
+    eEnumGet:=eEnumGet,
+    bEnable:=bEnable,
+    nActiveMotorCount:=1,
+);
+
+stMotionStage := astMotionStageMax[1];
+astPositionState := astPositionStateMax[1];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionState1D_InOut

+
FUNCTION_BLOCK FB_PositionState1D_InOut
+(*
+    An example and usable drop-in instance for a 1D state device with just an IN and an OUT state.
+*)
+VAR_IN_OUT
+    // Include a stage that can be passed into the FB
+    stMotionStage: ST_MotionStage;
+    // Simplify the interface, the user just needs to construct and pass in and out position states
+    stIn: ST_PositionState;
+    stOut: ST_PositionState;
+END_VAR
+VAR_INPUT
+    // Define an ENUM for EPICS to use to set a new value. It is expected this will be written to during one cycle, so don't continually apply a value here in the PLC code.
+    // It is exposed as an input so we can test it using the PLC.
+    {attribute 'pytmc' := '
+      pv: STATE:SET
+      io: io
+    '}
+    eStateReq: E_EpicsInOut;
+END_VAR
+VAR_OUTPUT
+    // Define an ENUM for EPICS to use to report the new value.
+    {attribute 'pytmc' := '
+      pv: STATE:GET
+      io: i
+    '}
+    eStateGet: E_EpicsInOut;
+END_VAR
+VAR
+    // Include the standard fb with blank pv pragma
+    {attribute 'pytmc' := 'pv:'}
+    fbPositionState1D: FB_PositionState1D;
+    // The standard fb expects a full array of position states
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+// Optional: default state names
+IF stIn.sName = '' THEN
+    stIn.sName := 'IN';
+END_IF
+IF stOut.sName = '' THEN
+    stOut.sName := 'OUT';
+END_IF
+
+// Assemble the states array, matching the enum values (IN is 1, OUT is 2)
+astPositionState[1] := stIn;
+astPositionState[2] := stOut;
+
+// Call the main function block, passing our motors, states, enums and an enable
+fbPositionState1D(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    eEnumSet:=eStateReq,
+    eEnumGet:=eStateGet,
+    bEnable:=TRUE,
+);
+
+// Send updates made on the array back to the inputs (VAR_IN_OUT) for maximum clarity
+stIn := astPositionState[1];
+stOut := astPositionState[2];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionState2D

+
FUNCTION_BLOCK FB_PositionState2D
+(*
+    2-Dimensional position state function block.
+
+    This allows the user to move 2 motors among some set of named state positions.
+
+    To use a states block, you must define enums that match the state options and give them pytmc pragmas.
+    See FB_PositionState1D_InOut for a simple example.
+    These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables.
+    The enum values must match the array indices in astPositionState1 and astPositionState2.
+
+    A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us
+    to accept a new, possibly conflicting, move request on the next cycle to interrupt the first.
+
+    The motors must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly.
+
+    With no PMPS handling, this FB basically just links the state names with positions in both directions for set and readback.
+*)
+VAR_IN_OUT
+    // The 1st motor to move
+    stMotionStage1: ST_MotionStage;
+    // The 2nd motor to move
+    stMotionStage2: ST_MotionStage;
+    // All possible position states for motor 1, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:01
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // All possible position states for motor 2, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:02
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input.
+    eEnumSet: UINT;
+    // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output.
+    eEnumGet: UINT;
+END_VAR
+VAR_INPUT
+    // Set this to TRUE to enable input state moves, or FALSE to disable them.
+    bEnable: BOOL;
+    // Normal EPICS inputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stEpicsToPlc: ST_StateEpicsToPlc;
+END_VAR
+VAR_OUTPUT
+    // Normal EPICS outputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPlcToEpics: ST_StatePlcToEpics;
+END_VAR
+VAR
+    fbCore: FB_PositionStateND_Core;
+    astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+astMotionStageMax[1] := stMotionStage1;
+astMotionStageMax[2] := stMotionStage2;
+astPositionStateMax[1] := astPositionState1;
+astPositionStateMax[2] := astPositionState2;
+
+fbCore(
+    astMotionStageMax:=astMotionStageMax,
+    astPositionStateMax:=astPositionStateMax,
+    stEpicsToPlc:=stEpicsToPlc,
+    stPlcToEpics:=stPlcToEpics,
+    eEnumSet:=eEnumSet,
+    eEnumGet:=eEnumGet,
+    bEnable:=bEnable,
+    nActiveMotorCount:=2,
+);
+
+stMotionStage1 := astMotionStageMax[1];
+stMotionStage2 := astMotionStageMax[2];
+astPositionState1 := astPositionStateMax[1];
+astPositionState2 := astPositionStateMax[2];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionState2D_InOut

+
FUNCTION_BLOCK FB_PositionState2D_InOut
+(*
+    An example and usable drop-in instance for a 2D state device with just an IN and an OUT state.
+*)
+VAR_IN_OUT
+    // Include stages that can be passed into the FB
+    stMotionStage1: ST_MotionStage;
+    stMotionStage2: ST_MotionStage;
+    // Simplify the interface, the user just needs to construct and pass in and out position states
+    stIn1: ST_PositionState;
+    stOut1: ST_PositionState;
+    stIn2: ST_PositionState;
+    stOut2: ST_PositionState;
+END_VAR
+VAR_INPUT
+    // Define an ENUM for EPICS to use to set a new value. It is expected this will be written to during one cycle, so don't continually apply a value here in the PLC code.
+    // It is exposed as an input so we can test it using the PLC.
+    {attribute 'pytmc' := '
+      pv: STATE:SET
+      io: io
+    '}
+    eStateSet: E_EpicsInOut;
+END_VAR
+VAR_OUTPUT
+    // Define an ENUM for EPICS to use to report the new value.
+    {attribute 'pytmc' := '
+      pv: STATE:GET
+      io: i
+    '}
+    eStateGet: E_EpicsInOut;
+END_VAR
+VAR
+    // Include the standard fb with blank pv pragma
+    {attribute 'pytmc' := 'pv:'}
+    fbPositionState2D: FB_PositionState2D;
+    // The standard fb expects a full array of position states per motor
+    astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+// Optional: default state names
+IF stIn1.sName = '' THEN
+    stIn1.sName := 'IN';
+END_IF
+IF stOut1.sName = '' THEN
+    stOut1.sName := 'OUT';
+END_IF
+IF stIn2.sName = '' THEN
+    stIn2.sName := 'IN';
+END_IF
+IF stOut2.sName = '' THEN
+    stOut2.sName := 'OUT';
+END_IF
+
+// Assemble the states arrays, matching the enum values (IN is 1, OUT is 2)
+astPositionState1[1] := stIn1;
+astPositionState1[2] := stOut1;
+astPositionState2[1] := stIn2;
+astPositionState2[2] := stOut2;
+
+// Call the main function block, passing our motors, states, and an enable
+fbPositionState2D(
+    stMotionStage1:=stMotionStage1,
+    astPositionState1:=astPositionState1,
+    stMotionStage2:=stMotionStage2,
+    astPositionState2:=astPositionState2,
+    eEnumSet:=eStateSet,
+    eEnumGet:=eStateGet,
+    bEnable:=TRUE,
+);
+
+// Send updates made on the array back to the inputs (VAR_IN_OUT) for maximum clarity
+stIn1 := astPositionState1[1];
+stOut1 := astPositionState1[2];
+stIn2 := astPositionState2[1];
+stOut2 := astPositionState2[2];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionState3D

+
FUNCTION_BLOCK FB_PositionState3D
+(*
+    3-Dimensional position state function block.
+
+    This allows the user to move 3 motors among some set of named state positions.
+
+    To use a states block, you must define enums that match the state options and give them pytmc pragmas.
+    See FB_PositionState1D_InOut for a simple example.
+    These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables.
+    The enum values must match the array indices in astPositionState1, astPositionState2, and astPositionState3.
+
+    A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us
+    to accept a new, possibly conflicting, move request on the next cycle to interrupt the first.
+
+    The motors must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly.
+
+    With no PMPS handling, this FB basically just links the state names with positions in both directions for set and readback.
+*)
+VAR_IN_OUT
+    // The 1st motor to move
+    stMotionStage1: ST_MotionStage;
+    // The 2nd motor to move
+    stMotionStage2: ST_MotionStage;
+    // The 3rd motor to move
+    stMotionStage3: ST_MotionStage;
+    // All possible position states for motor 1, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:01
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // All possible position states for motor 2, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:02
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // All possible position states for motor 3, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:03
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState3: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input.
+    eEnumSet: UINT;
+    // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output.
+    eEnumGet: UINT;
+END_VAR
+VAR_INPUT
+    // Set this to TRUE to enable input state moves, or FALSE to disable them.
+    bEnable: BOOL;
+    // Normal EPICS inputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stEpicsToPlc: ST_StateEpicsToPlc;
+END_VAR
+VAR_OUTPUT
+    // Normal EPICS outputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPlcToEpics: ST_StatePlcToEpics;
+END_VAR
+VAR
+    fbCore: FB_PositionStateND_Core;
+    astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+astMotionStageMax[1] := stMotionStage1;
+astMotionStageMax[2] := stMotionStage2;
+astMotionStageMax[3] := stMotionStage3;
+astPositionStateMax[1] := astPositionState1;
+astPositionStateMax[2] := astPositionState2;
+astPositionStateMax[3] := astPositionState3;
+
+fbCore(
+    astMotionStageMax:=astMotionStageMax,
+    astPositionStateMax:=astPositionStateMax,
+    stEpicsToPlc:=stEpicsToPlc,
+    stPlcToEpics:=stPlcToEpics,
+    eEnumSet:=eEnumSet,
+    eEnumGet:=eEnumGet,
+    bEnable:=bEnable,
+    nActiveMotorCount:=3,
+);
+
+stMotionStage1 := astMotionStageMax[1];
+stMotionStage2 := astMotionStageMax[2];
+stMotionStage3 := astMotionStageMax[3];
+astPositionState1 := astPositionStateMax[1];
+astPositionState2 := astPositionStateMax[2];
+astPositionState3 := astPositionStateMax[3];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateBase

+
{attribute 'obsolete' := 'Use FB_PositionState1D instead'}
+FUNCTION_BLOCK FB_PositionStateBase
+(*
+    Handles EPICS moves between multiple states for a single axis
+    Should be subclassed for a specific enumSet and enumGet.
+    See body comment  or FB_PositionStateInOut for an implementation example.
+*)
+VAR_IN_OUT
+    // Motor to move
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR_INPUT
+    // If TRUE, start a move when setState transitions to a nonzero number
+    bEnable: BOOL;
+    // On rising edge, reset this FB
+    {attribute 'pytmc' := '
+        pv: RESET
+        io: io
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bReset: BOOL;
+END_VAR
+VAR_OUTPUT
+    // If TRUE, there is an error
+    {attribute 'pytmc' := '
+        pv: ERR
+        io: i
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bError: BOOL;
+    // Error ID
+    {attribute 'pytmc' := '
+        pv: ERRID
+        io: i
+    '}
+    nErrorId: UDINT;
+    // The error that caused bError to flip TRUE
+    {attribute 'pytmc' := '
+        pv: ERRMSG
+        io: i
+    '}
+    sErrorMessage: STRING;
+    // If TRUE, we are moving the motor
+    {attribute 'pytmc' := '
+        pv: BUSY
+        io: i
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bBusy: BOOL;
+    // If TRUE, we are not moving the motor and the last move completed successfully
+    {attribute 'pytmc' := '
+        pv: DONE
+        io: i
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bDone: BOOL;
+END_VAR
+VAR
+    // Pre-allocated array of states
+    {attribute 'pytmc' := '
+        pv:
+        io: io
+        expand: %.2d
+    '}
+    arrStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+
+    // Corresponding arrStates index to move to, or 0 if no move selected
+    setState: INT;
+    // The current position we are trying to reach, or 0
+    goalState: INT;
+    // The readback position
+    getState: INT;
+
+    bInit: BOOL;
+    stUnknown: ST_PositionState;
+    stGoal: ST_PositionState;
+    fbStateMove: FB_PositionStateMove;
+    fbStateInternal: ARRAY[1..GeneralConstants.MAX_STATES] OF FB_PositionStateInternal;
+    nIndex: INT;
+    bNewGoal: BOOL;
+    bInnerExec: BOOL;
+    bInnerReset: BOOL;
+    rtReset: R_TRIG;
+    bMoveRequested: BOOL;
+END_VAR
+(*
+    Subclass me, define enums to translate setState and getState, call Exec
+
+    Example:
+
+    <something to fill arrStates>
+    setState := enumSet;
+    Exec();
+    enumGet := getState;
+    enumSet := setState;
+*)
+
+END_FUNCTION_BLOCK
+
+ACTION Exec:
+StateHandler();
+END_ACTION
+
+ACTION StateHandler:
+// Reset just goes through the first-cycle init again
+rtReset(CLK:=bReset);
+IF rtReset.Q THEN
+    bInit := FALSE;
+    bReset := FALSE;
+END_IF
+
+// First-cycle init
+IF NOT bInit THEN
+    bError := FALSE;
+    nErrorID := 0;
+    sErrorMessage := '';
+    bBusy := FALSE;
+    bDone := FALSE;
+    bNewGoal := FALSE;
+    bInnerExec := FALSE;
+    bInnerReset := TRUE;
+    setState := 0;
+    goalState := 0;
+END_IF
+
+// All state internal handlers
+FOR nIndex := 1 TO GeneralConstants.MAX_STATES DO
+    IF arrStates[nIndex].bValid THEN
+        fbStateInternal[nIndex](
+            stMotionStage:=stMotionStage,
+            stPositionState:=arrStates[nIndex]);
+    END_IF
+END_FOR
+
+// Check where we are by going through all possible states.
+// Note this favors the highest-number state that we're at, it's up to you to make your states mutually exclusive.
+getState := 0;
+FOR nIndex := 1 TO GeneralConstants.MAX_STATES DO
+    IF F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=arrStates[nIndex]) THEN
+        getState := nIndex;
+    END_IF
+END_FOR
+
+// Use the changing set pv as a rising-edge trigger
+IF setState <> goalState THEN
+    goalState := setState;
+    bNewGoal := TRUE;
+END_IF
+
+// Special move handling for error/enable state
+IF bError OR NOT bEnable THEN
+    bInnerExec := FALSE;
+ELSIF bNewGoal THEN
+    IF fbStateMove.bBusy THEN
+        // Stop previous move if we were already moving but want a new move
+        bInnerExec := FALSE;
+    ELSE
+        // If we hit this branch, we're ready to start a new move
+        bInnerExec := TRUE;
+        bInnerReset := FALSE;
+        bNewGoal := FALSE;
+    END_IF
+END_IF
+
+// Pick the correct goal structure or Unknown
+IF goalState = 0 THEN
+    stGoal := stUnknown;
+ELSE
+    stGoal := arrStates[goalState];
+END_IF
+
+// Do the move
+fbStateMove(
+    stMotionStage := stMotionStage,
+    stPositionState := stGoal,
+    bExecute := bInnerExec,
+    bReset := bInnerReset,
+    enumMotionRequest := E_MotionRequest.INTERRUPT,
+    bBusy => bBusy);
+
+// Only pass up bDone information if this FB is active
+IF bInnerExec THEN
+    bDone := fbStateMove.bDone;
+END_IF
+
+// Pick up any new errors, but don't override uncleared existing errors
+IF NOT bError THEN
+    bError := fbStateMove.bError;
+    IF bError THEN
+        nErrorId := fbStateMove.nErrorId;
+        sErrorMessage := fbStateMove.sErrorMessage;
+    END_IF
+END_IF
+
+// Reset the setpoint and goal to 0 if we're not doing anything
+// because FB is waiting for a change from 0 to "something"
+bMoveRequested := bInnerExec AND NOT bDone;
+IF NOT bError AND NOT bNewGoal AND NOT bMoveRequested THEN
+    setState := 0;
+    goalState := 0;
+    bInnerExec := FALSE;
+END_IF
+
+// Bring inner reset back low at the end of the init cycle so that it can be triggered again later
+IF NOT bInit THEN
+    bInit := TRUE;
+    bInnerReset := FALSE;
+END_IF
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateBase_WithPMPS

+
{attribute 'obsolete' := 'Use FB_PositionStatePMPS1D instead'}
+FUNCTION_BLOCK FB_PositionStateBase_WithPMPS EXTENDS FB_PositionStateBase
+(*
+    Handles EPICS moves between multiple states for a single axis with PMPS.
+    Should be subclassed for a specific enumSet and enumGet.
+    See body comment  or FB_PositionStateInOut_WithPMPS for an implementation example.
+*)
+VAR_IN_OUT
+    fbArbiter: FB_Arbiter;
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    sPmpsDeviceName: STRING;
+    sTransitionKey: STRING;
+    {attribute 'pytmc' := '
+        pv: PMPS:ARB:ENABLE
+        io: io
+    '}
+    bArbiterEnabled: BOOL := TRUE;
+    tArbiterTimeout: TIME := T#1s;
+    bMoveOnArbiterTimeout: BOOL := TRUE;
+    fStateBoundaryDeadband: LREAL := 0;
+    bBPOKAutoReset: BOOL := False;
+END_VAR
+VAR
+    {attribute 'pytmc' := 'pv: PMPS'}
+    fbStatePMPS: FB_PositionStatePMPS;
+    fbEncErrFFO: FB_EncErrorFFO;
+END_VAR
+(*
+    Subclass me, define enums to translate setState and getState, call Exec
+
+    Example:
+
+    <something to fill arrStates>
+    setState := enumSet;
+    Exec();
+    enumGet := getState;
+    enumSet := setState;
+*)
+
+END_FUNCTION_BLOCK
+
+ACTION Exec:
+StateHandler();
+PMPSHandler();
+END_ACTION
+
+ACTION PMPSHandler:
+fbStatePMPS(
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stMotionStage:=stMotionStage,
+    arrStates:=arrStates,
+    sPmpsDeviceName:=sPmpsDeviceName,
+    sTransitionKey:=sTransitionKey,
+    stPmpsDoc:= PMPS_GVL.BP_jsonDoc,
+    bRequestTransition:=setState <> 0,
+    setState:=setState,
+    getState:=getState,
+    bArbiterEnabled:=bArbiterEnabled,
+    tArbiterTimeout:=tArbiterTimeout,
+    bMoveOnArbiterTimeout:=bMoveOnArbiterTimeout,
+    fStateBoundaryDeadband:=fStateBoundaryDeadband,
+    bBPOKAutoReset:=bBPOKAutoReset);
+
+fbEncErrFFO(
+    stMotionStage:=stMotionStage,
+    fbFFHWO:=fbFFHWO,
+    bAutoReset:=TRUE);
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateBase_WithPMPS_Test

+
{attribute 'obsolete' := 'No longer any reason to use this, all state classes can have unit tests.'}
+FUNCTION_BLOCK FB_PositionStateBase_WithPMPS_Test EXTENDS FB_PositionStateBase
+(*
+    Handles EPICS moves between multiple states for a single axis with fake PMPS.
+    Should be subclassed for a specific enumSet and enumGet.
+    See body comment  or FB_PositionStateInOut_WithPMPS_Test for an implementation example.
+*)
+VAR_INPUT
+    stTransitionBeam: ST_BeamParams := PMPS_GVL.cst0RateBeam;
+    nTransitionAssertionID: UDINT;
+END_VAR
+VAR
+    fbStatePMPS: FB_PositionStatePMPS_Test;
+END_VAR
+(*
+    Subclass me, define enums to translate setState and getState, call Exec
+
+    Example:
+
+    <something to fill arrStates>
+    setState := enumSet;
+    Exec();
+    enumGet := getState;
+    enumSet := setState;
+*)
+
+END_FUNCTION_BLOCK
+
+ACTION Exec:
+StateHandler();
+PMPSHandler();
+END_ACTION
+
+ACTION PMPSHandler:
+fbStatePMPS(
+    stMotionStage:=stMotionStage,
+    arrStates:=arrStates,
+    bRequestTransition:=setState <> 0,
+    setState:=setState,
+    getState:=getState);
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateInOut

+
{attribute 'obsolete' := 'Use FB_PositionState1D_InOut instead'}
+FUNCTION_BLOCK FB_PositionStateInOut EXTENDS FB_PositionStateBase
+(*
+    Example usage of FB_PositionStateBase for a simple IN/OUT axis. See NOTE: comments.
+    Also usable as a drop-in for these cases (no need to roll your own in/out)
+*)
+VAR_INPUT
+    // The enum position to move to
+    {attribute 'pytmc' := '
+        pv: SET
+        io: io
+    '}
+    enumSet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumSet
+
+    // Information about the OUT position
+    stOut: ST_PositionState; // NOTE: Do not pragma these, let it happen in the manager.
+    // Information about the IN position
+    stIn: ST_PositionState;
+END_VAR
+VAR_OUTPUT
+    // The enum state readback
+    {attribute 'pytmc' := '
+        pv: GET
+        io: i
+    '}
+    enumGet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumGet
+END_VAR
+VAR
+    bInOutInit: BOOL;
+END_VAR
+IF NOT bInOutInit THEN
+    bInOutInit := TRUE;
+    arrStates[1] := stOut;
+    arrStates[2] := stIn;
+    stOut.sName := 'OUT';
+    stIn.sName := 'IN';
+END_IF
+setState := enumSet;
+Exec();
+enumGet := getState;
+enumSet := setState;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateInOut_WithPMPS

+
{attribute 'obsolete' := 'Use FB_PositionStatePMPS1D_InOut instead'}
+FUNCTION_BLOCK FB_PositionStateInOut_WithPMPS EXTENDS FB_PositionStateBase_WithPMPS
+(*
+    Example usage of FB_PositionStateBase_WithPMPS for a simple IN/OUT axis. See NOTE: comments.
+    Also usable as a drop-in for these cases (no need to roll your own in/out)
+
+    This is the PMPS version. Note that the only difference is that we extend the _WithPMPS FB.
+*)
+VAR_INPUT
+    // The enum position to move to
+    {attribute 'pytmc' := '
+        pv: SET
+        io: io
+    '}
+    enumSet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumSet
+
+    // Information about the OUT position
+    stOut: ST_PositionState; // NOTE: Do not pragma these, let it happen in the manager.
+    // Information about the IN position
+    stIn: ST_PositionState;
+END_VAR
+VAR_OUTPUT
+    // The enum state readback
+    {attribute 'pytmc' := '
+        pv: GET
+        io: i
+    '}
+    enumGet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumGet
+END_VAR
+VAR
+    bInOutInit: BOOL;
+END_VAR
+IF NOT bInOutInit THEN
+    bInOutInit := TRUE;
+    arrStates[1] := stOut;
+    arrStates[2] := stIn;
+    stOut.sName := 'OUT';
+    stIn.sName := 'IN';
+END_IF
+setState := enumSet;
+Exec();
+enumGet := getState;
+enumSet := setState;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateInOut_WithPMPS_Test

+
{attribute 'obsolete' := 'No longer any reason to use this, all state classes can have unit tests.'}
+FUNCTION_BLOCK FB_PositionStateInOut_WithPMPS_Test EXTENDS FB_PositionStateBase_WithPMPS_Test
+(*
+    Example usage of FB_PositionStateBase_WithPMPS_Test for a simple IN/OUT axis. See NOTE: comments.
+    Also usable as a drop-in for these cases (no need to roll your own in/out)
+
+    This is the PMPS version. Note that the only difference is that we extend the _WithPMPS_Test FB.
+*)
+VAR_INPUT
+    // The enum position to move to
+    {attribute 'pytmc' := '
+        pv: SET
+        io: io
+    '}
+    enumSet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumSet
+
+    // Information about the OUT position
+    stOut: ST_PositionState; // NOTE: Do not pragma these, let it happen in the manager.
+    // Information about the IN position
+    stIn: ST_PositionState;
+END_VAR
+VAR_OUTPUT
+    // The enum state readback
+    {attribute 'pytmc' := '
+        pv: GET
+        io: i
+    '}
+    enumGet: ENUM_EpicsInOut_INT; // NOTE: Please copy this pragma exactly on your enumGet
+END_VAR
+VAR
+    bInOutInit: BOOL;
+END_VAR
+IF NOT bInOutInit THEN
+    bInOutInit := TRUE;
+    arrStates[1] := stOut;
+    arrStates[2] := stIn;
+    stOut.sName := 'OUT';
+    stIn.sName := 'IN';
+END_IF
+setState := enumSet;
+Exec();
+enumGet := getState;
+enumSet := setState;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateInternal

+
FUNCTION_BLOCK FB_PositionStateInternal
+(*
+    Routines that must be called on all ST_PositionState
+
+    Currently, this FB:
+    - ensures that a position state has both a proper encoder count
+      and a proper position in engineering units with both of these quantities matching
+    - handles the parameter locking feature, which nominally prevents the user from changing
+      details about a locked state via EPICS
+*)
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+    stPositionState: ST_PositionState;
+END_VAR
+VAR_OUTPUT
+END_VAR
+VAR
+    fbEncConverter: FB_RawCountConverter;
+    fbLock: FB_PositionStateLock;
+END_VAR
+// Mark that we've been here
+stPositionState.bUpdated := TRUE;
+
+// Update pos state's count or egu position as appropriate
+IF stMotionStage.bAxisParamsInit THEN
+    fbEncConverter(
+        stParameters:=stMotionStage.stAxisParameters,
+        nCountCheck:=stPositionState.nEncoderCount,
+        fPosCheck:=stPositionState.fPosition);
+    IF stPositionState.bUseRawCounts THEN
+        stPositionState.fPosition := fbEncConverter.fPosGet;
+    ELSE
+        stPositionState.nEncoderCount := fbEncConverter.nCountGet;
+    END_IF
+END_IF
+
+// Handle state parameter locking
+fbLock(
+    stPositionState:=stPositionState,
+    bEnable:=stMotionStage.bAxisParamsInit);
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateInternalND

+
FUNCTION_BLOCK FB_PositionStateInternalND
+(*
+    Given a standard ND state setup, call all the required state management FBs.
+*)
+VAR_IN_OUT
+    // All the motors to apply the standard routines to
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    // Each motor's respective position states along its direction
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+VAR
+    // The individual instantiated internal FBs. Must have the same bounds as astPositionState.
+    afbStateInternal: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF FB_PositionStateInternal;
+    nIterMotors: DINT;
+    nIterStates: DINT;
+END_VAR
+FOR nIterMotors := 1 TO MotionConstants.MAX_STATE_MOTORS DO
+    FOR nIterStates := 1 TO GeneralConstants.MAX_STATES DO
+        afbStateInternal[nIterMotors][nIterStates](
+            stMotionStage:=astMotionStage[nIterMotors],
+            stPositionState:=astPositionState[nIterMotors][nIterStates],
+        );
+    END_FOR
+END_FOR
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateLock

+
FUNCTION_BLOCK FB_PositionStateLock
+(*
+    Implements immutability for a locked ST_PositionState
+    Once this is called the first time, the parameters at the time of the call will be restored on all subsequent calls.
+*)
+VAR_IN_OUT
+    stPositionState: ST_PositionState;
+END_VAR
+VAR_INPUT
+    bEnable: BOOL;
+END_VAR
+VAR
+    stCachedPositionState: ST_PositionState;
+    bInit: BOOL := FALSE;
+END_VAR
+IF bEnable THEN
+    // Force values to be cached if we've cached something
+    IF bInit AND stPositionState.bLocked THEN
+        stPositionState.sName := stCachedPositionState.sName;
+        stPositionState.fPosition := stCachedPositionState.fPosition;
+        stPositionState.fDelta := stCachedPositionState.fDelta;
+        stPositionState.fVelocity := stCachedPositionState.fVelocity;
+        stPositionState.fAccel := stCachedPositionState.fAccel;
+        stPositionState.fDecel := stCachedPositionState.fDecel;
+    // If we haven't cached and we should, make the cache. Note that we skip bLocked, bValid, and bMoveOk
+    ELSIF NOT bInit AND stPositionState.bLocked THEN
+        stCachedPositionState.sName := stPositionState.sName;
+        stCachedPositionState.fPosition := stPositionState.fPosition;
+        stCachedPositionState.fDelta := stPositionState.fDelta;
+        stCachedPositionState.fVelocity := stPositionState.fVelocity;
+        stCachedPositionState.fAccel := stPositionState.fAccel;
+        stCachedPositionState.fDecel := stPositionState.fDecel;
+        bInit := TRUE;
+    // Do nothing, or unlock the state if bLocked goes FALSE
+    ELSIF NOT stPositionState.bLocked THEN
+        bInit := FALSE;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateManager

+
{attribute 'obsolete' := 'Use FB_PositionState1D instead'}
+FUNCTION_BLOCK FB_PositionStateManager
+(*
+    Handles EPICS moves between multiple states for a single axis
+    Should be wrapped inside a block with enums for states,
+    see FB_EpicsInOut for an example.
+*)
+VAR_IN_OUT
+    // Motor to move
+    stMotionStage: ST_MotionStage;
+
+    // Allocated space for 15 states besides Unknown (16 is the max for an EPICS MBBI)
+    {attribute 'pytmc' := '
+        pv:
+        io: io
+        expand: %.2d
+    '}
+    arrStates: ARRAY[1..15] OF ST_PositionState;
+
+    // Corresponding arrStates index to move to, or 0 if no move selected
+    setState: INT;
+END_VAR
+VAR_INPUT
+    // If TRUE, start a move when setState transitions to a nonzero number
+    bEnable: BOOL;
+    // On rising edge, reset this FB
+    {attribute 'pytmc' := '
+        pv: RESET
+        io: io
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bReset: BOOL;
+END_VAR
+VAR_OUTPUT
+    // If TRUE, there is an error
+    {attribute 'pytmc' := '
+        pv: ERR
+        io: i
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bError: BOOL;
+    // Error ID
+    {attribute 'pytmc' := '
+        pv: ERRID
+        io: i
+    '}
+    nErrorId: UDINT;
+    // The error that caused bError to flip TRUE
+    {attribute 'pytmc' := '
+        pv: ERRMSG
+        io: i
+    '}
+    sErrorMessage: STRING;
+    // If TRUE, we are moving the motor
+    {attribute 'pytmc' := '
+        pv: BUSY
+        io: i
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bBusy: BOOL;
+    // If TRUE, we are not moving the motor and the last move completed successfully
+    {attribute 'pytmc' := '
+        pv: DONE
+        io: i
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bDone: BOOL;
+
+    // The current position we are trying to reach, or 0
+    goalState: INT;
+    // The readback position
+    getState: INT;
+END_VAR
+VAR
+    bInit: BOOL;
+    stUnknown: ST_PositionState;
+    stGoal: ST_PositionState;
+    fbStateMove: FB_PositionStateMove;
+    fbStateInternal: ARRAY[1..15] OF FB_PositionStateInternal;
+    nIndex: INT;
+    bNewGoal: BOOL;
+    bInnerExec: BOOL;
+    bInnerReset: BOOL;
+    rtReset: R_TRIG;
+    bMoveRequested: BOOL;
+END_VAR
+// Reset just goes through the first-cycle init again
+rtReset(CLK:=bReset);
+IF rtReset.Q THEN
+    bInit := FALSE;
+END_IF
+
+// First-cycle init
+IF NOT bInit THEN
+    bError := FALSE;
+    sErrorMessage := '';
+    bBusy := FALSE;
+    bDone := FALSE;
+    bNewGoal := FALSE;
+    bInnerExec := FALSE;
+    bInnerReset := TRUE;
+    setState := 0;
+    goalState := 0;
+END_IF
+
+// All state internal handlers
+FOR nIndex := 1 TO 15 DO
+    IF arrStates[nIndex].bValid THEN
+        fbStateInternal[nIndex](
+            stMotionStage:=stMotionStage,
+            stPositionState:=arrStates[nIndex]);
+    END_IF
+END_FOR
+
+// Check where we are by going through all possible states.
+// Note this favors the highest-number state that we're at, it's up to you to make your states mutually exclusive.
+getState := 0;
+FOR nIndex := 1 TO 15 DO
+    IF F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=arrStates[nIndex]) THEN
+        getState := nIndex;
+    END_IF
+END_FOR
+
+// Use the changing set pv as a rising-edge trigger
+IF setState <> goalState THEN
+    goalState := setState;
+    bNewGoal := TRUE;
+END_IF
+
+// Special move handling for error/enable state
+IF bError OR NOT bEnable THEN
+    bInnerExec := FALSE;
+// Reset inner block this cycle if we were already moving but want a new move
+ELSIF bInnerExec AND bNewGoal THEN
+    bInnerExec := FALSE;
+    bInnerReset := TRUE;
+// If we hit this branch, we're starting a new move
+ELSIF bNewGoal THEN
+    bInnerExec := TRUE;
+    bInnerReset := FALSE;
+    bNewGoal := FALSE;
+END_IF
+
+// Pick the correct goal structure or Unknown
+IF goalState = 0 THEN
+    stGoal := stUnknown;
+ELSE
+    stGoal := arrStates[goalState];
+END_IF
+
+// Do the move
+fbStateMove(
+    stMotionStage := stMotionStage,
+    stPositionState := stGoal,
+    bExecute := bInnerExec,
+    bReset := bInnerReset,
+    enumMotionRequest := E_MotionRequest.INTERRUPT,
+    bBusy => bBusy);
+
+// Only pass up bDone information if this FB is active
+IF bInnerExec THEN
+    bDone := fbStateMove.bDone;
+END_IF
+
+// Pick up any new errors, but don't override uncleared existing errors
+IF NOT bError THEN
+    bError := fbStateMove.bError;
+    nErrorId := fbStateMove.nErrorId;
+    sErrorMessage := fbStateMove.sErrorMessage;
+END_IF
+
+// Reset the setpoint and goal to 0 if we're not doing anything
+// because FB is waiting for a change from 0 to "something"
+bMoveRequested := bInnerExec AND NOT bDone;
+IF NOT bError AND NOT bNewGoal AND NOT bMoveRequested THEN
+    setState := 0;
+    goalState := 0;
+    bInnerExec := FALSE;
+END_IF
+
+// Bring inner reset back low at the end of the init cycle so that it can be triggered again later
+IF NOT bInit THEN
+    bInit := TRUE;
+    bInnerReset := FALSE;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateMove

+
FUNCTION_BLOCK FB_PositionStateMove
+(*
+    Request a move to a particular state from an axis controlled via EPICS
+    pytmc PVs here only exposed if using directly and not through another states function block.
+*)
+VAR_IN_OUT
+    // Motor to move
+    stMotionStage: ST_MotionStage;
+
+    // State to move to
+    {attribute 'pytmc' := '
+        pv:
+    '}
+    stPositionState: ST_PositionState;
+END_VAR
+VAR_INPUT
+    // Start move on rising edge, stop move on falling edge
+    {attribute 'pytmc' := '
+        pv: GO
+        io: io
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bExecute: BOOL;
+
+    // Rising edge error reset
+    {attribute 'pytmc' := '
+        pv: RESET
+        io: io
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bReset: BOOL;
+
+    // Define behavior for when a move is already active
+    enumMotionRequest: E_MotionRequest := E_MotionRequest.WAIT;
+END_VAR
+VAR_OUTPUT
+    // TRUE if the motor is at this state
+    {attribute 'pytmc' := '
+        pv: AT_STATE
+        io: input
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bAtState: BOOL;
+
+    // TRUE if we have an error
+    {attribute 'pytmc' := '
+        pv: ERR
+        io: input
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bError: BOOL;
+
+    // Error code
+    {attribute 'pytmc' := '
+        pv: ERRID
+        io: input
+    '}
+    nErrorID: UDINT;
+
+    // Error description
+    {attribute 'pytmc' := '
+        pv: ERRMSG
+        io: input
+    '}
+    sErrorMessage: STRING;
+
+    // TRUE if we are moving to a state
+    {attribute 'pytmc' := '
+        pv: BUSY
+        io: input
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bBusy: BOOL;
+
+    // TRUE if we are not moving and we reached a state successfully on our last move
+    {attribute 'pytmc' := '
+        pv: DONE
+        io: input
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bDone: BOOL;
+END_VAR
+VAR
+    fbMotionRequest: FB_MotionRequest;
+    bAllowMove: BOOL;
+END_VAR
+// Veto the move for uninitialized and unsafe states
+bAllowMove := stPositionState.bMoveOk AND stPositionState.bValid AND stPositionState.bUpdated;
+
+// Do the move
+fbMotionRequest(
+    stMotionStage := stMotionStage,
+    bExecute := bExecute AND bAllowMove,
+    bReset := bReset,
+    enumMotionRequest := enumMotionRequest,
+    fPos := stPositionState.fPosition,
+    fVel := stPositionState.fVelocity,
+    fAcc := stPositionState.fAccel,
+    fDec := stPositionState.fDecel,
+    bError => bError,
+    nErrorId => nErrorId,
+    sErrorMessage => sErrorMessage,
+    bBusy => bBusy,
+    bDone => bDone);
+
+// Inject custom error if we can't move because of bMoveOk or bValid
+IF bExecute AND NOT bAllowMove THEN
+    bError := TRUE;
+    IF stPositionState.bValid THEN
+        nErrorId := 16#7901;
+    ELSE
+        nErrorId := 16#7902;
+    END_IF
+    sErrorMessage := F_MotionErrorCodeLookup(nErrorId := nErrorID);
+END_IF
+
+// This can be useful if we're running this FB standalone for some reason
+bAtState := F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=stPositionState);
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateMove_Test

+
FUNCTION_BLOCK FB_PositionStateMove_Test EXTENDS FB_MotorTestSuite
+(*
+    Test that FB_PositionStateMove can be used to move motors to named state positions
+    And that the API behaves exactly as described.
+*)
+VAR
+    stMotionStage: ST_MotionStage;
+    fbMotionStage: FB_MotionStage;
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    afbInternal: ARRAY[1..3] OF FB_PositionStateInternal;
+    stDummyPos: ST_PositionState;
+    stInvalid: ST_PositionState;
+    stNotUpdated: ST_PositionState;
+    stUnsafe: ST_PositionState;
+    fbMove: FB_PositionStateMove;
+
+    nTestCounter: UINT;
+    bOneTestDone: BOOL;
+    fTestStartPos: LREAL;
+    tonTimer: TON;
+    nIter: DINT;
+    bStatesReady: BOOL;
+END_VAR
+astPositionState[1].sName := 'UNO';
+astPositionState[1].fPosition := 10;
+astPositionState[1].fDelta := 1;
+astPositionState[1].fVelocity := 10;
+SetGoodState(astPositionState[1]);
+
+astPositionState[2].sName := 'DOS';
+astPositionState[2].fPosition := 20;
+astPositionState[2].fDelta := 1;
+astPositionState[2].fVelocity := 10;
+SetGoodState(astPositionState[2]);
+
+astPositionState[3].sName := 'TRES';
+astPositionState[3].fPosition := 30;
+astPositionState[3].fDelta := 1;
+astPositionState[3].fVelocity := 10;
+SetGoodState(astPositionState[3]);
+
+bStatesReady := TRUE;
+FOR nIter := 1 TO 3 DO
+    afbInternal[nIter](
+        stMotionStage:=stMotionStage,
+        stPositionState:=astPositionState[nIter],
+    );
+    bStatesReady := bStatesReady AND astPositionState[nIter].bUpdated;
+END_FOR
+stInvalid.bValid := FALSE;
+stInvalid.bUpdated := TRUE;
+stInvalid.bMoveOk := TRUE;
+stNotUpdated.bValid := TRUE;
+stNotUpdated.bUpdated := FALSE;
+stNotUpdated.bMoveOk := TRUE;
+stUnsafe.bValid := TRUE;
+stUnsafe.bUpdated := TRUE;
+stUnsafe.bMoveOk := FALSE;
+
+SetEnables(stMotionStage);
+fbMotionStage(stMotionStage:=stMotionStage);
+
+IF bStatesReady AND nTestCounter = 0 THEN
+    // Don't run any tests until the states are ready
+    nTestCounter := 1;
+    // Warm up the motion FB with a exec false runthrough
+    fbMove(
+        stMotionStage:=stMotionStage,
+        stPositionState:=stDummyPos,
+        bExecute:=FALSE,
+    );
+END_IF
+
+// Test that we can move to state 1 and the outputs are correct as we go
+TestMove(1, 1, FALSE);
+// Test that we can move to state 2 and the outputs are correct as we go
+TestMove(2, 2, FALSE);
+// Test that we can interrupt a move to state 3 by dropping bExecute
+TestMove(3, 3, TRUE);
+// Test that we cannot move to an invalid state
+TestBadStates(4);
+
+IF bOneTestDone THEN
+    bOneTestDone := FALSE;
+    nTestCounter := nTestCounter + 1;
+    fbMove(
+        stMotionStage:=stMotionStage,
+        stPositionState:=stDummyPos,
+        bExecute:=FALSE,
+        bReset:=TRUE,
+    );
+    fbMove(
+        stMotionStage:=stMotionStage,
+        stPositionState:=stDummyPos,
+        bExecute:=FALSE,
+        bReset:=FALSE,
+    );
+    tonTimer(IN:=FALSE);
+END_IF
+// Use this timer to time out any tests that stall
+tonTimer(
+    IN:=bStatesReady,
+    PT:=T#5s,
+);
+
+END_FUNCTION_BLOCK
+
+METHOD TestBadStates
+VAR_INPUT
+    nTestIndex: UINT;
+END_VAR
+TEST(CONCAT('TestInvalid', UINT_TO_STRING(nTestIndex)));
+IF nTestCounter <> nTestIndex THEN
+    RETURN;
+END_IF
+
+AssertFalse(
+    fbMove.bError,
+    'Started with an error',
+);
+
+fbMove(
+    stMotionStage:=stMotionstage,
+    stPositionState:=stInvalid,
+    bExecute:=TRUE,
+);
+
+AssertTrue(
+    fbMove.bError,
+    'Invalid should have given an error',
+);
+
+fbMove(
+    stMotionStage:=stMotionstage,
+    stPositionState:=stInvalid,
+    bExecute:=FALSE,
+    bReset:=TRUE,
+);
+
+AssertFalse(
+    fbMove.bError,
+    'Started with an error',
+);
+
+fbMove(
+    stMotionStage:=stMotionstage,
+    stPositionState:=stNotUpdated,
+    bExecute:=TRUE,
+    bReset:=FALSE,
+);
+
+AssertTrue(
+    fbMove.bError,
+    'Not updated should have given an error',
+);
+
+fbMove(
+    stMotionStage:=stMotionstage,
+    stPositionState:=stNotUpdated,
+    bExecute:=FALSE,
+    bReset:=TRUE,
+);
+
+AssertFalse(
+    fbMove.bError,
+    'Started with an error',
+);
+
+fbMove(
+    stMotionStage:=stMotionstage,
+    stPositionState:=stUnsafe,
+    bExecute:=TRUE,
+    bReset:=FALSE,
+);
+
+AssertTrue(
+    fbMove.bError,
+    'Unsafe should have given an error',
+);
+
+bOneTestDone := TRUE;
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestMove
+VAR_INPUT
+    nTestIndex: UINT;
+    nStateIndex: UINT;
+    bInterrupt: BOOL;
+END_VAR
+VAR_INST
+    bLocalInit: BOOL;
+    bInterruptStarted: BOOL;
+END_VAR
+TEST(CONCAT('TestMove', UINT_TO_STRING(nTestIndex)));
+IF nTestCounter <> nTestIndex THEN
+    RETURN;
+END_IF
+
+IF NOT bLocalInit THEN
+    // Starting output checks
+    AssertFalse(
+        Condition:=fbMove.bBusy,
+        Message:='Tried to start test with busy motor',
+    );
+    AssertFalse(
+        Condition:=fbMove.bError,
+        Message:='Tried to start test with errored motor',
+    );
+    bLocalInit := TRUE;
+END_IF
+
+bInterruptStarted S= bInterrupt AND stMotionStage.bBusy;
+fbMove(
+    stMotionStage:=stMotionstage,
+    stPositionState:=astPositionState[nStateIndex],
+    bExecute:=NOT bInterruptStarted,
+);
+
+IF fbMove.bDone OR tonTimer.Q OR (bInterruptStarted AND NOT fbMove.bBusy) THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Test timed out',
+    );
+    IF bInterrupt THEN
+        AssertFalse(
+            fbMove.bAtState,
+            Message:='Should have been interrupted, but made it to the goal',
+        );
+    ELSE
+        AssertTrue(
+            fbMove.bAtState,
+            Message:='Did not end at the state',
+        );
+        AssertEquals_LREAL(
+            Expected:=astPositionState[nStateIndex].fPosition,
+            Actual:=stMotionStage.stAxisStatus.fActPosition,
+            Delta:=0.01,
+            Message:='Did not reach the goal state',
+        );
+    END_IF
+    AssertFalse(
+        fbMove.bBusy,
+        Message:='Was busy while done',
+    );
+    AssertFalse(
+        fbMove.bError,
+        Message:=CONCAT('Should not end in error: ', stMotionStage.sErrorMessage),
+    );
+
+    bOneTestDone := TRUE;
+    bLocalInit := FALSE;
+    bInterruptStarted := FALSE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateMoveND

+
FUNCTION_BLOCK FB_PositionStateMoveND
+(*
+    This function block coordinates multidimensional state moves for groups of motors.
+    It is a building block not meant for use outside of lcls-twintcat-motion.
+
+    Use FB_PositionState1D, FB_PositionState2D, ... etc. instead
+*)
+VAR_IN_OUT
+    // Array of motors to move together
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    // 1D Position states: the current position to send each axis to
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_PositionState;
+END_VAR
+VAR_INPUT
+    // The number of motors we're actually using
+    nActiveMotorCount: UINT;
+    // Start all moves on rising edge, stop all moves on falling edge
+    bExecute: BOOL;
+    // Reset any errors
+    bReset: BOOL;
+    // Define behavior for when a move request is interrupted with a new request
+    enumMotionRequest: E_MotionRequest := E_MotionRequest.WAIT;
+END_VAR
+VAR_OUTPUT
+    // TRUE if ALL of the motors are at their goal states
+    bAtState: BOOL;
+    // TRUE if ANY of this FB's moves are in progress
+    bBusy: BOOL;
+    // TRUE if ALL motors have completed the last move request from this FB
+    bDone: BOOL;
+    // TRUE if ANY of this FB's moves had an error
+    bError: BOOL;
+    // How many FBs are erroring
+    nErrorCount: UINT;
+    // Which component is the source of the example/summarized error
+    nShownError: DINT;
+    // One of the error ids
+    nErrorID: UDINT;
+    // The error error message matching the ID
+    sErrorMessage: STRING;
+END_VAR
+VAR
+    // 1D State movers: FBs to move the motors
+    afbPositionStateMove: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF FB_PositionStateMove;
+    nIndex: DINT;
+    bMotorCountError: BOOL;
+    nLowerBound: DINT;
+    nUpperBound: DINT;
+END_VAR
+CheckCount();
+IF NOT bMotorCountError THEN
+    DoStateMoves();
+    CombineOutputs();
+END_IF
+
+END_FUNCTION_BLOCK
+
+ACTION CheckCount:
+// Make sure the motor count is valid (positive, nonzero, less or equal to the max)
+bMotorCountError S= nActiveMotorCount <= 0;
+bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS;
+
+IF bMotorCountError THEN
+    bError := TRUE;
+    sErrorMessage := 'Internal Error: invalid motor count';
+END_IF
+END_ACTION
+
+ACTION CombineOutputs:
+// bAtState is TRUE if ALL entries are TRUE
+bAtState := TRUE;
+FOR nIndex := 1 TO nActiveMotorCount DO
+    bAtState := bAtState AND afbPositionStateMove[nIndex].bAtState;
+END_FOR
+
+// bBusy is TRUE if ANY entry is TRUE
+bBusy := FALSE;
+FOR nIndex := 1 TO nActiveMotorCount DO
+    bBusy := bBusy OR afbPositionStateMove[nIndex].bBusy;
+END_FOR
+
+// bDone is TRUE if ALL entries are TRUE
+bDone := TRUE;
+FOR nIndex := 1 TO nActiveMotorCount DO
+    bDone := bDone AND afbPositionStateMove[nIndex].bDone;
+END_FOR
+
+// bError is TRUE if ANY entry is TRUE
+// also set nShownError and increment nErrorCount
+bError := FALSE;
+nErrorCount := 0;
+FOR nIndex := 1 TO nActiveMotorCount DO
+    bError := bError OR afbPositionStateMove[nIndex].bError;
+    IF afbPositionStateMove[nIndex].bError THEN
+        nShownError := nIndex;
+        nErrorCount := nErrorCount + 1;
+    END_IF
+END_FOR
+
+// Pick error id and message using nShownError
+IF bError THEN
+    nErrorID := afbPositionStateMove[nShownError].nErrorID;
+    sErrorMessage := afbPositionStateMove[nShownError].sErrorMessage;
+ELSE
+    nErrorID := 0;
+    sErrorMessage := '';
+END_IF
+END_ACTION
+
+ACTION DoStateMoves:
+// Do the individual moves
+FOR nIndex := 1 TO nActiveMotorCount DO
+    afbPositionStateMove[nIndex](
+        stMotionStage:=astMotionStage[nIndex],
+        stPositionState:=astPositionState[nIndex],
+        bExecute:=bExecute,
+        bReset:=bReset,
+        enumMotionRequest:=enumMotionRequest,
+    );
+END_FOR
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateMoveND_Test

+
FUNCTION_BLOCK FB_PositionStateMoveND_Test EXTENDS FB_MotorTestSuite
+(*
+    Test that FB_PositionStateMoveND can be used to move motors to named state positions
+    And that the API behaves exactly as described.
+*)
+VAR
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    afbMotionStage: ARRAY[1..3] OF FB_MotionStage;
+    astGoalPositions: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_PositionState;
+    afbInternal: ARRAY[1..3] OF FB_PositionStateInternal;
+    stDummyPos: ST_PositionState;
+    fbMove: FB_PositionStateMoveND;
+
+    bInit: BOOL;
+    nTestCounter: UINT;
+    bOneTestDone: BOOL;
+    fTestStartPos: LREAL;
+    tonTimer: TON;
+    nIter: DINT;
+    bStatesReady: BOOL;
+END_VAR
+IF NOT bInit THEN
+    ResetGoals();
+    bInit := TRUE;
+END_IF
+
+bStatesReady := TRUE;
+FOR nIter := 1 TO 3 DO
+    afbInternal[nIter](
+        stMotionStage:=astMotionStage[nIter],
+        stPositionState:=astGoalPositions[nIter],
+    );
+    bStatesReady := bStatesReady AND astGoalPositions[nIter].bUpdated;
+    SetEnables(astMotionStage[nIter]);
+    afbMotionStage[nIter](stMotionStage:=astMotionStage[nIter]);
+END_FOR
+
+IF bStatesReady AND nTestCounter = 0 THEN
+    // Don't run any tests until the states are ready
+    nTestCounter := 1;
+    // Warm up the motion FB with a exec false runthrough
+    fbMove(
+        astMotionStage := astMotionStage,
+        astPositionState := astGoalPositions,
+        nActiveMotorCount := 3,
+        bExecute := FALSE,
+    );
+END_IF
+
+// Move to somewhere
+TestMove(1, 1, 5, 10, FALSE);
+// Somewhere else
+TestMove(2, -10, 0, 5, FALSE);
+// Interrupt on the way to the last place
+TestMove(3, 0, 0, 0, TRUE);
+
+IF bOneTestDone THEN
+    bOneTestDone := FALSE;
+    nTestCounter := nTestCounter + 1;
+    ResetGoals();
+    fbMove(
+        astMotionStage := astMotionStage,
+        astPositionState := astGoalPositions,
+        nActiveMotorCount := 3,
+        bExecute := FALSE,
+        bReset := TRUE,
+    );
+    tonTimer(IN:=FALSE);
+END_IF
+// Use this timer to time out any tests that stall
+tonTimer(
+    IN:=bStatesReady,
+    PT:=T#5s,
+);
+
+END_FUNCTION_BLOCK
+
+METHOD ResetGoals
+VAR_INPUT
+END_VAR
+astGoalPositions[1].sName := 'Goal1';
+astGoalPositions[1].fPosition := 0;
+astGoalPositions[1].fDelta := 1;
+astGoalPositions[1].fVelocity := 10;
+astGoalPositions[1].bUseRawCounts := FALSE;
+SetGoodState(astGoalPositions[1]);
+
+astGoalPositions[2].sName := 'Goal2';
+astGoalPositions[2].fPosition := 0;
+astGoalPositions[2].fDelta := 1;
+astGoalPositions[2].fVelocity := 10;
+astGoalPositions[2].bUseRawCounts := FALSE;
+SetGoodState(astGoalPositions[2]);
+
+astGoalPositions[3].sName := 'Goal3';
+astGoalPositions[3].fPosition := 0;
+astGoalPositions[3].fDelta := 1;
+astGoalPositions[3].fVelocity := 10;
+astGoalPositions[3].bUseRawCounts := FALSE;
+SetGoodState(astGoalPositions[3]);
+END_METHOD
+
+METHOD TestMove
+VAR_INPUT
+    nTestIndex: UINT;
+    fMotor1Pos: LREAL;
+    fMotor2Pos: LREAL;
+    fMotor3Pos: LREAL;
+    bInterrupt: BOOL;
+END_VAR
+VAR_INST
+    bLocalInit: BOOL;
+    bInterruptStarted: BOOL;
+END_VAR
+TEST(CONCAT('TestMove', UINT_TO_STRING(nTestIndex)));
+IF nTestCounter <> nTestIndex THEN
+    RETURN;
+END_IF
+
+IF NOT bLocalInit THEN
+    // Starting output checks
+    AssertFalse(
+        Condition:=fbMove.bBusy,
+        Message:='Tried to start test with busy motor',
+    );
+    AssertFalse(
+        Condition:=fbMove.bError,
+        Message:='Tried to start test with errored motor',
+    );
+    bLocalInit := TRUE;
+END_IF
+
+astGoalPositions[1].fPosition := fMotor1Pos;
+astGoalPositions[2].fPosition := fMotor2Pos;
+astGoalPositions[3].fPosition := fMotor3Pos;
+
+bInterruptStarted S= bInterrupt AND astMotionStage[1].bBusy AND astMotionStage[2].bBusy AND astMotionStage[3].bBusy;
+fbMove(
+    astMotionStage:=astMotionStage,
+    astPositionState:=astGoalPositions,
+    nActiveMotorCount:=3,
+    bExecute:=NOT bInterruptStarted,
+);
+IF fbMove.bDone OR tonTimer.Q OR (bInterruptStarted AND NOT fbMove.bBusy) THEN
+    IF bInterrupt THEN
+        AssertFalse(
+            fbMove.bAtState,
+            Message:='Should have been interrupted, but made it to the goal',
+        );
+    ELSE
+        AssertTrue(
+            fbMove.bAtState,
+            Message:='Did not end at the state',
+        );
+        FOR nIter := 1 TO 3 DO
+            AssertEquals_LREAL(
+                Expected:=astGoalPositions[nIter].fPosition,
+                Actual:=astMotionStage[nIter].stAxisStatus.fActPosition,
+                Delta:=0.01,
+                Message:='Did not reach the goal state',
+            );
+        END_FOR
+
+    END_IF
+    AssertFalse(
+        fbMove.bBusy,
+        Message:='Was busy while done',
+    );
+    AssertFalse(
+        fbMove.bError,
+        Message:='Should not end in error',
+    );
+
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateND_Core

+
FUNCTION_BLOCK FB_PositionStateND_Core
+(*
+    Collection of all the actions shared between all states FBs
+    This is used in e.g.
+    - FB_PositionState1D
+    - FB_PositionState2D
+    - ... etc.
+    - FB_PositionStatePMPS1D
+    - FB_PositionStatePMPS2D
+    - ... etc.
+
+    This is essentially input handling, position state reading, standard management blocks, and the motion state machine.
+*)
+VAR_IN_OUT
+    // All motors to be used in the states move, including blank/uninitialized structs.
+    astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    // All position states for all motors, including unused/invalid states.
+    astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Normal EPICS inputs, gathered into a single struct
+    stEpicsToPlc: ST_StateEpicsToPlc;
+    // Normal EPICS outputs, gathered into a single struct
+    stPlcToEpics: ST_StatePlcToEpics;
+    // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input.
+    eEnumSet: UINT;
+    // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output.
+    eEnumGet: UINT;
+END_VAR
+VAR_INPUT
+    // Set this to TRUE to enable input state moves, or FALSE to disable them.
+    bEnable: BOOL;
+    // Set this to the number of motors to be included in astMotionStageMax
+    nActiveMotorCount: UINT;
+END_VAR
+VAR_OUTPUT
+    // The current position index goal, where the motors are supposed to be moving towards.
+    nCurrGoal: UINT;
+END_VAR
+VAR
+    fbInput: FB_StatesInputHandler;
+    fbInternal: FB_PositionStateInternalND;
+    fbMove: FB_PositionStateMoveND;
+    fbRead: FB_PositionStateReadND;
+    astMoveGoals: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_PositionState;
+    stInvalidPos: ST_PositionState;
+    nIterMotor: DINT;
+END_VAR
+stEpicsToPlc.nSetValue := eEnumSet;
+
+fbInternal(
+    astMotionStage:=astMotionStageMax,
+    astPositionState:=astPositionStateMax,
+);
+
+fbRead(
+    astMotionStage:=astMotionStageMax,
+    astPositionState:=astPositionStateMax,
+    nActiveMotorCount:=nActiveMotorCount,
+    bKnownState=>,
+    bMovingState=>,
+    nPositionIndex=>stPlcToEpics.nGetValue,
+);
+
+fbInput(
+    stUserInput:=stEpicsToPlc,
+    bMoveBusy:=fbMove.bBusy,
+    nStartingState:=fbRead.nPositionIndex,
+    nCurrGoal=>nCurrGoal,
+    bExecMove=>,
+    bResetMove=>,
+);
+
+FOR nIterMotor := 1 TO MotionConstants.MAX_STATE_MOTORS DO
+    IF nCurrGoal > 0 THEN
+        astMoveGoals[nIterMotor] := astPositionStateMax[nIterMotor][nCurrGoal];
+    ELSE
+        astMoveGoals[nIterMotor] := stInvalidPos;
+    END_IF
+END_FOR
+
+fbMove(
+    astMotionStage:=astMotionStageMax,
+    astPositionState:=astMoveGoals,
+    nActiveMotorCount:=nActiveMotorCount,
+    bExecute:=fbInput.bExecMove AND bEnable,
+    bReset:=fbInput.bResetMove,
+    enumMotionRequest:=E_MotionRequest.INTERRUPT,
+    bAtState=>,
+    bError=>stPlcToEpics.bError,
+    nErrorID=>stPlcToEpics.nErrorID,
+    sErrorMessage=>stPlcToEpics.sErrorMsg,
+    bBusy=>stPlcToEpics.bBusy,
+    bDone=>stPlcToEpics.bDone,
+);
+
+eEnumSet := stEpicsToPlc.nSetValue;
+eEnumGet := stPlcToEpics.nGetValue;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateND_Test

+
FUNCTION_BLOCK FB_PositionStateND_Test EXTENDS FB_MotorTestSuite
+(*
+    Sanity checks for the following:
+    - FB_PositionState1D
+    - FB_PositionState2D
+    - FB_PositionState3D
+    The internals have already been tested, but we need to make sure that
+    they've been put together at least somewhat sensibly.
+    This FB will simply use each FB to move and check the results.
+
+    Additional tests:
+    - Regression test for issue #197 (input deadlock)
+*)
+VAR
+    stMotionStage1: ST_MotionStage;
+    stMotionStage2: ST_MotionStage;
+    stMotionStage3: ST_MotionStage;
+    astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    astPositionState3: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    afbInternal: ARRAY[1..3] OF ARRAY[1..3] OF FB_PositionStateInternal;
+    afbMotionStage: ARRAY[1..3] OF FB_MotionStage;
+
+    fb_Move1D: FB_PositionState1D;
+    fb_Move2D: FB_PositionState2D;
+    fb_Move3D: FB_PositionState3D;
+
+    nTestCounter: UINT;
+    bOneTestDone: BOOL;
+    fTestStartPos: LREAL;
+    tonTimer: TON;
+    nIter: DINT;
+    bStatesReady: BOOL;
+
+    eSetPos: E_TestStates;
+    eGetPos: E_TestStates;
+END_VAR
+bStatesReady := TRUE;
+FOR nIter := 1 TO 3 DO;
+    astPositionState1[nIter].fPosition := nIter;
+    astPositionState1[nIter].fDelta := 1;
+    astPositionState1[nIter].fVelocity := 100;
+    astPositionState2[nIter].fPosition := 10 + nIter;
+    astPositionState2[nIter].fDelta := 1;
+    astPositionState2[nIter].fVelocity := 100;
+    astPositionState3[nIter].fPosition := 20 + nIter;
+    astPositionState3[nIter].fDelta := 1;
+    astPositionState3[nIter].fVelocity := 100;
+    afbInternal[nIter][1](
+        stMotionStage:=stMotionStage1,
+        stPositionState:=astPositionState1[nIter],
+    );
+    afbInternal[nIter][2](
+        stMotionStage:=stMotionStage2,
+        stPositionState:=astPositionState2[nIter],
+    );
+    afbInternal[nIter][3](
+        stMotionStage:=stMotionStage3,
+        stPositionState:=astPositionState3[nIter],
+    );
+    SetGoodState(astPositionState1[nIter]);
+    SetGoodState(astPositionState2[nIter]);
+    SetGoodState(astPositionState3[nIter]);
+    bStatesReady := bStatesReady AND astPositionState1[nIter].bUpdated;
+    bStatesReady := bStatesReady AND astPositionState2[nIter].bUpdated;
+    bStatesReady := bStatesReady AND astPositionState3[nIter].bUpdated;
+END_FOR
+SetEnables(stMotionStage1);
+SetEnables(stMotionStage2);
+SetEnables(stMotionStage3);
+afbMotionStage[1](stMotionStage:=stMotionStage1);
+afbMotionStage[2](stMotionStage:=stMotionStage2);
+afbMotionStage[3](stMotionStage:=stMotionStage3);
+
+IF bStatesReady AND nTestCounter = 0 THEN
+    // Don't run any tests until the states are ready
+    nTestCounter := 1;
+    // Run all the motion FBs for one cycle to warm them up
+    fb_Move1D(
+        stMotionStage:=stMotionStage1,
+        astPositionState:=astPositionState1,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        bEnable:=TRUE,
+    );
+    fb_Move2D(
+        stMotionStage1:=stMotionStage1,
+        stMotionStage2:=stMotionStage2,
+        astPositionState1:=astPositionState1,
+        astPositionState2:=astPositionState2,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        bEnable:=TRUE,
+    );
+    fb_Move3D(
+        stMotionStage1:=stMotionStage1,
+        stMotionStage2:=stMotionStage2,
+        stMotionStage3:=stMotionStage3,
+        astPositionState1:=astPositionState1,
+        astPositionState2:=astPositionState2,
+        astPositionState3:=astPositionState3,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        bEnable:=TRUE,
+    );
+END_IF
+
+Test1D(1, E_TestStates.OUT);
+Test1D(2, E_TestStates.TARGET1);
+Test1D(3, E_TestStates.TARGET2);
+Test2D(4, E_TestStates.OUT);
+Test2D(5, E_TestStates.TARGET1);
+Test2D(6, E_TestStates.TARGET2);
+Test3D(7, E_TestStates.OUT);
+Test3D(8, E_TestStates.TARGET1);
+Test3D(9, E_TestStates.TARGET2);
+TestInputDeadlock(10);
+
+IF bOneTestDone THEN
+    bOneTestDone := FALSE;
+    nTestCounter := nTestCounter + 1;
+    tonTimer(IN:=FALSE);
+END_IF
+// Use this timer to time out any tests that stall
+tonTimer(
+    IN:=bStatesReady,
+    PT:=T#5s,
+);
+
+END_FUNCTION_BLOCK
+
+METHOD Test1D
+VAR_INPUT
+    nTestID: UINT;
+    nState: E_TestStates;
+END_VAR
+VAR_INST
+    nLocalInit: BOOL;
+END_VAR
+TEST(CONCAT('Test1D_state', DINT_TO_STRING(nState)));
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+IF NOT nLocalInit THEN
+    eSetPos := nState;
+    nLocalInit := TRUE;
+END_IF
+
+fb_Move1D(
+    stMotionStage:=stMotionStage1,
+    astPositionState:=astPositionState1,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    bEnable:=TRUE,
+);
+IF tonTimer.Q OR fb_Move1D.stPlcToEpics.bDone THEN
+    AssertTrue(
+        Condition:=fb_Move1D.stPlcToEpics.bDone,
+        Message:='Done should be True after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move1D.stPlcToEpics.bBusy,
+        Message:='Busy should be False after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move1D.stPlcToEpics.bError,
+        Message:='Error should be False after move',
+    );
+    AssertEquals_DINT(
+        Expected:=nState,
+        Actual:=eGetPos,
+        Message:='Did not get to the input state',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState1[nState].fPosition,
+        Actual:=stMotionStage1.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position',
+    );
+    fb_Move1D.stEpicsToPlc.bReset := TRUE;
+    fb_Move1D(
+        stMotionStage:=stMotionStage1,
+        astPositionState:=astPositionState1,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        bEnable:=TRUE,
+    );
+    bOneTestDone := TRUE;
+    nLocalInit := FALSE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD Test2D
+VAR_INPUT
+    nTestID: UINT;
+    nState: E_TestStates;
+END_VAR
+VAR_INST
+    nLocalInit: BOOL;
+END_VAR
+TEST(CONCAT('Test2D_state', DINT_TO_STRING(nState)));
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+IF NOT nLocalInit THEN
+    eSetPos := nState;
+    nLocalInit := TRUE;
+END_IF
+
+fb_Move2D(
+    stMotionStage1:=stMotionStage1,
+    stMotionStage2:=stMotionStage2,
+    astPositionState1:=astPositionState1,
+    astPositionState2:=astPositionState2,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    bEnable:=TRUE,
+);
+IF tonTimer.Q OR fb_Move2D.stPlcToEpics.bDone THEN
+    AssertTrue(
+        Condition:=fb_Move2D.stPlcToEpics.bDone,
+        Message:='Done should be True after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move2D.stPlcToEpics.bBusy,
+        Message:='Busy should be False after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move2D.stPlcToEpics.bError,
+        Message:='Error should be False after move',
+    );
+    AssertEquals_DINT(
+        Expected:=nState,
+        Actual:=eGetPos,
+        Message:='Did not get to the input state',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState1[nState].fPosition,
+        Actual:=stMotionStage1.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position for stage 1',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState2[nState].fPosition,
+        Actual:=stMotionStage2.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position for stage 2',
+    );
+    fb_Move2D.stEpicsToPlc.bReset := TRUE;
+    fb_Move2D(
+        stMotionStage1:=stMotionStage1,
+        stMotionStage2:=stMotionStage2,
+        astPositionState1:=astPositionState1,
+        astPositionState2:=astPositionState2,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        bEnable:=TRUE,
+    );
+    bOneTestDone := TRUE;
+    nLocalInit := FALSE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD Test3D
+VAR_INPUT
+    nTestID: UINT;
+    nState: E_TestStates;
+END_VAR
+VAR_INST
+    nLocalInit: BOOL;
+END_VAR
+TEST(CONCAT('Test3D_state', DINT_TO_STRING(nState)));
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+IF NOT nLocalInit THEN
+    eSetPos := nState;
+    nLocalInit := TRUE;
+END_IF
+
+fb_Move3D(
+    stMotionStage1:=stMotionStage1,
+    stMotionStage2:=stMotionStage2,
+    stMotionStage3:=stMotionStage3,
+    astPositionState1:=astPositionState1,
+    astPositionState2:=astPositionState2,
+    astPositionState3:=astPositionState3,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    bEnable:=TRUE,
+);
+IF tonTimer.Q OR fb_Move3D.stPlcToEpics.bDone THEN
+    AssertTrue(
+        Condition:=fb_Move3D.stPlcToEpics.bDone,
+        Message:='Done should be True after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move3D.stPlcToEpics.bBusy,
+        Message:='Busy should be False after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move3D.stPlcToEpics.bError,
+        Message:='Error should be False after move',
+    );
+    AssertEquals_DINT(
+        Expected:=nState,
+        Actual:=eGetPos,
+        Message:='Did not get to the input state',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState1[nState].fPosition,
+        Actual:=stMotionStage1.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position for stage 1',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState2[nState].fPosition,
+        Actual:=stMotionStage2.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position for stage 2',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState3[nState].fPosition,
+        Actual:=stMotionStage3.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position for stage 3',
+    );
+    fb_Move3D.stEpicsToPlc.bReset := TRUE;
+    fb_Move3D(
+        stMotionStage1:=stMotionStage1,
+        stMotionStage2:=stMotionStage2,
+        stMotionStage3:=stMotionStage3,
+        astPositionState1:=astPositionState1,
+        astPositionState2:=astPositionState2,
+        astPositionState3:=astPositionState3,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        bEnable:=TRUE,
+    );
+    bOneTestDone := TRUE;
+    nLocalInit := FALSE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestInputDeadlock
+(*
+    Regression test for issue #197
+
+    How to reproduce the issue:
+    1. Get the function block into any motion error
+    2. Ask for a move while in the error state
+
+    Then, the state mover never moves again.
+
+    To test we will follow steps 1 and 2, then reset the error, then move.
+
+    With our fix, our second attempt at the move (after an error reset) will succeed.
+    Our first attempt will fail regardless, since you cannot move a motor that is in an error state.
+
+    Without our fix, the motor could never be moved ever again and this move will time out.
+*)
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    nTestStep: UINT := 1;
+    eNewGoal: E_TestStates;
+END_VAR
+TEST('TestInputDeadlock');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+CASE nTestStep OF
+    // Step 1: Normal move
+    1:
+        // Normal move: pick any other state
+        IF eGetPos = E_TestStates.OUT THEN
+            eNewGoal := E_TestStates.TARGET1;
+        ELSE
+            eNewGoal := E_TestStates.OUT;
+        END_IF
+        eSetPos := eNewGoal;
+        nTestStep := 2;
+    // Step 2: Cause a motion error. Easiest is to just set bError to TRUE during a move.
+    2:
+        // Cause the error if it's time
+        IF stMotionStage1.bBusy THEN
+            stMotionStage1.bError := TRUE;
+            stMotionStage1.nErrorId := 16#4FFF;
+        ELSIF stMotionStage1.bError THEN
+            nTestStep := 3;
+        END_IF
+     // Step 3: another normal move. This should get us into the potential bugged state.
+     3:
+        eSetPos := eNewGoal;
+        nTestStep := 4;
+    // Step 4: reset the error, which will allow fixed versions of the code to resume normal operations.
+    4:
+        fb_Move1D.stEpicsToPlc.bReset := TRUE;
+        IF NOT stMotionStage1.bError THEN
+            nTestStep := 5;
+        END_IF
+    // Step 5: last normal move, which will succeed if we fixed the bug.
+    5:
+        eSetPos := eNewGoal;
+        IF eGetPos = E_TestStates.Unknown THEN
+            nTestStep := 6;
+        END_IF
+    // Step 6: wait for the move to finish
+    6:
+        IF eGetPos = eNewGoal THEN
+            nTestStep := 7;
+        END_IF
+END_CASE
+
+fb_Move1D(
+    stMotionStage:=stMotionStage1,
+    astPositionState:=astPositionState1,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    bEnable:=TRUE,
+);
+
+// Timeout and checks
+IF tonTimer.Q OR nTestStep = 7 THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in deadlock test',
+    );
+    AssertEquals_UINT(
+        Expected:=eNewGoal,
+        Actual:=eGetPos,
+        'Did not reach a goal state in deadlock test',
+    );
+    fb_Move1D.stEpicsToPlc.bReset := TRUE;
+    fb_Move1D(
+        stMotionStage:=stMotionStage1,
+        astPositionState:=astPositionState1,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        bEnable:=TRUE,
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPS

+
{attribute 'obsolete' := 'Use FB_PositionStatePMPS1D instead'}
+FUNCTION_BLOCK FB_PositionStatePMPS EXTENDS FB_PositionStatePMPS_Base
+(*
+    Hooks up a position state to an arbiter and an FFO
+        Use BeamParameterTransitionManager to manage transition requests between states
+        Hook up to the inputs/outputs of the state function block
+        Raises FFO if beam parameters are worse than required for current state
+*)
+VAR_IN_OUT
+    fbArbiter: FB_Arbiter;
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    bReadPmpsDb: BOOL;
+    sPmpsDeviceName: STRING;
+    sTransitionKey: STRING;
+    stPmpsDoc: SJsonValue;
+    stHighBeamThreshold: ST_BeamParams := PMPS_GVL.cstFullBeam;
+    bBPOKAutoReset: BOOL := False;
+END_VAR
+VAR
+    arrPMPS: ARRAY[0..GeneralConstants.MAX_STATES] OF ST_DbStateParams;
+    nBPIndex: UINT;
+    nTransitionAssertionID: UDINT;
+    nLastReqAssertionID: UDINT;
+    fbReadPmpsDb: FB_JsonDocToSafeBP;
+    ftDbBusy: F_TRIG;
+    rtReadDBExec: R_TRIG;
+    ftRead: F_TRIG;
+    bptm: BeamParameterTransitionManager;
+    ffBeamParamsOk: FB_FastFault;
+    ffZeroRate: FB_FastFault;
+    ffBPTMTimeoutAndMove: FB_FastFault;
+    ffBPTMError: FB_FastFault;
+    ffMaint: FB_FastFault;
+    ffUnknown: FB_FastFault;
+    bFFOxOk: BOOL;
+    bAtSafeState: BOOL;
+    nIter: UINT;
+END_VAR
+Exec();
+
+END_FUNCTION_BLOCK
+
+ACTION AssertHere:
+fbArbiter.AddRequest(
+    sDevName := stMotionStage.sName,
+    nReqID := stStateReq.stPMPS.nRequestAssertionID,
+    stReqBP := stStateReq.stPMPS.stBeamParams);
+END_ACTION
+
+ACTION ClearAsserts:
+fbArbiter.RemoveRequest(nTransitionAssertionID);
+FOR nIter := 1 TO GeneralConstants.MAX_STATES DO
+    fbArbiter.RemoveRequest(arrStates[nIter].stPMPS.nRequestAssertionID);
+END_FOR
+END_ACTION
+
+ACTION HandleBPTM:
+(*
+  Handle finishing the bptm late if timed out
+  bptm needs a rising edge of bTransDone after authorizing transition
+  If we fall into this block, bTransDone would otherwise be stuck at TRUE forever
+  so the BPTM would never see a rising edge and therefore stay stuck
+  We set to FALSE here to reset the BPTM, then gets set to TRUE again if really done.
+*)
+rtDoLateFinish(CLK:=bLateFinish AND bInternalAuth);
+IF rtDoLateFinish.Q THEN
+    bTransDone := FALSE;
+    bLateFinish := FALSE;
+END_IF
+
+IF stStateReq.stPMPS.nRequestAssertionID <> nTransitionAssertionID THEN
+    (*
+        Edge case: the request is swapped out without a move
+        Same as above: we need a rising edge of bTransDone, so cause a falling edge and the let the rising edge happen next cycle
+        This will already be false when we request a positional move
+    *)
+    bTransDone R= stStateReq.stPMPS.nRequestAssertionID <> nLastReqAssertionID;
+    // Just normal bptm call
+    bptm(fbArbiter:=fbArbiter,
+         i_sDeviceName:=stMotionStage.sName,
+         i_TransitionAssertionID:=nTransitionAssertionID,
+         i_stTransitionAssertion:=stTransitionBeam,
+         i_nRequestedAssertionID:=stStateReq.stPMPS.nRequestAssertionID,
+         i_stRequestedAssertion:=stStateReq.stPMPS.stBeamParams,
+         i_xDoneMoving:=bTransDone,
+         stCurrentBeamParameters:=PMPS_GVL.stCurrentBeamParameters,
+         q_xTransitionAuthorized=>bInternalAuth,
+         bDone=>bBPTMDone);
+    nLastReqAssertionID := stStateReq.stPMPS.nRequestAssertionID;
+END_IF
+END_ACTION
+
+ACTION HandleFFO:
+// stBeamNeeded will point to Unknown/No beam if we are out of state bounds or in motion
+// Otherwise we'll have the current state's beam parameters
+
+// Check for bad conditions
+bFFOxOk := F_SafeBPCompare(PMPS_GVL.stCurrentBeamParameters, stBeamNeeded);
+// It is safe to reset automatically if our current state can take full beam.
+// Otherwise we'll have to ask for a user acknowledgement to clear.
+// This avoids rapidly cycling the FFOs on/off
+// You can pass in a different stHighBeamThreshold as an input parameter to customize this behavior
+bAtSafeState := F_SafeBPCompare(stHighBeamThreshold, stBeamNeeded);
+
+// If the beam parameters are wrong, it is a fault! This encompasses all unknown arbiter-related errors.
+ffBeamParamsOk.i_xOK := bFFOxOk;
+ffBeamParamsOk.i_xReset S= bFFOxOk AND bAtSafeState;
+ffBeamParamsOk.i_xReset R= NOT ffBeamParamsOk.i_xOK;
+ffBeamParamsOk.i_xAutoReset := bBPOKAutoReset;
+
+ffBeamParamsOk(
+    i_DevName:=stMotionStage.sName,
+    i_Desc:='Beam parameter mismatch',
+    i_TypeCode:=16#1000,
+    io_fbFFHWO:=fbFFHWO);
+
+// Trip the beam for zero-rate states. This is a PMPS training wheel and should ultimately be removed.
+// Note: I think this is already redundant
+ffZeroRate(
+    i_xOk := stBeamNeeded.nRate > 0,
+    i_xAutoReset := TRUE,
+    i_DevName := stMotionStage.sName,
+    i_Desc := 'Device requesting zero rate',
+    i_TypeCode := 16#1001,
+    io_fbFFHWO := fbFFHWO);
+
+// Trip the beam for BPTM timeouts if we want to move
+// Only reset at safe beam OR at no bptm errors (some other FF should catch additional issues)
+ffBPTMTimeoutAndMove.i_xOK := NOT (bArbiterTimeout AND bMoveOnArbiterTimeout);
+ffBPTMTimeoutAndMove.i_xReset S= bAtSafeState OR (bptm.bDone AND NOT bptm.bError);
+ffBPTMTimeoutAndMove.i_xReset R= NOT ffBPTMTimeoutAndMove.i_xOK;
+ffBPTMTimeoutAndMove(
+    i_DevName := stMotionStage.sName,
+    i_Desc := 'BPTM Timeout',
+    i_TypeCode := 16#1002,
+    io_fbFFHWO := fbFFHWO);
+
+// Trip the beam for BPTM Errors
+ffBPTMError.i_xOK := NOT bptm.bError;
+ffBPTMError.i_xReset S= bptm.bDone AND NOT bptm.bError;
+ffBPTMError.i_xReset R= NOT ffBPTMError.i_xOK;
+ffBPTMError(
+    i_DevName := stMotionStage.sName,
+    i_Desc := 'BPTM error, state transition failed',
+    i_TypeCode := 16#1003,
+    io_fbFFHWO := fbFFHWO);
+
+// Trip the beam for maintenance mode
+ffMaint(
+    i_xOK := NOT bMaintMode,
+    i_xAutoReset := TRUE,
+    i_DevName := stMotionStage.sName,
+    i_Desc := 'Device is in maintenance mode',
+    i_TypeCode := 16#1004,
+    io_fbFFHWO := fbFFHWO);
+
+// Trip the beam for unknown state
+ffUnknown(
+    i_xOK := getState > 0 OR bInTransition,
+    i_xAutoReset := TRUE,
+    i_DevName := stMotionStage.sName,
+    i_Desc := 'Unknown position between moves',
+    i_TypeCode := 16#1005,
+    io_fbFFHWO := fbFFHWO);
+END_ACTION
+
+ACTION HandlePmpsDb:
+// Automatically read from the pmps db when it updates
+// Assume update if no longer busy and no errors
+
+ftDbBusy(CLK:=MOTION_GVL.fbPmpsFileReader.bBusy);
+IF ftDbBusy.Q THEN
+    bReadPmpsDb S= NOT MOTION_GVL.fbPmpsFileReader.bError;
+END_IF
+
+rtReadDBExec(CLK:=bReadPmpsDb);
+IF rtReadDBExec.Q THEN
+    arrPMPS[0].sPmpsState := sTransitionKey;
+    FOR nBPIndex := 1 TO GeneralConstants.MAX_STATES BY 1 DO
+        arrPMPS[nBPIndex] := arrStates[nBPIndex].stPMPS;
+    END_FOR
+END_IF
+
+fbReadPmpsDb(
+    bExecute:=bReadPmpsDb,
+    jsonDoc:=stPmpsDoc,
+    sDeviceName:=sPmpsDeviceName,
+    io_fbFFHWO:=fbFFHWO,
+    arrStates:=arrPMPS,
+);
+bReadPmpsDb R= NOT fbReadPmpsDb.bBusy;
+
+ftRead(CLK:=fbReadPmpsDb.bBusy);
+
+stTransitionState.sName := 'Transition';
+IF ftRead.Q AND NOT fbReadPmpsDb.bError THEN
+    stTransitionDb := arrPMPS[0];
+    stTransitionBeam := arrPMPS[0].stBeamParams;
+    nTransitionAssertionID := arrPMPS[0].nRequestAssertionID;
+    stTransitionState.stPMPS := arrPMPS[0];
+    FOR nBPIndex := 1 TO GeneralConstants.MAX_STATES BY 1 DO
+        arrStates[nBPIndex].stPMPS := arrPMPS[nBPIndex];
+    END_FOR
+END_IF
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPS1D

+
FUNCTION_BLOCK FB_PositionStatePMPS1D
+(*
+    1-Dimensional position state function block with PMPS.
+
+    This allows the user to move a motor among some set of named state positions with PMPS protection.
+
+    To use a states block, you must define enums that match the state options and give them pytmc pragmas.
+    See FB_PositionState1D_InOut for a simple example.
+    These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables.
+    The enum values must match the array indices in astPositionState.
+
+    A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us
+    to accept a new, possibly conflicting, move request on the next cycle to interrupt the first.
+
+    The motor must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly.
+
+    PMPS handling is done via database lookups by setting sPmpsState on each position state and on
+    the transition state input appropriately.
+*)
+VAR_IN_OUT
+    // The motor to move.
+    stMotionStage: ST_MotionStage;
+    // All possible position states, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input.
+    eEnumSet: UINT;
+    // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output.
+    eEnumGet: UINT;
+    // The fast fault output to fault to.
+    fbFFHWO: FB_HardwareFFOutput;
+    // The arbiter to request beam conditions from.
+    fbArbiter: FB_Arbiter;
+END_VAR
+VAR_INPUT
+    // Set this to TRUE to enable input state moves, or FALSE to disable them.
+    bEnableMotion: BOOL;
+    // Set this to TRUE to enable beam parameter checks, or FALSE to disable them.
+    bEnableBeamParams: BOOL;
+    // Set this to TRUE to enable position limit checks, or FALSE to disable them.
+    bEnablePositionLimits: BOOL;
+    // The name of the device for use in the PMPS DB lookup and diagnostic screens.
+    sDeviceName: STRING;
+    // The name of the transition state in the PMPS database.
+    sTransitionKey: STRING;
+    // Normal EPICS inputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stEpicsToPlc: ST_StateEpicsToPlc;
+    // PMPS EPICS inputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPMPSEpicsToPlc: ST_StatePMPSEpicsToPlc;
+    // Set this to TRUE to re-read the loaded database immediately (useful for debug)
+    bReadDBNow: BOOL;
+END_VAR
+VAR_OUTPUT
+    // Normal EPICS outputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPlcToEpics: ST_StatePlcToEpics;
+    // PMPS EPICS outputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPMPSPlcToEpics: ST_StatePMPSPlcToEpics;
+    // The PMPS database lookup associated with the current position state.
+    stDbStateParams: ST_DbStateParams;
+END_VAR
+VAR
+    fbCore: FB_PositionStateND_Core;
+    fbPMPSCore: FB_PositionStatePMPSND_Core;
+    astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+astMotionStageMax[1] := stMotionStage;
+astPositionStateMax[1] := astPositionState;
+
+fbCore(
+    astMotionStageMax:=astMotionStageMax,
+    astPositionStateMax:=astPositionStateMax,
+    stEpicsToPlc:=stEpicsToPlc,
+    stPlcToEpics:=stPlcToEpics,
+    eEnumSet:=eEnumSet,
+    eEnumGet:=eEnumGet,
+    bEnable:=bEnableMotion,
+    nActiveMotorCount:=1,
+    nCurrGoal=>,
+);
+fbPMPSCore(
+    astMotionStageMax:=astMotionStageMax,
+    astPositionStateMax:=astPositionStateMax,
+    stEpicsToPlc:=stEpicsToPlc,
+    stPMPSEpicsToPlc:=stPMPSEpicsToPlc,
+    stPlcToEpics:=stPlcToEpics,
+    stPMPSPlcToEpics:=stPMPSPlcToEpics,
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter,
+    bEnableBeamParams:=bEnableBeamParams,
+    bEnablePositionLimits:=bEnablePositionLimits,
+    nActiveMotorCount:=1,
+    sDeviceName:=sDeviceName,
+    sTransitionKey:=sTransitionKey,
+    nCurrGoal:=fbCore.nCurrGoal,
+    bReadDBNow:=bReadDBNow,
+    stDbStateParams=>stDbStateParams,
+);
+
+stMotionStage := astMotionStageMax[1];
+astPositionState := astPositionStateMax[1];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPS1D_InOut

+
FUNCTION_BLOCK FB_PositionStatePMPS1D_InOut
+(*
+    An example and usable drop-in instance for a 1D pmps state device with just an IN and an OUT state.
+    Note that the outward-facing API is nearly identical to the non-PMPS version
+*)
+VAR_IN_OUT
+    // Include a stage that can be passed into the FB
+    stMotionStage: ST_MotionStage;
+    // Simplify the interface, the user just needs to construct and pass in and out position states
+    stIn: ST_PositionState;
+    stOut: ST_PositionState;
+    // Include PMPS output helpers
+    fbFFHWO: FB_HardwareFFOutput;
+    fbArbiter: FB_Arbiter;
+END_VAR
+VAR_INPUT
+    // Define an ENUM for EPICS to use to set a new value. It is expected this will be written to during one cycle, so don't continually apply a value here in the PLC code.
+    // It is exposed as an input so we can test it using the PLC.
+    {attribute 'pytmc' := '
+      pv: STATE:SET
+      io: io
+    '}
+    eStateSet: E_EpicsInOut;
+END_VAR
+VAR_OUTPUT
+    // Define an ENUM for EPICS to use to report the new value.
+    {attribute 'pytmc' := '
+      pv: STATE:GET
+      io: i
+    '}
+    eStateGet: E_EpicsInOut;
+END_VAR
+VAR
+    // Include the standard fb with blank pv pragma
+    {attribute 'pytmc' := 'pv:'}
+    fbPositionStatePMPS1D: FB_PositionStatePMPS1D;
+    // The standard fb expects a full array of position states
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+// Optional: default state names
+IF stIn.sName = '' THEN
+    stIn.sName := 'IN';
+END_IF
+IF stOut.sName = '' THEN
+    stOut.sName := 'OUT';
+END_IF
+
+// Assemble the states array, matching the enum values (IN is 1, OUT is 2)
+astPositionState[1] := stIn;
+astPositionState[2] := stOut;
+
+// Call the main function block, passing our motors, states, and an enable
+fbPositionStatePMPS1D(
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter,
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    eEnumSet:=eStateSet,
+    eEnumGet:=eStateGet,
+    bEnableMotion:=TRUE,
+    bEnableBeamParams:=TRUE,
+    bEnablePositionLimits:=TRUE,
+);
+
+// Send updates made on the array back to the inputs (VAR_IN_OUT) for maximum clarity
+stIn := astPositionState[1];
+stOut := astPositionState[2];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPS2D

+
FUNCTION_BLOCK FB_PositionStatePMPS2D
+(*
+    2-Dimensional position state function block with PMPS.
+
+    This allows the user to move 2 motors among some set of named state positions with PMPS protection.
+
+    To use a states block, you must define enums that match the state options and give them pytmc pragmas.
+    See FB_PositionState1D_InOut for a simple example.
+    These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables.
+    The enum values must match the array indices in astPositionState1 and astPositionState2.
+
+    A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us
+    to accept a new, possibly conflicting, move request on the next cycle to interrupt the first.
+
+    The motors must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly.
+
+    PMPS handling is done via database lookups by setting sPmpsState on each position state and on
+    the transition state input appropriately.
+*)
+VAR_IN_OUT
+    // The 1st motor to move
+    stMotionStage1: ST_MotionStage;
+    // The 2nd motor to move
+    stMotionStage2: ST_MotionStage;
+    // All possible position states for motor 1, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:M1
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // All possible position states for motor 2, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:M2
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input.
+    eEnumSet: UINT;
+    // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output.
+    eEnumGet: UINT;
+    // The fast fault output to fault to.
+    fbFFHWO: FB_HardwareFFOutput;
+    // The arbiter to request beam conditions from.
+    fbArbiter: FB_Arbiter;
+END_VAR
+VAR_INPUT
+    // Set this to TRUE to enable input state moves, or FALSE to disable them.
+    bEnableMotion: BOOL;
+    // Set this to TRUE to enable beam parameter checks, or FALSE to disable them.
+    bEnableBeamParams: BOOL;
+    // Set this to TRUE to enable position limit checks, or FALSE to disable them.
+    bEnablePositionLimits: BOOL;
+    // The name of the device for use in the PMPS DB lookup and diagnostic screens.
+    sDeviceName: STRING;
+    // The name of the transition state in the PMPS database.
+    sTransitionKey: STRING;
+    // Normal EPICS inputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    // PMPS EPICS inputs, gathered into a single struct
+    stEpicsToPlc: ST_StateEpicsToPlc;
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPMPSEpicsToPlc: ST_StatePMPSEpicsToPlc;
+    // Set this to TRUE to re-read the loaded database immediately (useful for debug)
+    bReadDBNow: BOOL;
+END_VAR
+VAR_OUTPUT
+    // Normal EPICS outputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPlcToEpics: ST_StatePlcToEpics;
+    // PMPS EPICS outputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPMPSPlcToEpics: ST_StatePMPSPlcToEpics;
+    // The PMPS database lookup associated with the current position state.
+    stDbStateParams: ST_DbStateParams;
+END_VAR
+VAR
+    fbCore: FB_PositionStateND_Core;
+    fbPMPSCore: FB_PositionStatePMPSND_Core;
+    astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+astMotionStageMax[1] := stMotionStage1;
+astMotionStageMax[2] := stMotionStage2;
+astPositionStateMax[1] := astPositionState1;
+astPositionStateMax[2] := astPositionState2;
+
+fbCore(
+    astMotionStageMax:=astMotionStageMax,
+    astPositionStateMax:=astPositionStateMax,
+    stEpicsToPlc:=stEpicsToPlc,
+    stPlcToEpics:=stPlcToEpics,
+    eEnumSet:=eEnumSet,
+    eEnumGet:=eEnumGet,
+    bEnable:=bEnableMotion,
+    nActiveMotorCount:=2,
+    nCurrGoal=>,
+);
+fbPMPSCore(
+    astMotionStageMax:=astMotionStageMax,
+    astPositionStateMax:=astPositionStateMax,
+    stEpicsToPlc:=stEpicsToPlc,
+    stPMPSEpicsToPlc:=stPMPSEpicsToPlc,
+    stPlcToEpics:=stPlcToEpics,
+    stPMPSPlcToEpics:=stPMPSPlcToEpics,
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter,
+    bEnableBeamParams:=bEnableBeamParams,
+    bEnablePositionLimits:=bEnablePositionLimits,
+    nActiveMotorCount:=2,
+    sDeviceName:=sDeviceName,
+    sTransitionKey:=sTransitionKey,
+    nCurrGoal:=fbCore.nCurrGoal,
+    bReadDBNow:=bReadDBNow,
+    stDbStateParams=>stDbStateParams,
+);
+
+stMotionStage1 := astMotionStageMax[1];
+stMotionStage2 := astMotionStageMax[2];
+astPositionState1 := astPositionStateMax[1];
+astPositionState2 := astPositionStateMax[2];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPS2D_InOut

+
FUNCTION_BLOCK FB_PositionStatePMPS2D_InOut
+(*
+    An example and usable drop-in instance for a 2D state device with just an IN and an OUT state.
+    Note that the outward-facing API is nearly identical to the non-PMPS version
+*)
+VAR_IN_OUT
+    // Include stages that can be passed into the FB
+    stMotionStage1: ST_MotionStage;
+    stMotionStage2: ST_MotionStage;
+    // Simplify the interface, the user just needs to construct and pass in and out position states
+    stIn1: ST_PositionState;
+    stOut1: ST_PositionState;
+    stIn2: ST_PositionState;
+    stOut2: ST_PositionState;
+    // Include PMPS output helpers
+    fbFFHWO: FB_HardwareFFOutput;
+    fbArbiter: FB_Arbiter;
+END_VAR
+VAR_INPUT
+    // Define an ENUM for EPICS to use to set a new value. It is expected this will be written to during one cycle, so don't continually apply a value here in the PLC code.
+    // It is exposed as an input so we can test it using the PLC.
+    {attribute 'pytmc' := '
+      pv: STATE:SET
+      io: io
+    '}
+    eStateSet: E_EpicsInOut;
+END_VAR
+VAR_OUTPUT
+    // Define an ENUM for EPICS to use to report the new value.
+    {attribute 'pytmc' := '
+      pv: STATE:GET
+      io: i
+    '}
+    eStateGet: E_EpicsInOut;
+END_VAR
+VAR
+    // Include the standard fb with blank pv pragma
+    {attribute 'pytmc' := 'pv:'}
+    fbPositionStatePMPS2D: FB_PositionStatePMPS2D;
+    // The standard fb expects a full array of position states per motor
+    astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+// Optional: default state names
+IF stIn1.sName = '' THEN
+    stIn1.sName := 'IN';
+END_IF
+IF stOut1.sName = '' THEN
+    stOut1.sName := 'OUT';
+END_IF
+IF stIn2.sName = '' THEN
+    stIn2.sName := 'IN';
+END_IF
+IF stOut2.sName = '' THEN
+    stOut2.sName := 'OUT';
+END_IF
+
+// Assemble the states arrays, matching the enum values (IN is 1, OUT is 2)
+astPositionState1[1] := stIn1;
+astPositionState1[2] := stOut1;
+astPositionState2[1] := stIn2;
+astPositionState2[2] := stOut2;
+
+// Call the main function block, passing our motors, states, and an enable
+fbPositionStatePMPS2D(
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter,
+    stMotionStage1:=stMotionStage1,
+    astPositionState1:=astPositionState1,
+    stMotionStage2:=stMotionStage2,
+    astPositionState2:=astPositionState2,
+    eEnumSet:=eStateSet,
+    eEnumGet:=eStateGet,
+    bEnableMotion:=TRUE,
+    bEnableBeamParams:=TRUE,
+    bEnablePositionLimits:=TRUE,
+);
+
+// Send updates made on the array back to the inputs (VAR_IN_OUT) for maximum clarity
+stIn1 := astPositionState1[1];
+stOut1 := astPositionState1[2];
+stIn2 := astPositionState2[1];
+stOut2 := astPositionState2[2];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPS3D

+
FUNCTION_BLOCK FB_PositionStatePMPS3D
+(*
+    3-Dimensional position state function block with PMPS.
+
+    This allows the user to move 3 motors among some set of named state positions with PMPS protection.
+
+    To use a states block, you must define enums that match the state options and give them pytmc pragmas.
+    See FB_PositionState1D_InOut for a simple example.
+    These enums must be passed in as the eEnumSet and eEnumGet VAR_IN_OUT variables.
+    The enum values must match the array indices in astPositionState1, astPositionState2, and astPositionState3.
+
+    A move will begin when eEnumSet is set to a positive, nonzero value. eEnumSet will be reset to 0 on every cycle, allowing us
+    to accept a new, possibly conflicting, move request on the next cycle to interrupt the first.
+
+    The motors must already be set up for point-to-point motion via FB_MotionStage, etc., for this function block to work properly.
+
+    PMPS handling is done via database lookups by setting sPmpsState on each position state and on
+    the transition state input appropriately.
+*)
+VAR_IN_OUT
+    // The 1st motor to move
+    stMotionStage1: ST_MotionStage;
+    // The 2nd motor to move
+    stMotionStage2: ST_MotionStage;
+    // The 3rd motor to move
+    stMotionStage3: ST_MotionStage;
+    // All possible position states for motor 1, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:M1
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // All possible position states for motor 2, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:M2
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // All possible position states for motor 3, including unused/invalid states.
+    {attribute 'pytmc' := '
+        pv: STATE:M3
+        io: io
+        expand: :%.2d
+    '}
+    astPositionState3: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Set this to a nonzero value to request a new move. It will be reset to zero every cycle. This should be hooked up to a user's EPICS enum input.
+    eEnumSet: UINT;
+    // The current state index, or zero if we are not at a state. This should be hooked up to a user's EPICS enum output.
+    eEnumGet: UINT;
+    // The fast fault output to fault to.
+    fbFFHWO: FB_HardwareFFOutput;
+    // The arbiter to request beam conditions from.
+    fbArbiter: FB_Arbiter;
+END_VAR
+VAR_INPUT
+    // Set this to TRUE to enable input state moves, or FALSE to disable them.
+    bEnableMotion: BOOL;
+    // Set this to TRUE to enable beam parameter checks, or FALSE to disable them.
+    bEnableBeamParams: BOOL;
+    // Set this to TRUE to enable position limit checks, or FALSE to disable them.
+    bEnablePositionLimits: BOOL;
+    // The name of the device for use in the PMPS DB lookup and diagnostic screens.
+    sDeviceName: STRING;
+    // The name of the transition state in the PMPS database.
+    sTransitionKey: STRING;
+    // Normal EPICS inputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    // PMPS EPICS inputs, gathered into a single struct
+    stEpicsToPlc: ST_StateEpicsToPlc;
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPMPSEpicsToPlc: ST_StatePMPSEpicsToPlc;
+    // Set this to TRUE to re-read the loaded database immediately (useful for debug)
+    bReadDBNow: BOOL;
+END_VAR
+VAR_OUTPUT
+    // Normal EPICS outputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPlcToEpics: ST_StatePlcToEpics;
+    // PMPS EPICS outputs, gathered into a single struct
+    {attribute 'pytmc' := 'pv: STATE'}
+    stPMPSPlcToEpics: ST_StatePMPSPlcToEpics;
+    // The PMPS database lookup associated with the current position state.
+    stDbStateParams: ST_DbStateParams;
+END_VAR
+VAR
+    fbCore: FB_PositionStateND_Core;
+    fbPMPSCore: FB_PositionStatePMPSND_Core;
+    astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+astMotionStageMax[1] := stMotionStage1;
+astMotionStageMax[2] := stMotionStage2;
+astMotionStageMax[3] := stMotionStage3;
+astPositionStateMax[1] := astPositionState1;
+astPositionStateMax[2] := astPositionState2;
+astPositionStateMax[3] := astPositionState3;
+
+fbCore(
+    astMotionStageMax:=astMotionStageMax,
+    astPositionStateMax:=astPositionStateMax,
+    stEpicsToPlc:=stEpicsToPlc,
+    stPlcToEpics:=stPlcToEpics,
+    eEnumSet:=eEnumSet,
+    eEnumGet:=eEnumGet,
+    bEnable:=bEnableMotion,
+    nActiveMotorCount:=3,
+    nCurrGoal=>,
+);
+fbPMPSCore(
+    astMotionStageMax:=astMotionStageMax,
+    astPositionStateMax:=astPositionStateMax,
+    stEpicsToPlc:=stEpicsToPlc,
+    stPMPSEpicsToPlc:=stPMPSEpicsToPlc,
+    stPlcToEpics:=stPlcToEpics,
+    stPMPSPlcToEpics:=stPMPSPlcToEpics,
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter,
+    bEnableBeamParams:=bEnableBeamParams,
+    bEnablePositionLimits:=bEnablePositionLimits,
+    nActiveMotorCount:=3,
+    sDeviceName:=sDeviceName,
+    sTransitionKey:=sTransitionKey,
+    nCurrGoal:=fbCore.nCurrGoal,
+    bReadDBNow:=bReadDBNow,
+    stDbStateParams=>stDbStateParams,
+);
+
+stMotionStage1 := astMotionStageMax[1];
+stMotionStage2 := astMotionStageMax[2];
+stMotionStage3 := astMotionStageMax[3];
+astPositionState1 := astPositionStateMax[1];
+astPositionState2 := astPositionStateMax[2];
+astPositionState3 := astPositionStateMax[3];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPS_Base

+
{attribute 'obsolete' := 'Use FB_PositionStatePMPS1D instead'}
+FUNCTION_BLOCK FB_PositionStatePMPS_Base
+(*
+    FB_PositionStatePMPS without Arbiter, BPTM, FFO
+
+    This allows me to test most of the code without an arbiter plc setup
+*)
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+    arrStates: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+VAR_INPUT
+    bArbiterEnabled: BOOL := TRUE;
+    {attribute 'pytmc' := '
+        pv: MAINT
+        io: io
+    '}
+    bMaintMode: BOOL;
+    bRequestTransition: BOOL;
+    setState: INT;
+    getState: INT;
+    fStateBoundaryDeadband: LREAL := 0;
+    tArbiterTimeout: TIME := T#1s;
+    bMoveOnArbiterTimeout: BOOL := TRUE;
+END_VAR
+VAR_OUTPUT
+    bTransitionAuthorized: BOOL;
+    bForwardAuthorized: BOOL;
+    bBackwardAuthorized: BOOL;
+    bArbiterTimeout: BOOL;
+END_VAR
+VAR
+    {attribute 'pytmc' := '
+        pv: TRANS
+        io: i
+    '}
+    stTransitionDb: ST_DbStateParams;
+    stTransitionBeam: ST_BeamParams := PMPS_GVL.cst0RateBeam;
+    stTransitionState: ST_PositionState;
+    bInit: BOOL := TRUE;
+    bTransDone: BOOL;
+    rtTransReq: R_TRIG;
+    bBPTMDone: BOOL;
+    rtBPTMDone: R_TRIG;
+    ftMotorExec: F_TRIG;
+    rtTransDone: R_TRIG;
+    rtDoLateFinish: R_TRIG;
+    tonDone: TON;
+    stStateReq: ST_PositionState;
+    mcPower: MC_POWER;
+    fUpperBound: LREAL;
+    fLowerBound: LREAL;
+    nGoalState: INT;
+    stGoalState: ST_PositionState;
+    fActPos: LREAL;
+    fReqPos: LREAL;
+    bInTransition: BOOL;
+    stBeamNeeded: ST_BeamParams;
+    bFwdOk: BOOL;
+    bBwdOk: BOOL;
+    tonArbiter: TON;
+    bLateFinish: BOOL;
+    bInternalAuth: BOOL;
+END_VAR
+// This is meant to be subclassed. The parent class body is in the Exec action.
+
+END_FUNCTION_BLOCK
+
+ACTION AssertHere:
+
+END_ACTION
+
+ACTION ClearAsserts:
+
+END_ACTION
+
+ACTION Exec:
+// Load the pmps parameters as needed
+HandlePmpsDb();
+
+// Initialize or reinitialize to the current state value
+rtBPTMDone(CLK:=bBPTMDone);
+ftMotorExec(CLK:=stMotionStage.bExecute);
+tonDone(
+    IN:=bTransDone,
+    PT:=T#100ms
+    );
+IF rtBPTMDone.Q OR ftMotorExec.Q OR tonDone.Q THEN
+    bInit := TRUE;
+END_IF
+IF bInit OR nGoalState = 0 OR stMotionStage.bError THEN
+    bInit R= stMotionStage.bAxisParamsInit;
+    nGoalState := getState;
+    stStateReq := GetStateStruct(getState);
+    bInTransition := FALSE;
+    rtTransReq(CLK:=FALSE);
+    bTransitionAuthorized := FALSE;
+    bArbiterTimeout := FALSE;
+END_IF
+
+// Request transition on rising edge
+rtTransReq(CLK:=bRequestTransition);
+IF rtTransReq.Q THEN
+    nGoalState := setState;
+    stStateReq := GetStateStruct(setState);
+    bInTransition := TRUE;
+    bTransDone := FALSE;
+ELSE
+    bTransDone := F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=stStateReq) AND NOT stMotionStage.bBusy;
+END_IF
+
+// Mark late finish if bTransDone -> true before the bptm is done
+// This means that we finished the move so fast that the bptm needs to be unstuck via toggling bTransDone
+rtTransDone(CLK:=bTransDone);
+bLateFinish S= rtTransDone.Q AND NOT bBPTMDone;
+
+IF bArbiterEnabled THEN
+    // Handles getting the request to the arbiter and back
+    HandleBPTM();
+    // Handle arbiter timeouts
+    IF tArbiterTimeout > T#0s THEN
+        tonArbiter(
+            IN:=bInTransition AND NOT bInternalAuth,
+            PT:=tArbiterTimeout,
+            Q=>bArbiterTimeout);
+    ELSE
+        bArbiterTimeout := FALSE;
+    END_IF
+    bTransitionAuthorized S= bInternalAuth OR (bArbiterTimeout AND bMoveOnArbiterTimeout);
+ELSE
+    // Clear all of our assertions if we decide to disable the arbiter
+    ClearAsserts();
+    // Do some dummy request handling
+    bTransitionAuthorized := stMotionStage.bExecute;
+    bArbiterTimeout := stMotionStage.bExecute;
+END_IF
+
+// Set up MPS virtual limit for moves at and between states
+stGoalState := GetStateStruct(nGoalState);
+fActPos := stMotionStage.stAxisStatus.fActPosition;
+IF stMotionStage.bExecute THEN
+    fReqPos := stMotionStage.fPosition;
+ELSE
+    fReqPos := fActPos;
+END_IF
+
+// Start with no move authority
+bForwardAuthorized := FALSE;
+bBackwardAuthorized := FALSE;
+
+// Check if it would be OK to move without granting auth
+bFwdOk := F_PosUnderUpperBound(MAX(fActPos, fReqPos) + ABS(fStateBoundaryDeadband), stGoalState);
+bBwdOk := F_PosOverLowerBound(MIN(fActPos, fReqPos) - ABS(fStateBoundaryDeadband), stGoalState);
+
+// Grant auth during moves based on goal state, current position, and goal position
+IF stMotionStage.bExecute AND stGoalState.bValid THEN
+    bForwardAuthorized := bFwdOk;
+    bBackwardAuthorized := bBwdOk;
+END_IF
+
+IF bInTransition THEN
+    // Deny auth during a transition request until transition is authorized
+    bForwardAuthorized R= NOT bTransitionAuthorized;
+    bBackwardAuthorized R= NOT bTransitionAuthorized;
+    // Have the motor wait for permission to start move instead of immediately erroring
+    stMotionStage.bSafetyReady := bTransitionAuthorized;
+ELSE
+    // If not transitioning, no need to wait for safety: immediately try to move and error if no auth
+    stMotionStage.bSafetyReady := stMotionStage.bExecute;
+    // Set an error message override in case this causes an error
+    IF stMotionStage.bError AND bArbiterEnabled AND NOT bMaintMode THEN
+        IF fReqPos > fActPos AND NOT bFwdOk THEN
+            stMotionStage.sCustomErrorMessage := 'Unsafe tweak forward blocked by PMPS';
+        ELSIF fReqPos < fActPos AND NOT bBwdOk THEN
+            stMotionStage.sCustomErrorMessage := 'Unsafe tweak backward blocked by PMPS';
+        END_IF
+    END_IF
+END_IF
+
+IF bArbiterEnabled AND NOT bMaintMode THEN
+// Only let us move if the transition is allowed, or if we are moving within a state's bounds
+    mcPower(Axis:=stMotionStage.Axis,
+            Enable:=stMotionStage.bAllEnable,
+            Enable_Positive:=stMotionStage.bAllForwardEnable AND bForwardAuthorized,
+            Enable_Negative:=stMotionStage.bAllBackwardEnable AND bBackwardAuthorized);
+ELSE
+    mcPower(Axis:=stMotionStage.Axis,
+            Enable:=stMotionStage.bAllEnable,
+            Enable_Positive:=stMotionStage.bAllForwardEnable,
+            Enable_Negative:=stMotionStage.bAllBackwardEnable);
+    stMotionStage.bSafetyReady := TRUE;
+END_IF
+
+// Raise fast faults as needed
+stBeamNeeded := GetBeamFromState(getState);
+HandleFFO();
+END_ACTION
+
+ACTION HandleBPTM:
+
+END_ACTION
+
+ACTION HandleFFO:
+
+END_ACTION
+
+ACTION HandlePmpsDb:
+
+END_ACTION
+
+METHOD GetBeamFromState : ST_BeamParams;
+VAR_INPUT
+    nState: INT;
+END_VAR
+VAR
+    stState: ST_PositionState;
+END_VAR
+stState := GetStateStruct(nState);
+GetBeamFromState := stState.stPMPS.stBeamParams;
+END_METHOD
+
+METHOD GetStateCode : INT
+VAR_INPUT
+    nState: INT;
+END_VAR
+IF nState < 0 OR nState > GeneralConstants.MAX_STATES THEN
+    GetStateCode := -1;
+ELSE
+    GetStateCode := nState;
+END_IF
+END_METHOD
+
+METHOD GetStateStruct : ST_PositionState
+VAR_INPUT
+    nState: INT;
+END_VAR
+{warning disable C0371}
+// Implicit VAR_IN_OUT reference inside a method needs special handling
+IF NOT __ISVALIDREF(arrStates) THEN
+    GetStateStruct := stTransitionState;
+    RETURN;
+END_IF
+CASE GetStateCode(nState) OF
+    -1: GetStateStruct := stTransitionState;
+    0: GetStateStruct := stTransitionState;
+    ELSE
+        GetStateStruct := arrStates[nState];
+END_CASE
+{warning restore C0371}
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPS_Test

+
{attribute 'obsolete' := 'No longer any reason to use this, all state classes can have unit tests.'}
+FUNCTION_BLOCK FB_PositionStatePMPS_Test EXTENDS FB_PositionStatePMPS_Base
+(*
+    Implement position state pmps with no FFO and auto-accept transition after 3s
+    Use for offline testing of everything except the explicit interface
+*)
+VAR
+    tonReq: TON;
+END_VAR
+Exec();
+
+END_FUNCTION_BLOCK
+
+ACTION HandleBPTM:
+// Send the fake BPTM our assertion request by changing stStateReq.stBeamParams
+// We expect to recieve bTransitionAuthorized TRUE after some delta T
+// We expect bTransitionAuthorized to go FALSE after stMotionStage.bBusy goes FALSE
+tonReq(
+    IN:=bInTransition,
+    PT:=T#3s);
+bTransitionAuthorized := tonReq.Q AND stMotionStage.bExecute;
+END_ACTION
+
+ACTION HandleFFO:
+// Skip implementing this for offline testing
+// We won't be able to tell if it worked anyway
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPSND_Core

+
FUNCTION_BLOCK FB_PositionStatePMPSND_Core
+(*
+    Collection of all core actions shared between all PMPS states FBs
+    This is used in e.g.
+    - FB_PositionStatePMPS1D
+    - FB_PositionStatePMPS2D
+    - ... etc.
+
+    This handles database reading, BPTM, motor enables, virtual limits, and all FFOS.
+*)
+VAR_IN_OUT
+    // All motors to be used in the states move, including blank/uninitialized structs.
+    astMotionStageMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    // All position states for all motors, including unused/invalid states.
+    astPositionStateMax: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Normal EPICS inputs, gathered into a single struct
+    stEpicsToPlc: ST_StateEpicsToPlc;
+    // PMPS EPICS inputs, gathered into a single struct
+    stPMPSEpicsToPlc: ST_StatePMPSEpicsToPlc;
+    // Normal EPICS outputs, gathered into a single struct
+    stPlcToEpics: ST_StatePlcToEpics;
+    // PMPS EPICS outputs, gathered into a single struct
+    stPMPSPlcToEpics: ST_StatePMPSPlcToEpics;
+    // The fast fault output to fault to.
+    fbFFHWO: FB_HardwareFFOutput;
+    // The arbiter to request beam conditions from.
+    fbArbiter: FB_Arbiter;
+END_VAR
+VAR_INPUT
+    // Set this to TRUE to enable beam parameter checks, or FALSE to disable them.
+    bEnableBeamParams: BOOL;
+    // Set this to TRUE to enable position limit checks, or FALSE to disable them.
+    bEnablePositionLimits: BOOL;
+    // Set this to the number of motors to be included in astMotionStageMax
+    nActiveMotorCount: UINT;
+    // The name of the device for use in the PMPS DB lookup and diagnostic screens.
+    sDeviceName: STRING;
+    // The name of the transition state in the PMPS database.
+    sTransitionKey: STRING;
+    // The current position index goal, where the motors are supposed to be moving towards.
+    nCurrGoal: UINT;
+    // Set this to TRUE to re-read the loaded database immediately (useful for debug)
+    bReadDBNow: BOOL;
+END_VAR
+VAR_OUTPUT
+    // The PMPS database lookup associated with the current position state.
+    stDbStateParams: ST_DbStateParams;
+END_VAR
+VAR
+    fbMotionReadPMPSDB: FB_MotionReadPMPSDBND;
+    fbMotionBPTM: FB_MotionBPTM;
+    fbMotionClearAsserts: FB_MotionClearAsserts;
+    fbStatePMPSEnables: FB_StatePMPSEnablesND;
+    fbMiscStatesErrorFFO: FB_MiscStatesErrorFFO;
+    fbPerMotorFFO: FB_PerMotorFFOND;
+
+    eStatePMPSStatus: E_StatePMPSStatus;
+END_VAR
+IF stPMPSEpicsToPlc.bMaintMode OR NOT stPMPSEpicsToPlc.bArbiterEnabled THEN
+    eStatePMPSStatus := E_StatePMPSStatus.DISABLED;
+ELSIF stPlcToEpics.nGetValue = 0 AND nCurrGoal = 0 THEN
+    eStatePMPSStatus := E_StatePMPSStatus.UNKNOWN;
+ELSIF stPlcToEpics.nGetValue = nCurrGoal THEN
+    eStatePMPSStatus := E_StatePMPSStatus.AT_STATE;
+ELSE
+    eStatePMPSStatus := E_StatePMPSStatus.TRANSITION;
+END_IF
+
+fbMotionReadPMPSDB(
+    astPositionState:=astPositionStateMax,
+    fbFFHWO:=fbFFHWO,
+    sTransitionKey:=sTransitionKey,
+    sDeviceName:=sDeviceName,
+    bReadNow:=bReadDBNow,
+    astDbStateParams=>,
+    bError=>,
+);
+
+fbMotionBPTM(
+    astMotionStage:=astMotionStageMax,
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    stGoalParams:=fbMotionReadPMPSDB.astDbStateParams[nCurrGoal],
+    stTransParams:=fbMotionReadPMPSDB.astDbStateParams[0],
+    nActiveMotorCount:=nActiveMotorCount,
+    bEnable:=stPMPSEpicsToPlc.bArbiterEnabled AND bEnableBeamParams,
+    bAtState:=stPlcToEpics.nGetValue = nCurrGoal AND nCurrGoal <> 0,
+    sDeviceName:=sDeviceName,
+    bTransitionAuthorized=>,
+    bDone=>,
+    bMotorCountError=>,
+);
+
+fbMotionClearAsserts(
+    astDbStateParams:=fbMotionReadPMPSDB.astDbStateParams,
+    fbArbiter:=fbArbiter,
+    bExecute:=NOT fbMotionBPTM.bEnable,
+);
+
+fbStatePMPSEnables(
+    astMotionStage:=astMotionStageMax,
+    astPositionState:=astPositionStateMax,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=bEnablePositionLimits,
+    nActiveMotorCount:=nActiveMotorCount,
+    nGoalStateIndex:=nCurrGoal,
+    sDeviceName:=sDeviceName,
+    bMaintMode:=stPMPSEpicsToPlc.bMaintMode,
+    eStatePMPSStatus:=eStatePMPSStatus,
+    bTransitionAuthorized:=fbMotionBPTM.bTransitionAuthorized,
+    abEnabled=>,
+    abForwardEnabled=>,
+    abBackwardEnabled=>,
+    abValidGoal=>,
+    bMotorCountError=>,
+);
+
+IF bEnableBeamParams THEN
+    fbMiscStatesErrorFFO.stCurrentBeamReq := fbMotionReadPMPSDB.astDbStateParams[stPlcToEpics.nGetValue].stBeamParams;
+ELSE
+    fbMiscStatesErrorFFO.stCurrentBeamReq := PMPS_GVL.cstFullBeam;
+END_IF
+fbMiscStatesErrorFFO(
+    fbArbiter:=fbArbiter,
+    fbFFHWO:=fbFFHWO,
+    sDeviceName:=sDeviceName,
+    bKnownState:=stPlcToEpics.nGetValue > 0,
+    nTransitionID:=fbMotionReadPMPSDB.astDbStateParams[0].nRequestAssertionID,
+);
+
+fbPerMotorFFO(
+    astMotionStage:=astMotionStageMax,
+    fbFFHWO:=fbFFHWO,
+    nActiveMotorCount:=nActiveMotorCount,
+    sDeviceName:=sDeviceName,
+    bMotorCountError=>,
+);
+
+stPMPSPlcToEpics.stTransitionDb := fbMotionReadPMPSDB.astDbStateParams[0];
+stDbStateParams := fbMotionReadPMPSDB.astDbStateParams[stPlcToEpics.nGetValue];
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStatePMPSND_Test

+
FUNCTION_BLOCK FB_PositionStatePMPSND_Test EXTENDS FB_MotorTestSuite
+(*
+    Sanity checks for the following:
+    - FB_PositionStatePMPS1D
+    - FB_PositionStatePMPS2D
+    - FB_PositionStatePMPS3D
+    The internals have already been tested, but we need to make sure that
+    they've been put together at least somewhat sensibly.
+    This FB will simply use each FB to move and check the results.
+    In addition to reaching the goals, we need to check the beam assertions
+    and the pmps limit enables.
+*)
+VAR
+    stMotionStage1: ST_MotionStage;
+    stMotionStage2: ST_MotionStage;
+    stMotionStage3: ST_MotionStage;
+    astPositionState1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    astPositionState2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    astPositionState3: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    afbInternal: ARRAY[1..3] OF ARRAY[1..3] OF FB_PositionStateInternal;
+    afbMotionStage: ARRAY[1..3] OF FB_MotionStage;
+
+    astBeam: ARRAY[0..3] OF ST_DbStateParams;
+
+    fb_Move1D: FB_PositionStatePMPS1D;
+    fb_Move2D: FB_PositionStatePMPS2D;
+    fb_Move3D: FB_PositionStatePMPS3D;
+
+    nTestCounter: UINT;
+    bOneTestDone: BOOL;
+    fTestStartPos: LREAL;
+    tonTimer: TON;
+    nIter: DINT;
+    bStatesReady: BOOL;
+
+    eSetPos: E_TestStates;
+    eGetPos: E_TestStates;
+
+    fbArbiter1D: FB_Arbiter(1);
+    fbArbiter2D: FB_Arbiter(2);
+    fbArbiter3D: FB_Arbiter(3);
+
+    fbSubSysIO1D: FB_DummyArbIO;
+    fbSubSysIO2D: FB_DummyArbIO;
+    fbSubSysIO3D: FB_DummyArbIO;
+
+    jsonHelper: FB_PMPSJsonTestHelper;
+END_VAR
+bStatesReady := TRUE;
+FOR nIter := 1 TO 3 DO;
+    astPositionState1[nIter].fPosition := nIter;
+    astPositionState1[nIter].fDelta := 0.5;
+    astPositionState1[nIter].fVelocity := 100;
+    SetGoodState(astPositionState1[nIter]);
+    astPositionState2[nIter].fPosition := 10 + nIter;
+    astPositionState2[nIter].fDelta := 0.5;
+    astPositionState2[nIter].fVelocity := 100;
+    SetGoodState(astPositionState2[nIter]);
+    astPositionState3[nIter].fPosition := 20 + nIter;
+    astPositionState3[nIter].fDelta := 0.5;
+    astPositionState3[nIter].fVelocity := 100;
+    SetGoodState(astPositionState3[nIter]);
+    afbInternal[nIter][1](
+        stMotionStage:=stMotionStage1,
+        stPositionState:=astPositionState1[nIter],
+    );
+    afbInternal[nIter][2](
+        stMotionStage:=stMotionStage2,
+        stPositionState:=astPositionState2[nIter],
+    );
+    afbInternal[nIter][3](
+        stMotionStage:=stMotionStage3,
+        stPositionState:=astPositionState3[nIter],
+    );
+    bStatesReady := bStatesReady AND astPositionState1[nIter].bUpdated;
+    bStatesReady := bStatesReady AND astPositionState2[nIter].bUpdated;
+    bStatesReady := bStatesReady AND astPositionState3[nIter].bUpdated;
+END_FOR
+SetEnablesPMPS(stMotionStage1);
+SetEnablesPMPS(stMotionStage2);
+SetEnablesPMPS(stMotionStage3);
+IF nTestCounter <= 3 THEN
+    // Startup tests, make sure the motor is enabled so we can inspect MC_Power's output
+    // Otherwise we can't snoop on the PlcToNc control DWORD since this is all 0's if disabled
+    // When enabled, some of the other bits go to 1 to represent directional enables
+    stMotionStage1.nEnableMode := E_StageEnableMode.ALWAYS;
+    stMotionStage2.nEnableMode := E_StageEnableMode.ALWAYS;
+    stMotionStage3.nEnableMode := E_StageEnableMode.ALWAYS;
+ELSE
+    // Otherwise, make sure the most complicated mode (and the default) works
+    stMotionStage1.nEnableMode := E_StageEnableMode.DURING_MOTION;
+    stMotionStage2.nEnableMode := E_StageEnableMode.DURING_MOTION;
+    stMotionStage3.nEnableMode := E_StageEnableMode.DURING_MOTION;
+END_IF
+afbMotionStage[1](stMotionStage:=stMotionStage1);
+afbMotionStage[2](stMotionStage:=stMotionStage2);
+afbMotionStage[3](stMotionStage:=stMotionStage3);
+
+astBeam[E_TestStates.Unknown].stBeamParams := PMPS_GVL.cst0RateBeam;
+astBeam[E_TestStates.Unknown].nRequestAssertionID := 1;
+astBeam[E_TestStates.Unknown].sPmpsState := 'trans';
+astBeam[E_TestStates.OUT].stBeamParams := PMPS_GVL.cstFullBeam;
+astBeam[E_TestStates.OUT].nRequestAssertionID := 2;
+astBeam[E_TestStates.OUT].sPmpsState := 'out';
+astBeam[E_TestStates.TARGET1].stBeamParams := PMPS_GVL.cstFullBeam;
+astBeam[E_TestStates.TARGET1].stBeamParams.nTran := 0.1;
+astBeam[E_TestStates.TARGET1].nRequestAssertionID := 3;
+astBeam[E_TestStates.TARGET1].sPmpsState := 'target1';
+astBeam[E_TestStates.TARGET2].stBeamParams := PMPS_GVL.cstFullBeam;
+astBeam[E_TestStates.TARGET2].stBeamParams.nTran := 0.01;
+astBeam[E_TestStates.TARGET2].nRequestAssertionID := 4;
+astBeam[E_TestStates.TARGET2].sPmpsState := 'target2';
+
+// Assign beam params to states 1
+astPositionState1[E_TestStates.OUT].stPMPS := astBeam[E_TestStates.OUT];
+astPositionState1[E_TestStates.TARGET1].stPMPS := astBeam[E_TestStates.TARGET1];
+astPositionState1[E_TestStates.TARGET2].stPMPS := astBeam[E_TestStates.TARGET2];
+
+// Set some names for maybe help in debug
+astPositionState1[E_TestStates.OUT].sName := 'OUT';
+astPositionState1[E_TestStates.TARGET1].sName := 'TARGET1';
+astPositionState1[E_TestStates.TARGET2].sName := 'TARGET2';
+astPositionState2[E_TestStates.OUT].sName := 'OUT';
+astPositionState2[E_TestStates.TARGET1].sName := 'TARGET1';
+astPositionState2[E_TestStates.TARGET2].sName := 'TARGET2';
+astPositionState3[E_TestStates.OUT].sName := 'OUT';
+astPositionState3[E_TestStates.TARGET1].sName := 'TARGET1';
+astPositionState3[E_TestStates.TARGET2].sName := 'TARGET2';
+
+// Load a fake json doc to be consumed by our FB
+jsonHelper(
+    astBeamParams:=astBeam,
+    bExecute:=TRUE,
+    sDevName:='test',
+);
+
+IF bStatesReady AND nTestCounter = 0 THEN
+    // Don't run any tests until the states are ready
+    nTestCounter := 1;
+END_IF
+
+TestStartup1D(1);
+TestStartup2D(2);
+TestStartup3D(3);
+Test1D(4, E_TestStates.OUT);
+Test1D(5, E_TestStates.TARGET1);
+Test1D(6, E_TestStates.TARGET2);
+Test2D(7, E_TestStates.OUT);
+Test2D(8, E_TestStates.TARGET1);
+Test2D(9, E_TestStates.TARGET2);
+Test3D(10, E_TestStates.OUT);
+Test3D(11, E_TestStates.TARGET1);
+Test3D(12, E_TestStates.TARGET2);
+
+IF bOneTestDone THEN
+    bOneTestDone := FALSE;
+    nTestCounter := nTestCounter + 1;
+    tonTimer(IN:=FALSE);
+END_IF
+// Use this timer to time out any tests that stall
+tonTimer(
+    IN:=bStatesReady,
+    PT:=T#5s,
+);
+
+END_FUNCTION_BLOCK
+
+METHOD AssertMotionLims: BOOL
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+VAR_INPUT
+    eState: E_TestStates;
+    sID: STRING;
+END_VAR
+VAR
+    nExpected: DWORD;
+END_VAR
+IF F_AtPositionState(stMotionStage, astPositionState[eState]) THEN
+    // Both allowed
+    nExpected := 2#111;
+ELSIF stMotionStage.stAxisStatus.fActPosition < astPositionState[eState].fPosition THEN
+    // Only + allowed
+    nExpected := 2#011;
+ELSE
+    // Only - allowed
+    nExpected := 2#101;
+END_IF
+
+IF stMotionStage.Axis.PlcToNc.ControlDWord > 0 THEN
+    AssertEquals_DWORD(
+        Expected:=nExpected,
+        Actual:=stMotionStage.Axis.PlcToNc.ControlDWord,
+        Message:=CONCAT('Wrong control dword in test ', sID),
+    );
+    AssertMotionLims := TRUE;
+END_IF
+END_METHOD
+
+METHOD Test1D
+VAR_INPUT
+    nTestID: UINT;
+    eState: E_TestStates;
+END_VAR
+VAR_INST
+    fbFFHWO: FB_HardwareFFOutput;
+    bInit: BOOL;
+    bLimAsserted: BOOL;
+END_VAR
+TEST(CONCAT('Test1D_state', UINT_TO_STRING(eState)));
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+IF NOT bInit THEN
+    eSetPos := eState;
+END_IF
+
+fbSubSysIO1D(
+    LA:=fbArbiter1D,
+    FFO:=fbFFHWO,
+);
+
+fb_Move1D(
+    stMotionStage:=stMotionStage1,
+    astPositionState:=astPositionState1,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter1D,
+    bEnableMotion:=TRUE,
+    bEnableBeamParams:=TRUE,
+    bEnablePositionLimits:=TRUE,
+    bReadDBNow:=NOT bInit,
+    sDeviceName:='test',
+    sTransitionKey:='trans',
+);
+
+// When ready: check that directonal enables are correct
+bLimAsserted S= AssertMotionLims(stMotionStage1, astPositionState1, eState, CONCAT('1D mot 1 state ', UINT_TO_STRING(eState)));
+
+
+IF NOT bInit THEN
+    bInit := TRUE;
+END_IF
+
+IF tonTimer.Q OR fb_Move1D.stPlcToEpics.bDone THEN
+    AssertTrue(
+        bLimAsserted,
+        'Skipped limit assert test',
+    );
+    AssertTrue(
+        Condition:=fb_Move1D.stPlcToEpics.bDone,
+        Message:='Done should be True after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move1D.stPlcToEpics.bBusy,
+        Message:='Busy should be False after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move1D.stPlcToEpics.bError,
+        Message:='Error should be False after move',
+    );
+    AssertEquals_UINT(
+        Expected:=eState,
+        Actual:=eGetPos,
+        Message:='Did not get to the input state',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState1[eState].fPosition,
+        Actual:=stMotionStage1.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position',
+    );
+    AssertTrue(
+        fbArbiter1D.CheckRequestInPool(astBeam[eState].nRequestAssertionID),
+        'Destination bp should have been in the arbiter',
+    );
+    fb_Move1D.stEpicsToPlc.bReset := TRUE;
+    fb_Move1D(
+        stMotionStage:=stMotionStage1,
+        astPositionState:=astPositionState1,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        fbFFHWO:=fbFFHWO,
+        fbArbiter:=fbArbiter1D,
+        bEnableMotion:=TRUE,
+        bEnableBeamParams:=TRUE,
+        bEnablePositionLimits:=TRUE,
+    );
+    bInit := FALSE;
+    bLimAsserted := FALSE;
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD Test2D
+VAR_INPUT
+    nTestID: UINT;
+    eState: E_TestStates;
+END_VAR
+VAR_INST
+    fbFFHWO: FB_HardwareFFOutput;
+    bInit: BOOL;
+    bLimAsserted1: BOOL;
+    bLimAsserted2: BOOL;
+END_VAR
+TEST(CONCAT('Test2D_state', UINT_TO_STRING(eState)));
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+IF NOT bInit THEN
+    eSetPos := eState;
+END_IF
+
+fbSubSysIO2D(
+    LA:=fbArbiter2D,
+    FFO:=fbFFHWO,
+);
+
+fb_Move2D(
+    stMotionStage1:=stMotionStage1,
+    stMotionStage2:=stMotionStage2,
+    astPositionState1:=astPositionState1,
+    astPositionState2:=astPositionState2,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter2D,
+    bEnableMotion:=TRUE,
+    bEnableBeamParams:=TRUE,
+    bEnablePositionLimits:=TRUE,
+    bReadDBNow:=NOT bInit,
+    sDeviceName:='test',
+    sTransitionKey:='trans',
+);
+
+// When ready: check that directonal enables are correct
+bLimAsserted1 S= AssertMotionLims(stMotionStage1, astPositionState1, eState, CONCAT('2D mot 1 state ', UINT_TO_STRING(eState)));
+bLimAsserted2 S= AssertMotionLims(stMotionStage2, astPositionState2, eState, CONCAT('2D mot 2 state ', UINT_TO_STRING(eState)));
+
+IF NOT bInit THEN
+    bInit := TRUE;
+END_IF
+
+IF tonTimer.Q OR fb_Move2D.stPlcToEpics.bDone THEN
+    AssertTrue(
+        bLimAsserted1 AND bLimAsserted2,
+        'Skipped limit assert test',
+    );
+    AssertTrue(
+        Condition:=fb_Move2D.stPlcToEpics.bDone,
+        Message:='Done should be True after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move2D.stPlcToEpics.bBusy,
+        Message:='Busy should be False after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move2D.stPlcToEpics.bError,
+        Message:='Error should be False after move',
+    );
+    AssertEquals_UINT(
+        Expected:=eState,
+        Actual:=eGetPos,
+        Message:='Did not get to the input state',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState1[eState].fPosition,
+        Actual:=stMotionStage1.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState2[eState].fPosition,
+        Actual:=stMotionStage2.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position',
+    );
+    AssertTrue(
+        fbArbiter2D.CheckRequestInPool(astBeam[eState].nRequestAssertionID),
+        'Destination bp should have been in the arbiter',
+    );
+    fb_Move2D.stEpicsToPlc.bReset := TRUE;
+    fb_Move2D(
+        stMotionStage1:=stMotionStage1,
+        stMotionStage2:=stMotionStage2,
+        astPositionState1:=astPositionState1,
+        astPositionState2:=astPositionState2,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        fbFFHWO:=fbFFHWO,
+        fbArbiter:=fbArbiter2D,
+        bEnableMotion:=TRUE,
+        bEnableBeamParams:=TRUE,
+        bEnablePositionLimits:=TRUE,
+    );
+    bInit := FALSE;
+    bLimAsserted1 := FALSE;
+    bLimAsserted2 := FALSE;
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD Test3D
+VAR_INPUT
+    nTestID: UINT;
+    eState: E_TestStates;
+END_VAR
+VAR_INST
+    fbFFHWO: FB_HardwareFFOutput;
+    bInit: BOOL;
+    bLimAsserted1: BOOL;
+    bLimAsserted2: BOOL;
+    bLimAsserted3: BOOL;
+END_VAR
+TEST(CONCAT('Test3D_state', UINT_TO_STRING(eState)));
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+IF NOT bInit THEN
+    eSetPos := eState;
+END_IF
+
+fbSubSysIO3D(
+    LA:=fbArbiter3D,
+    FFO:=fbFFHWO,
+);
+
+fb_Move3D(
+    stMotionStage1:=stMotionStage1,
+    stMotionStage2:=stMotionStage2,
+    stMotionStage3:=stMotionStage3,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    astPositionState1:=astPositionState1,
+    astPositionState2:=astPositionState2,
+    astPositionState3:=astPositionState3,
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter3D,
+    bEnableMotion:=TRUE,
+    bEnableBeamParams:=TRUE,
+    bEnablePositionLimits:=TRUE,
+    bReadDBNow:=NOT bInit,
+    sDeviceName:='test',
+    sTransitionKey:='trans',
+);
+
+// When ready: check that directonal enables are correct
+bLimAsserted1 S= AssertMotionLims(stMotionStage1, astPositionState1, eState, CONCAT('3D mot 1 state ', UINT_TO_STRING(eState)));
+bLimAsserted2 S= AssertMotionLims(stMotionStage2, astPositionState2, eState, CONCAT('3D mot 2 state ', UINT_TO_STRING(eState)));
+bLimAsserted3 S= AssertMotionLims(stMotionStage3, astPositionState3, eState, CONCAT('3D mot 3 state ', UINT_TO_STRING(eState)));
+
+IF NOT bInit THEN
+    bInit := TRUE;
+END_IF
+
+IF tonTimer.Q OR fb_Move3D.stPlcToEpics.bDone THEN
+    AssertTrue(
+        bLimAsserted1 AND bLimAsserted2 AND bLimAsserted3,
+        'Skipped limit assert test',
+    );
+    AssertTrue(
+        Condition:=fb_Move3D.stPlcToEpics.bDone,
+        Message:='Done should be True after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move3D.stPlcToEpics.bBusy,
+        Message:='Busy should be False after move',
+    );
+    AssertFalse(
+        Condition:=fb_Move3D.stPlcToEpics.bError,
+        Message:='Error should be False after move',
+    );
+    AssertEquals_UINT(
+        Expected:=eState,
+        Actual:=eGetPos,
+        Message:='Did not get to the input state',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState1[eState].fPosition,
+        Actual:=stMotionStage1.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState2[eState].fPosition,
+        Actual:=stMotionStage2.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState3[eState].fPosition,
+        Actual:=stMotionStage3.stAxisStatus.fActPosition,
+        Delta:=0.1,
+        Message:='Did not get to the input state position',
+    );
+    AssertTrue(
+        fbArbiter3D.CheckRequestInPool(astBeam[eState].nRequestAssertionID),
+        'Destination bp should have been in the arbiter',
+    );
+    fb_Move3D.stEpicsToPlc.bReset := TRUE;
+    fb_Move3D(
+        stMotionStage1:=stMotionStage1,
+        stMotionStage2:=stMotionStage2,
+        stMotionStage3:=stMotionStage3,
+        astPositionState1:=astPositionState1,
+        astPositionState2:=astPositionState2,
+        astPositionState3:=astPositionState3,
+        eEnumSet:=eSetPos,
+        eEnumGet:=eGetPos,
+        fbFFHWO:=fbFFHWO,
+        fbArbiter:=fbArbiter3D,
+        bEnableMotion:=TRUE,
+        bEnableBeamParams:=TRUE,
+        bEnablePositionLimits:=TRUE,
+    );
+    bInit := FALSE;
+    bLimAsserted1 := FALSE;
+    bLimAsserted2 := FALSE;
+    bLimAsserted3 := FALSE;
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestStartup1D
+(*
+    - On startup, there should be no move request
+    - In this case, we start in an unknown state since (0, 0, 0) is not matching any state for any motor
+    - Movement should be free but the transition assertion must be active
+*)
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbFFHWO: FB_HardwareFFOutput;
+    bInit: BOOL;
+END_VAR
+TEST('TestStartup1D');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+fb_Move1D(
+    stMotionStage:=stMotionStage1,
+    astPositionState:=astPositionState1,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter1D,
+    bEnableMotion:=TRUE,
+    bEnableBeamParams:=TRUE,
+    bEnablePositionLimits:=TRUE,
+    bReadDBNow:=NOT bInit,
+    sDeviceName:='test',
+    sTransitionKey:='trans',
+);
+
+bInit := TRUE;
+
+// We sit in this fb for some timeout number of seconds on purpose, not an error
+IF tonTimer.Q THEN
+    // We should neither be busy nor done (we didn't do anything)
+    AssertFalse(
+        Condition:=fb_Move1D.stPlcToEpics.bDone,
+        Message:='Done should be False with no move',
+    );
+    AssertFalse(
+        Condition:=fb_Move1D.stPlcToEpics.bBusy,
+        Message:='Busy should be False with no move',
+    );
+    // We should still be at 0,0,0
+    AssertEquals_LREAL(
+        Expected:=0,
+        Actual:=stMotionStage1.stAxisStatus.fActPosition,
+        Delta:=0.0001,
+        Message:='Why did we move? motor1 should have default position',
+    );
+    // We should be able to move both directions, which is control word 7 (2#111)
+    AssertEquals_DWORD(
+        Expected:=2#111,
+        Actual:=stMotionStage1.Axis.PlcToNc.ControlDWord,
+        Message:='Expected full +/- enables',
+    );
+    AssertTrue(
+        fbArbiter1D.CheckRequestInPool(astBeam[E_TestStates.Unknown].nRequestAssertionID),
+        'Transition assertion ID not in pool',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestStartup2D
+(*
+    - On startup, there should be no move request
+    - Starting from (0, 0, 0) all motors should only be allowed to move +
+*)
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbFFHWO: FB_HardwareFFOutput;
+    bInit: BOOL;
+END_VAR
+TEST('TestStartup2D');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+fb_Move2D(
+    stMotionStage1:=stMotionStage1,
+    stMotionStage2:=stMotionStage2,
+    astPositionState1:=astPositionState1,
+    astPositionState2:=astPositionState2,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter2D,
+    bEnableMotion:=TRUE,
+    bEnableBeamParams:=TRUE,
+    bEnablePositionLimits:=TRUE,
+    bReadDBNow:=NOT bInit,
+    sDeviceName:='test',
+    sTransitionKey:='trans',
+);
+
+bInit := TRUE;
+
+// We sit in this fb for some timeout number of seconds on purpose, not an error
+IF tonTimer.Q THEN
+    // We should neither be busy nor done (we didn't do anything)
+    AssertFalse(
+        Condition:=fb_Move2D.stPlcToEpics.bDone,
+        Message:='Done should be False with no move',
+    );
+    AssertFalse(
+        Condition:=fb_Move2D.stPlcToEpics.bBusy,
+        Message:='Busy should be False with no move',
+    );
+    // We should still be at 0,0,0
+    AssertEquals_LREAL(
+        Expected:=0,
+        Actual:=stMotionStage1.stAxisStatus.fActPosition,
+        Delta:=0.0001,
+        Message:='Why did we move? motor1 should have default position',
+    );
+    AssertEquals_LREAL(
+        Expected:=0,
+        Actual:=stMotionStage2.stAxisStatus.fActPosition,
+        Delta:=0.0001,
+        Message:='Why did we move? motor2 should have default position',
+    );
+    // We should be able to move both directions, which is control word 7 (2#111)
+    AssertEquals_DWORD(
+        Expected:=2#111,
+        Actual:=stMotionStage1.Axis.PlcToNc.ControlDWord,
+        Message:='Expected full +/- enables',
+    );
+    AssertEquals_DWORD(
+        Expected:=2#111,
+        Actual:=stMotionStage2.Axis.PlcToNc.ControlDWord,
+        Message:='Expected full +/- enables',
+    );
+    AssertTrue(
+        fbArbiter2D.CheckRequestInPool(astBeam[E_TestStates.Unknown].nRequestAssertionID),
+        'Transition assertion ID not in pool',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestStartup3D
+(*
+    - On startup, there should be no move request
+    - Starting from (0, 0, 0) all motors should only be allowed to move +
+*)
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbFFHWO: FB_HardwareFFOutput;
+    bInit: BOOL;
+END_VAR
+TEST('TestStartup3D');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+fb_Move3D(
+    stMotionStage1:=stMotionStage1,
+    stMotionStage2:=stMotionStage2,
+    stMotionStage3:=stMotionStage3,
+    astPositionState1:=astPositionState1,
+    astPositionState2:=astPositionState2,
+    astPositionState3:=astPositionState3,
+    eEnumSet:=eSetPos,
+    eEnumGet:=eGetPos,
+    fbFFHWO:=fbFFHWO,
+    fbArbiter:=fbArbiter3D,
+    bEnableMotion:=TRUE,
+    bEnableBeamParams:=TRUE,
+    bEnablePositionLimits:=TRUE,
+    bReadDBNow:=NOT bInit,
+    sDeviceName:='test',
+    sTransitionKey:='trans',
+);
+
+bInit := TRUE;
+
+// We sit in this fb for some timeout number of seconds on purpose, not an error
+IF tonTimer.Q THEN
+    // We should neither be busy nor done (we didn't do anything)
+    AssertFalse(
+        Condition:=fb_Move3D.stPlcToEpics.bDone,
+        Message:='Done should be False with no move',
+    );
+    AssertFalse(
+        Condition:=fb_Move3D.stPlcToEpics.bBusy,
+        Message:='Busy should be False with no move',
+    );
+    // We should still be at 0,0,0
+    AssertEquals_LREAL(
+        Expected:=0,
+        Actual:=stMotionStage1.stAxisStatus.fActPosition,
+        Delta:=0.0001,
+        Message:='Why did we move? motor1 should have default position',
+    );
+    AssertEquals_LREAL(
+        Expected:=0,
+        Actual:=stMotionStage2.stAxisStatus.fActPosition,
+        Delta:=0.0001,
+        Message:='Why did we move? motor2 should have default position',
+    );
+    AssertEquals_LREAL(
+        Expected:=0,
+        Actual:=stMotionStage3.stAxisStatus.fActPosition,
+        Delta:=0.0001,
+        Message:='Why did we move? motor3 should have default position',
+    );
+    // We should be able to move both directions, which is control word 7 (2#111)
+    AssertEquals_DWORD(
+        Expected:=2#111,
+        Actual:=stMotionStage1.Axis.PlcToNc.ControlDWord,
+        Message:='Expected full +/- enables',
+    );
+    AssertEquals_DWORD(
+        Expected:=2#111,
+        Actual:=stMotionStage2.Axis.PlcToNc.ControlDWord,
+        Message:='Expected full +/- enables',
+    );
+    AssertEquals_DWORD(
+        Expected:=2#111,
+        Actual:=stMotionStage3.Axis.PlcToNc.ControlDWord,
+        Message:='Expected full +/- enables',
+    );
+    AssertTrue(
+        fbArbiter3D.CheckRequestInPool(astBeam[E_TestStates.Unknown].nRequestAssertionID),
+        'Transition assertion ID not in pool',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateRead

+
FUNCTION_BLOCK FB_PositionStateRead
+(*
+    This function block tells us what state a single motor is at.
+    In the case of multiple valid overlapping states, one will be picked arbitrarily,
+    but we can see a full description of which overlapping states are present using the abAtPosition array.
+
+    This will only run properly if FB_PositionStateInternal has been called on each position state to initialize it.
+*)
+VAR_IN_OUT
+    // The motor to check the state of
+    stMotionStage: ST_MotionStage;
+    // The allowed states for this motor
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+VAR_OUTPUT
+    // TRUE if we're standing still at a known state, or moving within the bounds of a state to another location in the bounds.
+    bKnownState: BOOL;
+    // TRUE if we're moving to some other state or to another non-state position.
+    bMovingState: BOOL;
+    // If we're at a known state, this will be the index in the astPositionState array that matches the state. Otherwise, this will be 0, which is below the bounds of the array, so it cannot be confused with a valid output.
+    nPositionIndex: UINT;
+    // A copy of the details of the current position state, for convenience. This may be a moving state or an unknown state as a placeholder if we are not at a known state.
+    stCurrentPosition: ST_PositionState;
+    // A full description of whether we're at each of our states. This is used in 2D, 3D, etc. to clarify cases where states may overlap in 1D.
+    abAtPosition: ARRAY[1..GeneralConstants.MAX_STATES] OF BOOL;
+END_VAR
+VAR
+    nIter: UINT;
+END_VAR
+bKnownState := FALSE;
+bMovingState := FALSE;
+
+FOR nIter := 1 TO GeneralConstants.MAX_STATES DO
+    IF astPositionState[nIter].bValid THEN
+        MOTION_GVL.nMaxStates := MAX(MOTION_GVL.nMaxStates, nIter);
+    END_IF
+    IF F_AtPositionState(stMotionStage:=stMotionStage, stPositionState:=astPositionState[nIter]) THEN
+        bKnownState := TRUE;
+        nPositionIndex := nIter;
+        stCurrentPosition := astPositionState[nIter];
+        abAtPosition[nIter] := TRUE;
+    ELSE
+        abAtPosition[nIter] := FALSE;
+    END_IF
+END_FOR
+
+IF NOT bKnownState THEN
+    nPositionIndex := 0;
+    stCurrentPosition.fPosition := stMotionStage.stAxisStatus.fActPosition;
+    stCurrentPosition.fDelta := 0;
+    stCurrentPosition.bMoveOk := FALSE;
+    stCurrentPosition.bValid := FALSE;
+    stCurrentPosition.bUseRawCounts := FALSE;
+
+    bMovingState := stMotionStage.bExecute;
+    IF bMovingState THEN
+        stCurrentPosition.sName := 'Moving';
+        stCurrentPosition.fVelocity := stMotionStage.fVelocity;
+        stCurrentPosition.fAccel := stMotionStage.fAcceleration;
+    ELSE
+        stCurrentPosition.sName := 'Unknown';
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateRead_Test

+
FUNCTION_BLOCK FB_PositionStateRead_Test EXTENDS TcUnit.FB_TestSuite
+(*
+    Test that FB_PositionStateRead works exactly how it should
+    according to its API during normal and failure states.
+*)
+VAR
+    stMotionStage: ST_MotionStage;
+    fbMotionStage: FB_MotionStage;
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    afbInternal: ARRAY[1..3] OF FB_PositionStateInternal;
+    stDummyPos: ST_PositionState;
+    fbTestMove: FB_TestHelperSetAndMove;
+    fbRead: FB_PositionStateRead;
+
+    nTestCounter: UINT;
+    bOneTestDone: BOOL;
+    fTestStartPos: LREAL;
+    tonTimer: TON;
+    nIter: DINT;
+    bStatesReady: BOOL;
+END_VAR
+astPositionState[1].sName := 'UNO';
+astPositionState[1].fPosition := 10;
+astPositionState[1].fDelta := 1;
+astPositionState[1].bValid := TRUE;
+astPositionState[1].bUseRawCounts := FALSE;
+
+astPositionState[2].sName := 'DOS';
+astPositionState[2].fPosition := 20;
+astPositionState[2].fDelta := 1;
+astPositionState[2].bValid := FALSE;
+astPositionState[2].bUseRawCounts := FALSE;
+
+astPositionState[3].sName := 'TRES';
+astPositionState[3].fPosition := 30;
+astPositionState[3].fDelta := 1;
+astPositionState[3].bValid := TRUE;
+astPositionState[3].bUseRawCounts := FALSE;
+
+astPositionState[4].sName := 'QUATRO';
+astPositionState[4].fPosition := 30;
+astPositionState[4].fDelta := 1;
+astPositionState[4].bValid := FALSE;
+astPositionState[4].bUseRawCounts := FALSE;
+
+bStatesReady := TRUE;
+FOR nIter := 1 TO 4 DO
+    afbInternal[nIter](
+        stMotionStage:=stMotionStage,
+        stPositionState:=astPositionState[nIter],
+    );
+    bStatesReady := bStatesReady AND astPositionState[nIter].bUpdated;
+END_FOR
+fbMotionStage(stMotionStage:=stMotionStage);
+
+// At position 1 check
+TestStaticPosition(
+    nTestIndex:=0,
+    sTestName:='AtPos1',
+    fPosition:=astPositionState[1].fPosition + 0.2 * astPositionState[1].fDelta,
+    bKnownState:=TRUE,
+    bMovingState:=FALSE,
+    nPositionIndex:=1,
+    stCurrentPosition:=astPositionState[1],
+);
+// Outside the deltas check
+TestStaticPosition(
+    nTestIndex:=1,
+    sTestName:='OutsidePos1Delta',
+    fPosition:=astPositionState[1].fPosition + 2 * astPositionState[1].fDelta,
+    bKnownState:=FALSE,
+    bMovingState:=FALSE,
+    nPositionIndex:=0,
+    stCurrentPosition:=stDummyPos,
+);
+// At invalid state 2 check
+TestStaticPosition(
+    nTestIndex:=2,
+    sTestName:='AtInvalidPos',
+    fPosition:=astPositionState[2].fPosition,
+    bKnownState:=FALSE,
+    bMovingState:=FALSE,
+    nPositionIndex:=0,
+    stCurrentPosition:=stDummyPos,
+);
+// At position 3 check
+TestStaticPosition(
+    nTestIndex:=3,
+    sTestName:='AtPos3',
+    fPosition:=astPositionState[3].fPosition - 0.5 * astPositionState[3].fDelta,
+    bKnownState:=TRUE,
+    bMovingState:=FALSE,
+    nPositionIndex:=3,
+    stCurrentPosition:=astPositionState[3],
+);
+// At position 3 and moving within bounds check
+TestMovingPosition(
+    nTestIndex:=4,
+    sTestName:='MovingAt3',
+    fStartPosition:=astPositionState[3].fPosition,
+    fGoalPosition:=astPositionState[3].fPosition + 0.9 * astPositionState[3].fDelta,
+    fVelocity:=0.001,
+    bKnownState:=TRUE,
+    bMovingState:=FALSE,
+    nPositionIndex:=3,
+    stCurrentPosition:=astPositionState[3],
+);
+// At position 3 and moving away check
+TestMovingPosition(
+    nTestIndex:=5,
+    sTestName:='MovingFrom3',
+    fStartPosition:=astPositionState[3].fPosition,
+    fGoalPosition:=astPositionState[3].fPosition + 100 * astPositionState[3].fDelta,
+    fVelocity:=0.001,
+    bKnownState:=FALSE,
+    bMovingState:=TRUE,
+    nPositionIndex:=0,
+    stCurrentPosition:=stDummyPos,
+);
+TestDupe(nTestIndex:=6);
+
+IF bOneTestDone THEN
+    bOneTestDone := FALSE;
+    nTestCounter := nTestCounter + 1;
+    fbTestMove(
+        stMotionStage:=stMotionStage,
+        bExecute:=FALSE,
+    );
+END_IF
+
+END_FUNCTION_BLOCK
+
+METHOD PRIVATE Asserts
+VAR_INPUT
+    tTimeout: TIME;
+    bKnownState: BOOL;
+    bMovingState: BOOL;
+    nPositionIndex: DINT;
+    stCurrentPosition: ST_PositionState;
+END_VAR
+VAR
+    abExpected: ARRAY[1..GeneralConstants.MAX_STATES] OF BOOL;
+END_VAR
+fbRead(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionstate,
+);
+
+AssertEquals_BOOL(
+    Expected:=FALSE,
+    Actual:=fbTestMove.tElapsed > tTimeout,
+    Message:='Test timed out',
+);
+AssertEquals_BOOL(
+    Expected:=bKnownState,
+    Actual:=fbRead.bKnownState,
+    Message:='Incorrect bKnownState',
+);
+AssertEquals_BOOL(
+    Expected:=bMovingState,
+    Actual:=fbRead.bMovingState,
+    Message:='Incorrect bMovingState',
+);
+AssertEquals_DINT(
+    Expected:=nPositionIndex,
+    Actual:=fbRead.nPositionIndex,
+    Message:='Incorrect nPositionIndex',
+);
+IF nPositionIndex > 0 THEN
+    IF nPositionIndex <= GeneralConstants.MAX_STATES THEN
+        abExpected[nPositionIndex] := TRUE;
+    END_IF
+ END_IF
+AssertArrayEquals_BOOL(
+    Expecteds:=abExpected,
+    Actuals:=fbRead.abAtPosition,
+    Message:='Wrong at position array',
+);
+
+IF bKnownState THEN
+    AssertEquals_STRING(
+        Expected:=stCurrentPosition.sName,
+        Actual:=fbRead.stCurrentPosition.sName,
+        Message:='Did not provide correct current position struct',
+    );
+END_IF
+END_METHOD
+
+METHOD TestDupe
+VAR_INPUT
+    nTestIndex: DINT;
+END_VAR
+VAR
+    abExpected: ARRAY[1..GeneralConstants.MAX_STATES] OF BOOL;
+END_VAR
+TEST('TestDupe');
+IF nTestIndex <> nTestCounter THEN
+    RETURN;
+END_IF
+
+// In this test, and only in this test, we must make sure state 4 is valid
+astPositionState[4].bValid := TRUE;
+
+fbTestMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=TRUE,
+    fStartPosition:=astPositionState[4].fPosition,
+    fGoalPosition:=astPositionState[4].fPosition,
+);
+abExpected[3] := TRUE;
+abExpected[4] := TRUE;
+
+IF fbTestMove.tElapsed > T#1s OR (fbTestMove.bSetDone AND bStatesReady) THEN
+    fbRead(
+        stMotionStage:=stMotionStage,
+        astPositionState:=astPositionstate,
+    );
+    AssertEquals_BOOL(
+        Expected:=FALSE,
+        Actual:=fbTestMove.tElapsed > T#1s,
+        Message:='Test timed out',
+    );
+    AssertEquals_BOOL(
+        Expected:=TRUE,
+        Actual:=fbRead.bKnownState,
+        Message:='Incorrect bKnownState',
+    );
+    AssertArrayEquals_BOOL(
+        Expecteds:=abExpected,
+        Actuals:=fbRead.abAtPosition,
+        Message:='Wrong at position array',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestMovingPosition
+VAR_INPUT
+    nTestIndex: UINT;
+    sTestName: STRING;
+    fStartPosition: LREAL;
+    fGoalPosition: LREAL;
+    fVelocity: LREAL;
+    bKnownState: BOOL;
+    bMovingState: BOOL;
+    nPositionIndex: DINT;
+    stCurrentPosition: ST_PositionState;
+END_VAR
+TEST(sTestName);
+IF nTestIndex <> nTestCounter THEN
+    RETURN;
+END_IF
+
+fbTestMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=TRUE,
+    fStartPosition:=fStartPosition,
+    fGoalPosition:=fGoalPosition,
+    fVelocity:=0.001,
+    bHWEnable:=TRUE,
+);
+
+IF fbTestMove.tElapsed > T#5s OR (fbTestMove.bMotionStarted AND bStatesReady) THEN
+    Asserts(
+        tTimeout:=T#5s,
+        bKnownState:=bKnownState,
+        bMovingState:=bMovingState,
+        nPositionIndex:=nPositionIndex,
+        stCurrentPosition:=stCurrentPosition,
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestStaticPosition
+VAR_INPUT
+    nTestIndex: UINT;
+    sTestName: STRING;
+    fPosition: LREAL;
+    bKnownState: BOOL;
+    bMovingState: BOOL;
+    nPositionIndex: DINT;
+    stCurrentPosition: ST_PositionState;
+END_VAR
+TEST(sTestName);
+IF nTestIndex <> nTestCounter THEN
+    RETURN;
+END_IF
+
+fbTestMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=TRUE,
+    fStartPosition:=fPosition,
+    fGoalPosition:=fPosition,
+);
+
+IF fbTestMove.tElapsed > T#1s OR (fbTestMove.bSetDone AND bStatesReady) THEN
+    Asserts(
+        tTimeout:=T#1s,
+        bKnownState:=bKnownState,
+        bMovingState:=bMovingState,
+        nPositionIndex:=nPositionIndex,
+        stCurrentPosition:=stCurrentPosition,
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateReadND

+
FUNCTION_BLOCK FB_PositionStateReadND
+(*
+    Function block to get the combined N-dimensional state of a group of motors.
+    It is a building block not meant for use outside of lcls-twintcat-motion.
+
+    Use FB_PositionStateRead1D, FB_PositionStateRead2D, ... etc. instead
+*)
+VAR_IN_OUT
+    // The motors with a combined N-dimensional state
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    // Each motor's respective position states along its direction
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+END_VAR
+VAR_INPUT
+    // The number of motors we're actually using
+    nActiveMotorCount: UINT;
+END_VAR
+VAR_OUTPUT
+    // TRUE if we're standing still at a known state.
+    bKnownState: BOOL;
+    // TRUE if we're moving, there can be no valid state if we are moving.
+    bMovingState: BOOL;
+    // If we're at a known state, this will be the state index along the enclosed states arrays. Otherwise, it will be zero, which is below the bounds of the states array.
+    nPositionIndex: UINT;
+    // TRUE if the active motor count was invalid
+    bMotorCountError: BOOL;
+    // A full description of whether we're at each of our states. This is used to clarify cases where states may overlap.
+    abAtPosition: ARRAY[1..GeneralConstants.MAX_STATES] OF BOOL;
+END_VAR
+VAR
+    // The individual position state reader function blocks
+    afbPositionStateRead: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF FB_PositionStateRead;
+
+    nIter: UINT;
+    nIter2: UINT;
+END_VAR
+CheckCount();
+IF NOT bMotorCountError THEN
+    DoStateReads();
+    CombineOutputs();
+END_IF
+
+END_FUNCTION_BLOCK
+
+ACTION CheckCount:
+// Make sure the motor count is valid (positive, nonzero, less or equal to the max)
+bMotorCountError S= nActiveMotorCount <= 0;
+bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS;
+END_ACTION
+
+ACTION CombineOutputs:
+// bKnownState is TRUE if ALL motors have the same known state
+bKnownState := TRUE;
+FOR nIter := 1 TO nActiveMotorCount DO
+    bKnownState := bKnownState AND afbPositionStateRead[nIter].bKnownState;
+END_FOR
+
+// bMovingState is TRUE if ANY motor is moving
+bMovingState := FALSE;
+FOR nIter := 1 TO nActiveMotorCount DO
+    bMovingState := bMovingState OR afbPositionStateRead[nIter].bMovingState;
+END_FOR
+
+// To account for redundant 1D states, we need to check the full output arrays.
+nPositionIndex := 0;
+FOR nIter := 1 TO GeneralConstants.MAX_STATES DO
+    abAtPosition[nIter] := TRUE;
+    FOR nIter2 := 1 TO nActiveMotorCount DO
+        abAtPosition[nIter] R= NOT afbPositionStateRead[nIter2].abAtPosition[nIter];
+    END_FOR
+    IF abAtPosition[nIter] THEN
+        nPositionIndex := nIter;
+    END_IF
+END_FOR
+
+// Position index 0 means different positions
+bKnownState := bKnownState AND nPositionIndex <> 0;
+END_ACTION
+
+ACTION DoStateReads:
+MOTION_GVL.nMaxStateMotorCount := MAX(MOTION_GVL.nMaxStateMotorCount, nActiveMotorCount);
+FOR nIter := 1 TO nActiveMotorCount DO
+    afbPositionStateRead[nIter](
+        stMotionStage:=astMotionStage[nIter],
+        astPositionState:=astPositionState[nIter],
+    );
+END_FOR
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_PositionStateReadND_Test

+
FUNCTION_BLOCK FB_PositionStateReadND_Test EXTENDS FB_MotorTestSuite
+(*
+    Test that FB_PositionStateReadND can be used to read and summarize
+    N-dimensional state positions where multiple motors must move in
+    sync to a shared named state.
+*)
+VAR
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    afbMotionStage: ARRAY[1..3] OF FB_MotionStage;
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY [1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    afbInternal: ARRAY[1..3] OF ARRAY [1..2] OF FB_PositionStateInternal;
+
+    afbTestMove: ARRAY[1..3] OF FB_TestHelperSetAndMove;
+    fbRead: FB_PositionStateReadND;
+    bOneAssertDone: BOOL;
+    nAssertCounter: UINT;
+    nIter1: UINT;
+    nIter2: UINT;
+    nIter3: UINT;
+
+    fbMisRead: FB_PositionStateReadND;
+    astGoodStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    astGoodStateShape: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY [1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+
+    astSqMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    afbSqMotionStage: ARRAY[1..2] OF FB_MotionStage;
+    astSquareStates: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY [1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    afbSqInternal: ARRAY[1..2] OF ARRAY[1..4] OF FB_PositionStateInternal;
+
+    afbSqTestMove: ARRAY[1..2] OF FB_TestHelperSetAndMove;
+    fbSqRead: FB_PositionStateReadND;
+    bSqAssertDone: BOOL;
+    nSqAssertCounter: UINT;
+END_VAR
+VAR CONSTANT
+    NO_STATE: UINT := 0;
+    OUT_STATE: UINT := 1;
+    IN_STATE: UINT := 2;
+    IN_TWEAK: UINT := 3;
+    AWAY: UINT := 4;
+    LAST_TEST: UINT := AWAY;
+    TEST_COUNT: UINT := 5;
+END_VAR
+PerMotor(1);
+PerMotor(2);
+PerMotor(3);
+SquareSetup();
+
+// First check the case of mismatched arrays
+TestForgot();
+TestCombos(nAssertCounter);
+TestSquare(nSqAssertCounter);
+
+IF bOneAssertDone THEN
+    afbTestMove[1](
+        stMotionStage:=astMotionStage[1],
+        bExecute:=FALSE,
+    );
+    afbTestMove[2](
+        stMotionStage:=astMotionStage[2],
+        bExecute:=FALSE,
+    );
+    afbTestMove[3](
+        stMotionStage:=astMotionStage[3],
+        bExecute:=FALSE,
+    );
+    IF afbTestMove[1].bResetDone AND afbTestMove[2].bResetDone AND afbTestMove[3].bResetDone THEN
+        bOneAssertDone := FALSE;
+        nAssertCounter := nAssertCounter + 1;
+    END_IF
+END_IF
+
+IF bSqAssertDone THEN
+    afbSqTestMove[1](
+        stMotionStage:=astMotionStage[1],
+        bExecute:=FALSE,
+    );
+    afbSqTestMove[2](
+        stMotionStage:=astMotionStage[2],
+        bExecute:=FALSE,
+    );
+    IF afbSqTestMove[1].bResetDone AND afbSqTestMove[2].bResetDone THEN
+        bSqAssertDone := FALSE;
+        nSqAssertCounter := nSqAssertCounter + 1;
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+METHOD PRIVATE DoAssert
+VAR_INPUT
+    nMotorCase1: UINT;
+    nMotorCase2: UINT;
+    nMotorCase3: UINT;
+    bReady1: BOOL;
+    bReady2: BOOL;
+    bReady3: BOOL;
+END_VAR
+VAR
+    bKnownState: BOOL;
+    bMovingState: BOOL;
+    nPositionIndex: DINT;
+    sTestCase: STRING;
+END_VAR
+sTestCase := CONCAT(CONCAT(UINT_TO_STRING(nMotorCase1), UINT_TO_STRING(nMotorCase2)), UINT_TO_STRING(nMotorCase3));
+
+AssertTrue(
+    Condition:=bReady1,
+    Message:=CONCAT('Timeout for motor 1 during test case ', sTestCase),
+);
+AssertTrue(
+    Condition:=bReady2,
+    Message:=CONCAT('Timeout for motor 2 during test case ', sTestCase),
+);
+AssertTrue(
+    Condition:=bReady3,
+    Message:=CONCAT('Timeout for motor 3 during test case ', sTestCase),
+);
+
+// All at OUT or all at IN should be OUT and IN respectively, even if doing a tweak move
+// Any other combination is at no state
+IF nMotorCase1 = OUT_STATE AND nMotorCase2 = OUT_STATE AND nMotorCase3 = OUT_STATE THEN
+    bKnownState := TRUE;
+    nPositionIndex := 1;
+ELSIF (nMotorCase1 = IN_STATE OR nMotorCase1 = IN_TWEAK) AND
+      (nMotorCase2 = IN_STATE OR nMotorCase2 = IN_TWEAK) AND
+      (nMotorCase3 = IN_STATE OR nMotorCase3 = IN_TWEAK) THEN
+    bKnownState := TRUE;
+    nPositionIndex := 2;
+END_IF
+// In addition, bMovingState must be set if any is moving away from a state
+IF nMotorCase1 = AWAY OR nMotorCase2 = AWAY OR nMotorCase3 = AWAY THEN
+    bMovingState := TRUE;
+END_IF
+
+AssertEquals_BOOL(
+    Expected:=bKnownState,
+    Actual:=fbRead.bKnownState,
+    Message:=CONCAT('Wrong bKnownState for test case ', sTestCase),
+);
+AssertEquals_BOOL(
+    Expected:=bMovingState,
+    Actual:=fbRead.bMovingState,
+    Message:=CONCAT('Wrong bMovingState for test case ', sTestCase),
+);
+AssertEquals_DINT(
+    Expected:=nPositionIndex,
+    Actual:=fbRead.nPositionIndex,
+    Message:=CONCAT('Wrong nPositionIndex for test case ', sTestCase),
+);
+END_METHOD
+
+METHOD PRIVATE DoMove: BOOL
+VAR_INPUT
+    nMotorIndex: UINT;
+    nMotorCase: UINT;
+END_VAR
+VAR
+    fStartPosition: LREAL;
+    fGoalPosition: LREAL;
+END_VAR
+CASE nMotorCase OF
+    // Somewhere smaller than OUT, static
+    NO_STATE:
+        fStartPosition := astPositionState[nMotorIndex][1].fPosition - 10 * astPositionState[nMotorIndex][1].fDelta;
+        fGoalPosition := fStartPosition;
+    // Exactly at OUT, static
+    OUT_STATE:
+        fStartPosition := astPositionState[nMotorIndex][1].fPosition;
+        fGoalPosition := fStartPosition;
+    // Exactly at IN, static
+    IN_STATE:
+        fStartPosition := astPositionState[nMotorIndex][2].fPosition;
+        fGoalPosition := fStartPosition;
+    // Start at IN, do a small tweak
+    IN_TWEAK:
+        fStartPosition := astPositionState[nMotorIndex][2].fPosition;
+        fGoalPosition := fStartPosition + 0.9 * astPositionState[nMotorIndex][2].fDelta;
+    // Start at IN, move positive a lot
+    AWAY:
+        fStartPosition := astPositionState[nMotorIndex][2].fPosition;
+        fGoalPosition := fStartPosition + 100 * astPositionState[nMotorIndex][2].fDelta;
+END_CASE
+
+afbTestMove[nMotorIndex](
+    stMotionStage:=astMotionStage[nMotorIndex],
+    bExecute:=TRUE,
+    fStartPosition:=fStartPosition,
+    fGoalPosition:=fGoalPosition,
+    fVelocity:=0.001,
+    bHWEnable:=TRUE,
+);
+
+CASE nMotorCase OF
+    // All static states: report ready when set is done
+    NO_STATE:
+        DoMove := afbTestMove[nMotorIndex].bSetDone;
+    OUT_STATE:
+        DoMove := afbTestMove[nMotorIndex].bSetDone;
+    IN_STATE:
+        DoMove := afbTestMove[nMotorIndex].bSetDone;
+    // All moving states: report ready when move starts
+    IN_TWEAK:
+        DoMove := afbTestMove[nMotorIndex].bMotionStarted;
+    AWAY:
+        DoMove := afbTestMove[nMotorIndex].bMotionStarted;
+END_CASE
+// Universal 5s timeout
+DoMove S= afbTestMove[nMotorIndex].tElapsed > T#5s;
+END_METHOD
+
+METHOD PRIVATE DoRead
+VAR_INPUT
+END_VAR
+fbRead(
+    astMotionStage:=astMotionStage,
+    astPositionState:=astPositionState,
+    nActiveMotorCount:=3,
+);
+END_METHOD
+
+METHOD PRIVATE PerMotor : BOOL
+VAR_INPUT
+    nIndex: DINT;
+END_VAR
+afbMotionStage[nIndex](stMotionStage:=astMotionStage[nIndex]);
+
+astPositionState[nIndex][1].sName := 'OUT';
+astPositionState[nIndex][1].fPosition := nIndex * 100 + 10;
+astPositionState[nIndex][1].fDelta := 1;
+astPositionState[nIndex][1].bUseRawCounts := FALSE;
+SetGoodState(astPositionState[nIndex][1]);
+afbInternal[nIndex][1](
+    stMotionStage:=astMotionStage[nIndex],
+    stPositionState:=astPositionState[nIndex][1],
+);
+
+astPositionState[nIndex][2].sName := 'IN';
+astPositionState[nIndex][2].fPosition := nIndex * 100 + 20;
+astPositionState[nIndex][2].fDelta := 1;
+astPositionState[nIndex][2].bUseRawCounts := FALSE;
+SetGoodState(astPositionState[nIndex][2]);
+afbInternal[nIndex][2](
+    stMotionStage:=astMotionStage[nIndex],
+    stPositionState:=astPositionState[nIndex][2],
+);
+END_METHOD
+
+METHOD SquareSetup
+VAR_INPUT
+END_VAR
+// 2 motors, 4 positions per motor, square geometry
+// Motor 1 is X, motor 2 is Y
+// Corners at (10,10), (10, 20), (20, 10), (20, 20)
+// So motor 1 is either LEFT=10 or RIGHT=20
+// motor 2 is either BOT=10 or TOP=20
+
+afbSqMotionStage[1](stMotionStage:=astSqMotionStage[1]);
+afbSqMotionStage[2](stMotionStage:=astSqMotionStage[2]);
+
+astSquareStates[1][1].sName := 'Top Left';
+astSquareStates[1][1].fPosition := 10;
+astSquareStates[1][1].fDelta := 1;
+SetGoodState(astSquareStates[1][1]);
+afbSqInternal[1][1](
+    stMotionStage:=astMotionStage[1],
+    stPositionState:=astSquareStates[1][1],
+);
+
+astSquareStates[1][2].sName := 'Top Right';
+astSquareStates[1][2].fPosition := 20;
+astSquareStates[1][2].fDelta := 1;
+SetGoodState(astSquareStates[1][2]);
+afbSqInternal[1][2](
+    stMotionStage:=astMotionStage[1],
+    stPositionState:=astSquareStates[1][2],
+);
+
+astSquareStates[1][3].sName := 'Bot Left';
+astSquareStates[1][3].fPosition := 10;
+astSquareStates[1][3].fDelta := 1;
+SetGoodState(astSquareStates[1][3]);
+afbSqInternal[1][3](
+    stMotionStage:=astMotionStage[1],
+    stPositionState:=astSquareStates[1][3],
+);
+
+astSquareStates[1][4].sName := 'Bot Right';
+astSquareStates[1][4].fPosition := 20;
+astSquareStates[1][4].fDelta := 1;
+SetGoodState(astSquareStates[1][4]);
+afbSqInternal[1][4](
+    stMotionStage:=astMotionStage[1],
+    stPositionState:=astSquareStates[1][4],
+);
+
+astSquareStates[2][1].sName := 'Top Left';
+astSquareStates[2][1].fPosition := 20;
+astSquareStates[2][1].fDelta := 1;
+SetGoodState(astSquareStates[2][1]);
+afbSqInternal[2][1](
+    stMotionStage:=astMotionStage[1],
+    stPositionState:=astSquareStates[2][1],
+);
+
+astSquareStates[2][2].sName := 'Top Right';
+astSquareStates[2][2].fPosition := 20;
+astSquareStates[2][2].fDelta := 1;
+SetGoodState(astSquareStates[2][2]);
+afbSqInternal[2][2](
+    stMotionStage:=astMotionStage[1],
+    stPositionState:=astSquareStates[2][2],
+);
+
+astSquareStates[2][3].sName := 'Bot Left';
+astSquareStates[2][3].fPosition := 10;
+astSquareStates[2][3].fDelta := 1;
+SetGoodState(astSquareStates[2][3]);
+afbSqInternal[2][3](
+    stMotionStage:=astMotionStage[1],
+    stPositionState:=astSquareStates[2][3],
+);
+
+astSquareStates[2][4].sName := 'Bot Right';
+astSquareStates[2][4].fPosition := 10;
+astSquareStates[2][4].fDelta := 1;
+SetGoodState(astSquareStates[2][4]);
+afbSqInternal[2][4](
+    stMotionStage:=astMotionStage[1],
+    stPositionState:=astSquareStates[2][4],
+);
+END_METHOD
+
+METHOD PRIVATE TestCombos
+VAR_INPUT
+    nAssertID: UINT;
+END_VAR
+VAR
+    nMotor1Case: UINT;
+    nMotor2Case: UINT;
+    nMotor3Case: UINT;
+    bReady1: BOOL;
+    bReady2: BOOL;
+    bReady3: BOOL;
+END_VAR
+VAR_INST
+    tonTimeout: TON;
+END_VAR
+// This should be one big test case with 125 asserts
+TEST('TestAllCombos');
+
+nMotor1Case := nAssertID MOD TEST_COUNT;
+nMotor2Case := LREAL_TO_UINT(FLOOR(nAssertID / TEST_COUNT)) MOD TEST_COUNT;
+nMotor3Case := LREAL_TO_UINT(FLOOR(nAssertID / TEST_COUNT / TEST_COUNT)) MOD TEST_COUNT;
+
+bReady1 := DoMove(1, nMotor1Case);
+bReady2 := DoMove(2, nMotor2Case);
+bReady3 := DoMove(3, nMotor3Case);
+
+// There is a 5s timeout at a lower level, but that timeout could fail
+tonTimeout(
+    IN:=TRUE,
+    PT:=T#7s,
+);
+
+IF tonTimeout.Q OR (bReady1 AND bReady2 AND bReady3) THEN
+    DoRead();
+    DoAssert(nMotor1Case, nMotor2Case, nMotor3Case, bReady1, bReady2, bReady3);
+    bOneAssertDone := TRUE;
+    // The final assert case marks test as finished
+    IF tonTimeout.Q OR (nMotor1Case = LAST_TEST AND nMotor2Case = LAST_TEST AND nMotor3Case = LAST_TEST) THEN
+        // 11 extra tests
+        // 1 from TestForgot
+        // 10 (2*5) from TestSquare
+        AssertEquals_UINT(
+            Expected:=6 * TEST_COUNT * TEST_COUNT * TEST_COUNT + 11,
+            Actual:=AssertResults.TotalAsserts,
+            Message:='Some of the asserts were not run',
+        );
+        AssertFalse(
+            tonTimeout.Q,
+            'Level 2 timeout in test',
+        );
+        TEST_FINISHED();
+    END_IF
+    tonTimeout(IN:=FALSE);
+END_IF
+END_METHOD
+
+METHOD PRIVATE TestForgot
+VAR
+END_VAR
+TEST('ForgotCount');
+
+fbMisRead(
+    astMotionStage:=astGoodStage,
+    astPositionState:=astGoodStateShape,
+);
+
+AssertTrue(
+    Condition:=fbMisRead.bMotorCountError,
+    Message:='Failed to notice missing count',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestSquare
+VAR_INPUT
+    nAssertID: UINT;
+END_VAR
+VAR
+    fMotor1Pos: LREAL;
+    fMotor2Pos: LREAL;
+    nGoal: UINT;
+END_VAR
+VAR_INST
+    tonTimeout: TON;
+END_VAR
+// We'll do 5 tests, one at each square point and one more in the middle
+Test('TestSquare');
+IF nAssertID > 4 THEN
+    RETURN;
+END_IF
+
+IF nAssertID = 0 THEN
+    fMotor1Pos := 10;
+    fMotor2Pos := 10;
+    nGoal := 3;
+ELSIF nAssertID = 1 THEN
+    fMotor1Pos := 20;
+    fMotor2Pos := 10;
+    nGoal := 4;
+ELSIF nAssertID = 2 THEN
+    fMotor1Pos := 10;
+    fMotor2Pos := 20;
+    nGoal := 1;
+ELSIF nAssertID = 3 THEN
+    fMotor1Pos := 20;
+    fMotor2Pos := 20;
+    nGoal := 2;
+ELSIF nAssertID = 4 THEN
+    fMotor1Pos := 15;
+    fMotor2Pos := 15;
+    nGoal := 0;
+END_IF
+
+afbSqTestMove[1](
+    stMotionStage:=astSqMotionStage[1],
+    bExecute:=TRUE,
+    fStartPosition:=fMotor1Pos,
+    fGoalPosition:=fMotor1Pos,
+);
+afbSqTestMove[2](
+    stMotionStage:=astSqMotionStage[2],
+    bExecute:=TRUE,
+    fStartPosition:=fMotor2Pos,
+    fGoalPosition:=fMotor2Pos,
+);
+
+tonTimeout(
+    IN:=TRUE,
+    PT:=T#5s,
+);
+
+IF tonTimeout.Q OR afbSqTestMove[1].bSetDone AND afbSqTestMove[1].bSetDone THEN
+    fbSqRead(
+        astMotionStage:=astSqMotionStage,
+        astPositionState:=astSquareStates,
+        nActiveMotorCount:=2,
+    );
+    AssertFalse(
+        tonTimeout.Q,
+        CONCAT('Timeout in square test ', UINT_TO_STRING(nAssertID)),
+    );
+    AssertEquals_UINT(
+        Expected:=nGoal,
+        Actual:=fbSqRead.nPositionIndex,
+        Message:=CONCAT('Wrong read in square test ', UINT_TO_STRING(nAssertID)),
+    );
+
+    bSqAssertDone := TRUE;
+    IF nAssertID = 4 THEN
+        TEST_FINISHED();
+    END_IF
+    tonTimeout(IN:=FALSE);
+END_IF
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_RawCountConverter

+
FUNCTION_BLOCK FB_RawCountConverter
+(*
+    Utility function block for converting raw counts to EGU and back
+*)
+VAR_INPUT
+    // Parameters to check against
+    stParameters: ST_AxisParameterSet;
+    // Optional count to convert to a real position
+    nCountCheck: UDINT;
+    // Optional position to convert to encoder counts
+    fPosCheck: LREAL;
+END_VAR
+VAR_OUTPUT
+    // If converting position, the number of counts
+    nCountGet: UDINT;
+    // If converting counts, the position
+    fPosGet: LREAL;
+    // True during a parameter get/calc
+    bBusy: BOOL;
+    // True after a successful get/calc
+    bDone: BOOL;
+    // True if the calculation errored
+    bError: BOOL;
+END_VAR
+IF stParameters.fEncScaleFactorInternal <> 0 THEN
+    nCountGet := LREAL_TO_UDINT((fPosCheck - stParameters.fEncOffset) / stParameters.fEncScaleFactorInternal);
+    fPosGet := nCountCheck * stParameters.fEncScaleFactorInternal + stParameters.fEncOffset;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_ReadFloatParameter

+
FUNCTION_BLOCK FB_ReadFloatParameter
+VAR_INPUT
+    bExecute: BOOL;
+    ///16#4000=Axisdata, 16#5000=Encoderdata, 16#6000=Controldata, 16#7000=Drivedata
+    nDeviceGroup: UDINT;
+    nIndexOffset: UDINT;
+END_VAR
+VAR_OUTPUT
+    nData: LREAL;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR
+    nState: UINT;
+    fbADSREAD: ADSREAD;
+END_VAR
+(*Sequence to read parameter in Nc*)
+CASE nState OF
+0:  (*Start sequence. Wait until bExecute is TRUE*)
+    IF bExecute THEN
+            bBusy:=TRUE;
+            bError:=FALSE;
+            nErrorId:=0;
+            nState:=10;
+    END_IF
+
+10: (*Read parameter in Nc*)
+    fbADSREAD(
+            PORT:=500,
+            IDXGRP:=nDeviceGroup+Axis.NcToPlc.AxisId,
+            IDXOFFS:=nIndexOffset,
+            LEN:=SIZEOF(nData),
+            DESTADDR:=ADR(nData),
+            READ:=TRUE);
+
+    (*Wait until it's done or if an error occurs*)
+    IF NOT fbADSREAD.ERR THEN
+            IF NOT fbADSREAD.BUSY THEN
+                    fbADSREAD(READ:=FALSE);
+                    nState:=20;
+            END_IF
+    ELSE
+            nErrorId:=fbADSREAD.ERRID;
+            nState:=999;
+    END_IF
+
+20: (*Sequense is done. Waits until bExecute is FALSE*)
+    bBusy:=FALSE;
+    bDone:=TRUE;
+    IF NOT bExecute THEN
+            bDone:=FALSE;
+            nState:=0;
+    END_IF
+
+999: (*Error in sequence*)
+    bError:=TRUE;
+    bBusy:=FALSE;
+    bDone:=FALSE;
+    fbADSREAD(READ:=FALSE);
+    IF NOT bExecute THEN
+            nState:=0;
+    END_IF
+
+END_CASE
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_ReadParameterInNc_v1_00

+
///#########################################################
+///Function block to read parameter in Nc.
+///
+/// Library:
+/// Tc2_MC2.lib
+/// Tc2_System.lib
+///
+/// Global Variables:
+///
+/// Data types:
+///
+/// External functions:
+///
+/// History:
+/// 2014-02-05      v1.00   NB      Release code.
+///
+/// Known bugs:
+///
+///
+///
+///###########################################################
+FUNCTION_BLOCK FB_ReadParameterInNc_v1_00
+VAR_INPUT
+    bExecute: BOOL;
+    ///16#4000=Axisdata, 16#5000=Encoderdata, 16#6000=Controldata, 16#7000=Drivedata
+    nDeviceGroup: UDINT;
+    nIndexOffset: UDINT;
+END_VAR
+VAR_OUTPUT
+    nData: DWORD;
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR
+    nState: UINT;
+    fbADSREAD: ADSREAD;
+END_VAR
+(*Sequence to read parameter in Nc*)
+CASE nState OF
+0:  (*Start sequence. Wait until bExecute is TRUE*)
+    IF bExecute THEN
+            bBusy:=TRUE;
+            bError:=FALSE;
+            nErrorId:=0;
+            nState:=10;
+    END_IF
+
+10: (*Read parameter in Nc*)
+    fbADSREAD(
+            PORT:=500,
+            IDXGRP:=nDeviceGroup+Axis.NcToPlc.AxisId,
+            IDXOFFS:=nIndexOffset,
+            LEN:=SIZEOF(nData),
+            DESTADDR:=ADR(nData),
+            READ:=TRUE);
+
+    (*Wait until it's done or if an error occurs*)
+    IF NOT fbADSREAD.ERR THEN
+            IF NOT fbADSREAD.BUSY THEN
+                    fbADSREAD(READ:=FALSE);
+                    nState:=20;
+            END_IF
+    ELSE
+            nErrorId:=fbADSREAD.ERRID;
+            nState:=999;
+    END_IF
+
+20: (*Sequense is done. Waits until bExecute is FALSE*)
+    bBusy:=FALSE;
+    bDone:=TRUE;
+    IF NOT bExecute THEN
+            bDone:=FALSE;
+            nState:=0;
+    END_IF
+
+999: (*Error in sequence*)
+    bError:=TRUE;
+    bBusy:=FALSE;
+    bDone:=FALSE;
+    fbADSREAD(READ:=FALSE);
+    IF NOT bExecute THEN
+            nState:=0;
+    END_IF
+
+END_CASE
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_SetEnables

+
FUNCTION_BLOCK FB_SetEnables
+// Update the all enable booleans based on the booleans that make them up
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+stMotionStage.bAllForwardEnable := stMotionStage.bLimitForwardEnable AND (stMotionStage.bGantryForwardEnable OR NOT stMotionStage.bGantryAxis) AND stMotionStage.stEPSForwardEnable.bEPS_OK;
+stMotionStage.bAllBackwardEnable := stMotionStage.bLimitBackwardEnable AND (stMotionStage.bGantryBackwardEnable OR NOT stMotionStage.bGantryAxis) AND stMotionStage.stEPSBackwardEnable.bEPS_OK;
+
+stMotionStage.bAllEnable := stMotionStage.bEnable AND stMotionStage.bHardwareEnable AND stMotionStage.stEPSPowerEnable.bEPS_OK;
+stMotionStage.bAllEnable R= NOT stMotionStage.bUserEnable;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_Standard_PMPSDB

+
FUNCTION_BLOCK FB_Standard_PMPSDB
+(*
+    This FB should be run on every motion PLC to encapsulate the pmps file reader.
+    It is pre-instantiated at MOTION_GVL.fbStandardPMPSDB
+*)
+VAR_IN_OUT
+    // The fast fault output to fault to.
+    io_fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    // If TRUE, FB will run. Reads when enable goes TRUE.
+    bEnable: BOOL;
+    // E.g. lfe-motion
+    sPlcName: STRING;
+    {attribute 'pytmc' := '
+        pv: REFRESH
+        io: io
+    '}
+    // Set to TRUE to cause an extra read.
+    bRefresh: BOOL;
+    // Directory where the DB is stored.
+    sDirectory: STRING := '/Hard Disk/ftp/PMPS/';
+END_VAR
+VAR_OUTPUT
+    {attribute 'pytmc' := '
+        pv: LAST_REFRESH
+        io: i
+    '}
+    nLastRefreshTime: DINT;
+    bReadPmpsDb: BOOL;
+END_VAR
+VAR
+    bExecute: BOOL;
+    rtEnable: R_TRIG;
+    rtRefresh: R_TRIG;
+    ftBusy: F_TRIG;
+
+    // Time tracking liften from Arbiter PLCs
+    fbTime : FB_LocalSystemTime := ( bEnable := TRUE, dwCycle := 1 );
+    fbTime_to_UTC: FB_TzSpecificLocalTimeToSystemTime;
+    fbGetTimeZone: FB_GetTimeZoneInformation;
+END_VAR
+IF NOT bEnable THEN
+    RETURN;
+END_IF
+
+rtEnable(CLK:=bEnable);
+rtRefresh(CLK:=bRefresh);
+bRefresh := FALSE;
+
+IF rtEnable.Q OR rtRefresh.Q THEN
+    // Make sure file reader gets a rising edge
+    MOTION_GVL.fbPmpsFileReader(
+        io_fbFFHWO:=io_fbFFHWO,
+        bExecute:=FALSE,
+    );
+    bExecute := TRUE;
+END_IF
+
+MOTION_GVL.fbPmpsFileReader(
+    io_fbFFHWO:=io_fbFFHWO,
+    bExecute:=bExecute,
+    sSrcPathName:=CONCAT(CONCAT(sDirectory, sPlcName), '.json'),
+    sPLCName:=sPLCName,
+    PMPS_jsonDoc=>PMPS_GVL.BP_jsonDoc,
+);
+
+ftBusy(CLK:=MOTION_GVL.fbPmpsFileReader.bBusy);
+IF ftBusy.Q THEN
+    bReadPmpsDb := TRUE;
+ELSE
+    bReadPmpsDb := FALSE;
+END_IF
+
+
+// Lifted from Arbiter PLCs: keep track of the time
+fbTime(sNetID:='');
+fbGetTimeZone(sNetID:='', bExecute:=TRUE, tTimeout:=T#10S);
+fbTime_to_UTC(in:= fbTime.systemTime , tzInfo:=fbGetTimeZone.tzInfo);
+
+// Update the refresh time on successful read
+IF ftBusy.Q AND NOT MOTION_GVL.fbPmpsFileReader.bError THEN
+   nLastRefreshTime := TO_DINT(TO_DT(SystemTime_TO_DT(fbTime_to_UTC.out)));
+END_IF
+
+bExecute R= ftBusy.Q;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_StatePMPSEnables

+
FUNCTION_BLOCK FB_StatePMPSEnables
+(*
+    Function block to set virtual limit enables using MC_POWER for single dimensional state movers.
+    It is a building block not meant for use outside of lcls-twintcat-motion.
+
+    Each motor has a virtual "allowed" range of motion based on its goal position.
+    When not at the goal, the motor can only move toward the goal.
+    When at the goal, the motor can move within the position's delta.
+
+    With no goals or other strange states, the motor is permitted to move in either direction
+    to help restore it to a known position.
+*)
+VAR_IN_OUT
+    // The motor with a position state.
+    stMotionStage: ST_MotionStage;
+    // All possible position states for this motor.
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Hardware output to fault to if there is a problem.
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    // If TRUE, do the limits as normal. If FALSE, allow all moves regardless of the limits defined here.
+    bEnable: BOOL;
+    // The state that the motor is moving to.
+    nGoalStateIndex: UINT;
+    // The overal PMPS FB state
+    eStatePMPSStatus: E_StatePMPSStatus;
+    // Connect to the BPTM
+    bTransitionAuthorized: BOOL;
+END_VAR
+VAR_OUTPUT
+    // The enable state we send to MC_Power. This is a pass-through from stMotionStage.
+    bEnabled: BOOL;
+    // The forward enable state we send to MC_Power. This may be a pass-through or an override to FALSE.
+    bForwardEnabled: BOOL;
+    // The backwards enable state we send to MC_Power. This may be a pass-through or an override to FALSE.
+    bBackwardEnabled: BOOL;
+    // TRUE if there is a valid goal position and FALSE otherwise. This makes a fast fault if FALSE.
+    bValidGoal: BOOL;
+END_VAR
+VAR
+    mc_power: MC_POWER;
+    nPrevStateIndex: DINT;
+    fLowerPos: LREAL;
+    fUpperPos: LREAL;
+    ffNoGoal: FB_FastFault;
+END_VAR
+GetBounds();
+SetEnables();
+ApplyEnables();
+RunFastFaults();
+
+END_FUNCTION_BLOCK
+
+ACTION ApplyEnables:
+(*
+    This action takes runs MC_POWER appropriately
+    given the motor's own enables and the results of this FB's checks.
+*)
+bEnabled := stMotionStage.bAllEnable;
+bForwardEnabled := bForwardEnabled AND stMotionStage.bAllForwardEnable;
+bBackwardEnabled := bBackwardEnabled AND stMotionStage.bAllBackwardEnable;
+
+CASE eStatePMPSStatus OF
+    E_StatePMPSStatus.UNKNOWN:
+        stMotionStage.bSafetyReady := FALSE;
+    E_StatePMPSStatus.TRANSITION:
+        stMotionStage.bSafetyReady := bTransitionAuthorized;
+        bForwardEnabled R= NOT bTransitionAuthorized;
+        bBackwardEnabled R= NOT bTransitionAuthorized;
+    E_StatePMPSStatus.AT_STATE:
+        stMotionStage.bSafetyReady := stMotionStage.bExecute;
+    E_StatePMPSStatus.DISABLED:
+        stMotionStage.bSafetyReady := TRUE;
+END_CASE
+
+mc_power(
+    Axis:=stMotionStage.Axis,
+    Enable:=bEnabled,
+    Enable_Positive:=bForwardEnabled,
+    Enable_Negative:=bBackwardEnabled,
+);
+END_ACTION
+
+ACTION GetBounds:
+(*
+    This action sets fLowerPos and fUpperPos based on our goal position.
+*)
+IF nGoalStateIndex > 0 AND nGoalStateIndex <= GeneralConstants.MAX_STATES THEN
+    IF astPositionState[nGoalStateIndex].bValid AND astPositionState[nGoalStateIndex].bUpdated THEN
+        bValidGoal := TRUE;
+        fLowerPos := astPositionState[nGoalStateIndex].fPosition - ABS(astPositionState[nGoalStateIndex].fDelta);
+        fUpperPos := astPositionState[nGoalStateIndex].fPosition + ABS(astPositionState[nGoalStateIndex].fDelta);
+    ELSE
+        bValidGoal := FALSE;
+    END_IF
+ELSE
+    bValidGoal := FALSE;
+END_IF
+END_ACTION
+
+ACTION RunFastFaults:
+ffNoGoal(
+    i_xOK:=bValidGoal,
+    i_xAutoReset:=TRUE,
+    i_DevName:=stMotionStage.sName,
+    i_Desc:='Invalid goal position in state move',
+    i_TypeCode:=E_MotionFFType.INVALID_GOAL,
+    io_fbFFHWO:=fbFFHWO,
+);
+END_ACTION
+
+ACTION SetEnables:
+(*
+    This action sets bForwardEnable and bBackwardEnable based on
+    the current position and the calculated bounds.
+*)
+IF bValidGoal AND bEnable THEN
+    bForwardEnabled := stMotionStage.stAxisStatus.fActPosition < fUpperPos;
+    bBackwardEnabled := stMotionStage.stAxisStatus.fActPosition > fLowerPos;
+ELSE
+    // Either invalid state with a fault or FB not enabled
+    bForwardEnabled := TRUE;
+    bBackwardEnabled := TRUE;
+END_IF
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_StatePMPSEnables_Test

+
FUNCTION_BLOCK FB_StatePMPSEnables_Test EXTENDS FB_MotorTestSuite
+(*
+    Tests for FB_StatePMPSEnables
+
+    This function block ensures that:
+    - When not at our goal state, we cannot move away from our goal state
+    - When at our goal state, we must stay within the state bounds
+    - When at our goal state, we still obey other constraints like limit switches
+
+    We also include a super basic real move test with our simulator motor to make sure the enables are set properly.
+*)
+VAR
+    stMotionStage: ST_MotionStage;
+    fbMotionStage: FB_MotionStage;
+    astPositionState: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    fbInternal1: FB_PositionStateInternal;
+    fbInternal2: FB_PositionStateInternal;
+    nInvalidState: UINT := 2;
+    nGoalState: UINT := 4;
+    nNotUpdatedState: UINT := 6;
+
+    bInit: BOOL;
+    nTestCounter: UINT;
+    bOneTestDone: BOOL;
+    fTestStartPos: LREAL;
+    tonTimer: TON;
+    bStatesReady: BOOL;
+END_VAR
+astPositionState[nGoalState].fPosition := 10;
+astPositionState[nGoalState].fDelta := 1;
+SetGoodState(astPositionState[nGoalState]);
+astPositionState[nInvalidState].fPosition := 20;
+astPositionState[nInvalidState].fDelta := 1;
+astPositionState[nNotUpdatedState].fPosition := 20;
+astPositionState[nNotUpdatedState].fDelta := 1;
+SetGoodState(astPositionState[nNotUpdatedState]);
+fbInternal1(
+    stMotionStage:=stMotionStage,
+    stPositionState:=astPositionState[nGoalState],
+);
+fbInternal2(
+    stMotionStage:=stMotionStage,
+    stPositionState:=astPositionState[nInvalidState],
+);
+fbMotionStage(stMotionStage:=stMotionStage);
+bStatesReady:=astPositionState[nGoalState].bUpdated AND astPositionState[nInvalidState].bUpdated;
+
+IF bStatesReady AND nTestCounter = 0 THEN
+    // Don't run any tests until the states are ready
+    nTestCounter := 1;
+END_IF
+
+TestInvalid(1);
+TestNotUpdated(2);
+TestBelow(3);
+TestAbove(4);
+TestAt(5);
+TestDisabled(6);
+TestLimits(7);
+TestMoveTo(8);
+TestMoveAt(9);
+
+IF bOneTestDone THEN
+    bOneTestDone := FALSE;
+    nTestCounter := nTestCounter + 1;
+    tonTimer(IN:=FALSE);
+END_IF
+// Use this timer to time out any tests that stall
+tonTimer(
+    IN:=bStatesReady,
+    PT:=T#5s,
+);
+
+END_FUNCTION_BLOCK
+
+METHOD TestAbove
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbStateEnables: FB_StatePMPSEnables;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbMove: FB_TestHelperSetAndMove;
+
+    bInit: BOOL;
+END_VAR
+TEST('TestAbove');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+SetEnablesPMPS(stMotionStage);
+
+// Set position to be above the goal's range
+fbMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=bInit,
+    fStartPosition:=astPositionState[nGoalState].fPosition + 100 * astPositionState[nGoalState].fDelta,
+    fGoalPosition:=astPositionState[nGoalState].fPosition + 100 * astPositionState[nGoalState].fDelta,
+    fVelocity:=1,
+    bHWEnable:=FALSE,
+);
+bInit := TRUE;
+// Run our FB
+fbStateEnables(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=TRUE,
+    nGoalStateIndex:=nGoalState,
+);
+fbFFHWO.EvaluateOutput();
+// If we've set the position OR ran out of time to set the position, check the asserts
+IF tonTimer.Q OR fbMove.bSetDone THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    AssertEquals_LREAL(
+        Expected:=fbMove.fStartPosition,
+        Actual:=fbMove.fActPosition,
+        Delta:=0.0001,
+        Message:='Position was not set correctly',
+    );
+    AssertTrue(
+        fbFFHWO.q_xFastFaultOut,
+        'Fast fault in normal situation',
+    );
+    AssertFalse(
+        fbStateEnables.bForwardEnabled,
+        'Forward enabled when above goal',
+    );
+    AssertTrue(
+        fbStateEnables.bBackwardEnabled,
+        'Backward disabled when above goal',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestAt
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbStateEnables: FB_StatePMPSEnables;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbMove: FB_TestHelperSetAndMove;
+
+    bInit: BOOL;
+END_VAR
+TEST('TestAt');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+SetEnablesPMPS(stMotionStage);
+
+// Set position to be at the goal state
+fbMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=bInit,
+    fStartPosition:=astPositionState[nGoalState].fPosition,
+    fGoalPosition:=astPositionState[nGoalState].fPosition,
+    fVelocity:=1,
+    bHWEnable:=FALSE,
+);
+bInit := TRUE;
+// Run our FB
+fbStateEnables(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=TRUE,
+    nGoalStateIndex:=nGoalState,
+);
+fbFFHWO.EvaluateOutput();
+// If we've set the position OR ran out of time to set the position, check the asserts
+IF tonTimer.Q OR fbMove.bSetDone THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    AssertEquals_LREAL(
+        Expected:=fbMove.fStartPosition,
+        Actual:=fbMove.fActPosition,
+        Delta:=0.0001,
+        Message:='Position was not set correctly',
+    );
+    AssertTrue(
+        fbFFHWO.q_xFastFaultOut,
+        'Fast fault in normal situation',
+    );
+    AssertTrue(
+        fbStateEnables.bForwardEnabled,
+        'Forward disabled when at goal',
+    );
+    AssertTrue(
+        fbStateEnables.bBackwardEnabled,
+        'Backward disabled when at goal',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestBelow
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbStateEnables: FB_StatePMPSEnables;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbMove: FB_TestHelperSetAndMove;
+
+    bInit: BOOL;
+END_VAR
+TEST('TestBelow');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+SetEnablesPMPS(stMotionStage);
+
+// Set position to be below the goal's range
+fbMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=bInit,
+    fStartPosition:=astPositionState[nGoalState].fPosition - 100 * astPositionState[nGoalState].fDelta,
+    fGoalPosition:=astPositionState[nGoalState].fPosition - 100 * astPositionState[nGoalState].fDelta,
+    fVelocity:=1,
+    bHWEnable:=FALSE,
+);
+bInit := TRUE;
+// Run our FB
+fbStateEnables(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=bInit,
+    nGoalStateIndex:=nGoalState,
+);
+
+fbFFHWO.EvaluateOutput();
+// If we've set the position OR ran out of time to set the position, check the asserts
+IF tonTimer.Q OR fbMove.bSetDone THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    AssertEquals_LREAL(
+        Expected:=fbMove.fStartPosition,
+        Actual:=fbMove.fActPosition,
+        Delta:=0.0001,
+        Message:='Position was not set correctly',
+    );
+    AssertTrue(
+        fbFFHWO.q_xFastFaultOut,
+        'Fast fault in normal situation',
+    );
+    AssertFalse(
+        fbStateEnables.bBackwardEnabled,
+        'Backward enabled when below goal',
+    );
+    AssertTrue(
+        fbStateEnables.bForwardEnabled,
+        'Forward disabled when below goal',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestDisabled
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbStateEnables: FB_StatePMPSEnables;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbMove: FB_TestHelperSetAndMove;
+
+    bInit: BOOL;
+END_VAR
+TEST('TestDisabled');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+SetEnablesPMPS(stMotionStage);
+
+// Set position to be below the goal's range
+fbMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=bInit,
+    fStartPosition:=astPositionState[nGoalState].fPosition - 100 * astPositionState[nGoalState].fDelta,
+    fGoalPosition:=astPositionState[nGoalState].fPosition - 100 * astPositionState[nGoalState].fDelta,
+    fVelocity:=1,
+    bHWEnable:=FALSE,
+);
+bInit := TRUE;
+// Run our FB
+fbStateEnables(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=FALSE,
+    nGoalStateIndex:=nGoalState,
+);
+
+fbFFHWO.EvaluateOutput();
+// If we've set the position OR ran out of time to set the position, check the asserts
+IF tonTimer.Q OR fbMove.bSetDone THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    AssertEquals_LREAL(
+        Expected:=fbMove.fStartPosition,
+        Actual:=fbMove.fActPosition,
+        Delta:=0.0001,
+        Message:='Position was not set correctly',
+    );
+    AssertTrue(
+        fbFFHWO.q_xFastFaultOut,
+        'Fast fault in normal situation',
+    );
+    AssertTrue(
+        fbStateEnables.bBackwardEnabled,
+        'Backward disabled when fb is supposed to be disabled',
+    );
+    AssertTrue(
+        fbStateEnables.bForwardEnabled,
+        'Forward disabled when fb is supposed to be disabled',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestInvalid
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbStateEnables: FB_StatePMPSEnables;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestInvalid');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+SetEnablesPMPS(stMotionStage);
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Faulted prior to test',
+);
+// The invalid state should give us a fault
+fbStateEnables(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=TRUE,
+    nGoalStateIndex:=nInvalidState,
+);
+fbFFHWO.EvaluateOutput();
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Invalid state did not fault',
+);
+
+bOneTestDone := TRUE;
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestLimits
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbStateEnables: FB_StatePMPSEnables;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbMove: FB_TestHelperSetAndMove;
+
+    bInit: BOOL;
+END_VAR
+TEST('TestLimits');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+SetEnablesPMPS(stMotionStage);
+// Kill the limit switches for this test
+stMotionStage.bLimitForwardEnable := FALSE;
+stMotionStage.bLimitBackwardEnable := FALSE;
+
+// Set position to be at the goal state
+fbMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=bInit,
+    fStartPosition:=astPositionState[nGoalState].fPosition,
+    fGoalPosition:=astPositionState[nGoalState].fPosition,
+    fVelocity:=1,
+    bHWEnable:=FALSE,
+);
+bInit := TRUE;
+
+// Run our FB
+fbStateEnables(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=TRUE,
+    nGoalStateIndex:=nGoalState,
+);
+fbFFHWO.EvaluateOutput();
+// If we've set the position OR ran out of time to set the position, check the asserts
+IF tonTimer.Q OR fbMove.bSetDone THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    AssertEquals_LREAL(
+        Expected:=fbMove.fStartPosition,
+        Actual:=fbMove.fActPosition,
+        Delta:=0.0001,
+        Message:='Position was not set correctly',
+    );
+    AssertTrue(
+        fbFFHWO.q_xFastFaultOut,
+        'Fast fault in normal situation',
+    );
+    AssertFalse(
+        fbStateEnables.bForwardEnabled,
+        'Forward enabled with limit hit',
+    );
+    AssertFalse(
+        fbStateEnables.bBackwardEnabled,
+        'Backward enabled with limit hit',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestMoveAt
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbStateEnables: FB_StatePMPSEnables;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbMove: FB_TestHelperSetAndMove;
+
+    bInit: BOOL;
+END_VAR
+TEST('TestMoveAt');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+SetEnablesPMPS(stMotionStage);
+
+// Run our FB which should enable the real move
+fbStateEnables(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=bInit,
+    nGoalStateIndex:=nGoalState,
+    eStatePMPSStatus:=E_StatePMPSStatus.AT_STATE,
+    bTransitionAuthorized:=FALSE,
+);
+
+// Set position to be below the goal's range, and move to the goal
+fbMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=bInit,
+    fStartPosition:=astPositionState[nGoalState].fPosition - astPositionState[nGoalState].fDelta / 2,
+    fGoalPosition:=astPositionState[nGoalState].fPosition + astPositionState[nGoalState].fDelta / 2,
+    fVelocity:=5,
+    bHWEnable:=FALSE,
+);
+bInit := TRUE;
+
+fbFFHWO.EvaluateOutput();
+
+// If we've reached the position OR ran out of time to set the position, check the asserts
+IF tonTimer.Q OR fbMove.bMoveDone THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState[nGoalState].fPosition + astPositionState[nGoalState].fDelta / 2,
+        Actual:=fbMove.fActPosition,
+        Delta:=0.0001,
+        Message:='Did not reach the goal position',
+    );
+    AssertTrue(
+        fbFFHWO.q_xFastFaultOut,
+        'Fast fault in normal situation',
+    );
+    AssertTrue(
+        fbStateEnables.bBackwardEnabled,
+        'Backward disabled when at goal',
+    );
+    AssertTrue(
+        fbStateEnables.bForwardEnabled,
+        'Forward disabled when at goal',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestMoveTo
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbStateEnables: FB_StatePMPSEnables;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+    fbMove: FB_TestHelperSetAndMove;
+
+    bInit: BOOL;
+END_VAR
+TEST('TestMoveTo');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+SetEnablesPMPS(stMotionStage);
+
+// Run our FB which should enable the real move
+fbStateEnables(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=bInit,
+    nGoalStateIndex:=nGoalState,
+    eStatePMPSStatus:=E_StatePMPSStatus.TRANSITION,
+    bTransitionAuthorized:=TRUE,
+);
+
+// Set position to be below the goal's range, and move to the goal
+fbMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=bInit,
+    fStartPosition:=astPositionState[nGoalState].fPosition - 10,
+    fGoalPosition:=astPositionState[nGoalState].fPosition,
+    fVelocity:=5,
+    bHWEnable:=FALSE,
+);
+bInit := TRUE;
+
+fbFFHWO.EvaluateOutput();
+
+// If we've reached the position OR ran out of time to set the position, check the asserts
+IF tonTimer.Q OR fbMove.bMoveDone THEN
+    AssertFalse(
+        tonTimer.Q,
+        'Timeout in test',
+    );
+    AssertEquals_LREAL(
+        Expected:=astPositionState[nGoalState].fPosition,
+        Actual:=fbMove.fActPosition,
+        Delta:=0.0001,
+        Message:='Did not reach the goal position',
+    );
+    AssertTrue(
+        fbFFHWO.q_xFastFaultOut,
+        'Fast fault in normal situation',
+    );
+    AssertTrue(
+        fbStateEnables.bBackwardEnabled,
+        'Backward disabled when at goal',
+    );
+    AssertTrue(
+        fbStateEnables.bForwardEnabled,
+        'Forward disabled when at goal',
+    );
+    bOneTestDone := TRUE;
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+METHOD TestNotUpdated
+VAR_INPUT
+    nTestID: UINT;
+END_VAR
+VAR_INST
+    fbStateEnables: FB_StatePMPSEnables;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestNotUpdated');
+IF nTestCounter <> nTestID THEN
+    RETURN;
+END_IF
+
+SetEnablesPMPS(stMotionStage);
+
+fbFFHWO.EvaluateOutput();
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Faulted prior to test',
+);
+// The invalid state should give us a fault
+fbStateEnables(
+    stMotionStage:=stMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=TRUE,
+    nGoalStateIndex:=nNotUpdatedState,
+);
+fbFFHWO.EvaluateOutput();
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Not updated state did not fault',
+);
+
+bOneTestDone := TRUE;
+TEST_FINISHED();
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_StatePMPSEnablesND

+
FUNCTION_BLOCK FB_StatePMPSEnablesND
+(*
+    Function block to set virtual limit enables using MC_POWER for multidimensional state movers.
+    It is a building block not meant for use outside of lcls-twintcat-motion.
+
+    Each motor has a virtual "allowed" range of motion based on its goal position.
+    Motors can move toward their goal delta ranges or within them, but not away from these ranges.
+*)
+VAR_IN_OUT
+    // The motors with a combined N-dimensional state
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    // Each motor's respective position states along its direction
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    // Hardware output to fault to if there is a problem.
+    fbFFHWO: FB_HardwareFFOutput;
+END_VAR
+VAR_INPUT
+    // Whether or not to do anything
+    bEnable: BOOL;
+    // The number of motors we're actually using
+    nActiveMotorCount: UINT;
+    // The state that the motors are moving to, along dimension 2 of the position state array. This may be the same as the current state.
+    nGoalStateIndex: UINT;
+    // A name to use for this state mover in the case of fast faults.
+    sDeviceName: STRING;
+    // Set to TRUE to put motors into maintenance mode. This allows us to freely move the motors at the cost of a fast fault.
+    bMaintMode: BOOL;
+    // The overal PMPS FB state
+    eStatePMPSStatus: E_StatePMPSStatus;
+    // Connect from bptm bTransitionAuthorized
+    bTransitionAuthorized: BOOL;
+END_VAR
+VAR_OUTPUT
+    // Per-motor enable state we send to MC_Power. This is a pass-through from stMotionStage.
+    abEnabled: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF BOOL;
+    // Per-motor forward enable state we send to MC_Power. This may be a pass-through or an override to FALSE.
+    abForwardEnabled: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF BOOL;
+    // Per-motor backwards enable state we send to MC_Power. This may be a pass-through or an override to FALSE.
+    abBackwardEnabled: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF BOOL;
+    // Per-motor TRUE if there is a valid goal position and FALSE otherwise. This makes a fast fault if FALSE.
+    abValidGoal: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF BOOL;
+    // Set to TRUE if the arrays have mismatched sizing. For this FB, this means the motor won't ever get an enable.
+    bMotorCountError: BOOL;
+END_VAR
+VAR
+    // The individual state limit function blocks
+    afbStateEnables: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF FB_StatePMPSEnables;
+    ffMaint: FB_FastFault;
+    ffProgrammerError: FB_FastFault;
+    nIter: DINT;
+END_VAR
+CheckCount();
+IF NOT bMotorCountError THEN
+    DoLimits();
+END_IF
+RunFastFaults();
+
+END_FUNCTION_BLOCK
+
+ACTION CheckCount:
+// Make sure the motor count is valid (positive, nonzero, less or equal to the max)
+bMotorCountError S= nActiveMotorCount <= 0;
+bMotorCountError S= nActiveMotorCount > MotionConstants.MAX_STATE_MOTORS;
+END_ACTION
+
+ACTION DoLimits:
+FOR nIter := 1 TO nActiveMotorCount DO
+    afbStateEnables[nIter](
+        stMotionStage:=astMotionStage[nIter],
+        astPositionState:=astPositionState[nIter],
+        fbFFHWO:=fbFFHWO,
+        bEnable:=bEnable AND NOT bMaintMode,
+        nGoalStateIndex:=nGoalStateIndex,
+        eStatePMPSStatus:=eStatePMPSStatus,
+        bTransitionAuthorized:=bTransitionAuthorized,
+        bEnabled=>abEnabled[nIter],
+        bForwardEnabled=>abForwardEnabled[nIter],
+        bBackwardEnabled=>abBackwardEnabled[nIter],
+        bValidGoal=>abValidGoal[nIter],
+    );
+END_FOR
+END_ACTION
+
+ACTION RunFastFaults:
+ffMaint(
+    i_xOK := NOT bMaintMode,
+    i_xAutoReset := TRUE,
+    i_DevName := sDeviceName,
+    i_Desc := 'Device is in maintenance mode',
+    i_TypeCode := E_MotionFFType.MAINT_MODE,
+    io_fbFFHWO := fbFFHWO,
+);
+
+ffProgrammerError(
+    i_xOK:=NOT bMotorCountError,
+    i_xAutoReset:=TRUE,
+    i_DevName:=sDeviceName,
+    i_Desc:='Programmer error picking motor count',
+    i_TypeCode:=E_MotionFFType.INTERNAL_ERROR,
+    io_fbFFHWO:=fbFFHWO,
+);
+END_ACTION
+
+
+
+
Related:
+
+
+
+
+

FB_StatePMPSEnablesND_Test

+
FUNCTION_BLOCK FB_StatePMPSEnablesND_Test EXTENDS FB_MotorTestSuite
+(*
+    Unit tests for FB_StatePMPSEnablesND
+    I'm confident that FB_StatePMPSEnables was tested in FB_StatePMPSEnables_Test
+    There will be one core functionality check
+    Then, the rest will be about the ND feature adds.
+    Full checks:
+    - Core motors not at goal can't move away check
+    - bMaintMode = no move restrictions for all motors.
+    - bMaintMode = fast fault
+    - Wrong count = fast fault
+*)
+VAR
+    astMotionStage: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ST_MotionStage;
+    astPositionState: ARRAY[1..MotionConstants.MAX_STATE_MOTORS] OF ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    afbInternal: ARRAY[1..2] OF FB_PositionStateInternal;
+    nIter: UINT;
+END_VAR
+// Spoof motor enables
+FOR nIter := 1 TO 3 DO
+    astMotionStage[nIter].bAllEnable := TRUE;
+    astMotionStage[nIter].bAllForwardEnable := TRUE;
+    astMotionStage[nIter].bAllBackwardEnable := TRUE;
+END_FOR
+// Note: the fake motors show as position = 0, so they will be over/under the goals here
+astPositionState[1][1].fPosition := 10;
+astPositionState[1][1].fDelta := 1;
+afbInternal[1](
+    stMotionStage:=astMotionStage[1],
+    stPositionState:=astPositionState[1][1],
+);
+SetGoodState(astPositionState[1][1]);
+
+astPositionState[2][1].fPosition := -10;
+astPositionState[2][1].fDelta := 1;
+afbInternal[2](
+    stMotionStage:=astMotionStage[2],
+    stPositionState:=astPositionState[2][1],
+);
+SetGoodState(astPositionState[2][1]);
+
+TestUnderOverGoals();
+TestMaint();
+TestCount();
+
+END_FUNCTION_BLOCK
+
+METHOD TestCount
+VAR_INST
+    fbEnables: FB_StatePMPSEnablesND;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestCount');
+
+fbFFHWO.EvaluateOutput();
+// No faults please
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Had faults prior to test',
+);
+fbEnables(
+    astMotionStage:=astMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    nGoalStateIndex:=1,
+    sDeviceName:='TestUnderOverGoals',
+    bMaintMode:=FALSE,
+);
+fbFFHWO.EvaluateOutput();
+// Must fault with bad count
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Had no fault with bad count',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestMaint
+VAR_INST
+    fbEnables: FB_StatePMPSEnablesND;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestMaint');
+
+fbFFHWO.EvaluateOutput();
+// No faults please
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Had faults prior to test',
+);
+fbEnables(
+    astMotionStage:=astMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    nActiveMotorCount:=2,
+    nGoalStateIndex:=1,
+    sDeviceName:='TestUnderOverGoals',
+    bMaintMode:=TRUE,
+);
+fbFFHWO.EvaluateOutput();
+// Must fault in maint mode
+AssertFalse(
+    fbFFHWO.q_xFastFaultOut,
+    'Had no fault in maintenance mode',
+);
+// All overrides should be relaxed
+AssertTrue(
+    fbEnables.abForwardEnabled[1],
+    'In maintenance mode, we should be able to move anywhere',
+);
+AssertTrue(
+    fbEnables.abBackwardEnabled[1],
+    'In maintenance mode, we should be able to move anywhere',
+);
+AssertTrue(
+    fbEnables.abForwardEnabled[1],
+    'In maintenance mode, we should be able to move anywhere',
+);
+AssertTrue(
+    fbEnables.abBackwardEnabled[1],
+    'In maintenance mode, we should be able to move anywhere',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestUnderOverGoals
+VAR_INST
+    fbEnables: FB_StatePMPSEnablesND;
+    fbFFHWO: FB_HardwareFFOutput := (bAutoReset := TRUE);
+END_VAR
+TEST('TestUnderOverGoals');
+
+IF NOT astPositionState[1][1].bUpdated OR NOT astPositionState[2][1].bUpdated THEN
+    // Cannot run this test until the one-time-setup runs
+    RETURN;
+END_IF
+
+fbEnables(
+    astMotionStage:=astMotionStage,
+    astPositionState:=astPositionState,
+    fbFFHWO:=fbFFHWO,
+    bEnable:=TRUE,
+    nActiveMotorCount:=2,
+    nGoalStateIndex:=1,
+    sDeviceName:='TestUnderOverGoals',
+    bMaintMode:=FALSE,
+);
+fbFFHWO.EvaluateOutput();
+// No faults please
+AssertTrue(
+    fbFFHWO.q_xFastFaultOut,
+    'Had faults in normal situation',
+);
+// All core enables are true
+AssertTrue(
+    astMotionStage[1].bAllForwardEnable,
+    'Core enables should be TRUE',
+);
+AssertTrue(
+    astMotionStage[1].bAllBackwardEnable,
+    'Core enables should be TRUE',
+);
+AssertTrue(
+    astMotionStage[2].bAllForwardEnable,
+    'Core enables should be TRUE',
+);
+AssertTrue(
+    astMotionStage[2].bAllBackwardEnable,
+    'Core enables should be TRUE',
+);
+// But the overrides force us to move toward the goal
+// Motor 1 is below the goal, Motor 2 is above the goal
+AssertTrue(
+    fbEnables.abForwardEnabled[1],
+    'Motor 1 should be able to move up to the goal',
+);
+AssertFalse(
+    fbEnables.abBackwardEnabled[1],
+    'Motor 1 should not be able to move down away from the goal',
+);
+AssertFalse(
+    fbEnables.abForwardEnabled[2],
+    'Motor 2 should not be able to move up away from the goal',
+);
+AssertTrue(
+    fbEnables.abBackwardEnabled[2],
+    'Motor 2 should be able to move down to the goal',
+);
+
+TEST_FINISHED();
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_StatePTPMove

+
{attribute 'obsolete' := 'Use FB_PositionStateMove instead'}
+FUNCTION_BLOCK FB_StatePTPMove
+// Do not use, this is deprecated
+VAR_INPUT
+    {attribute 'pytmc' := '
+        pv:
+    '}
+    stPositionState: ST_PositionState;
+
+    {attribute 'pytmc' := '
+        pv: GO
+        io: io
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bExecute: BOOL;
+
+    bMoveOk: BOOL;
+END_VAR
+VAR_IN_OUT
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR_OUTPUT
+    {attribute 'pytmc' := '
+        pv: AT_STATE
+        io: input
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bAtState: BOOL;
+
+    {attribute 'pytmc' := '
+        pv: DMOV
+        io: input
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bDone: BOOL;
+
+    {attribute 'pytmc' := '
+        pv: BUSY
+        io: input
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bBusy: BOOL;
+
+    {attribute 'pytmc' := '
+        pv: ERR
+        io: input
+        field: ZNAM False
+        field: ONAM True
+    '}
+    bError: BOOL;
+
+    {attribute 'pytmc' := '
+        pv: ERRMSG
+        io: input
+    '}
+    sError: STRING;
+END_VAR
+VAR
+    bExecTrig: R_TRIG;
+    bExecEnd: F_TRIG;
+    fActPosition: LREAL;
+    fLowPos: LREAL;
+    fHighPos: LREAL;
+END_VAR
+bExecTrig(CLK:=bExecute);
+IF bExecTrig.Q AND bMoveOk THEN
+    IF NOT stMotionStage.bBusy AND NOT stMotionStage.bError THEN
+        stMotionStage.bExecute := TRUE;
+        stMotionStage.nCommand := E_EpicsMotorCmd.MOVE_ABSOLUTE;
+        stMotionStage.fPosition := stPositionState.fPosition;
+        stMotionStage.fVelocity := stPositionState.fVelocity;
+        stMotionStage.fAcceleration := stPositionState.fAccel;
+        stMotionStage.fDeceleration := stPositionState.fDecel;
+        bDone := FALSE;
+        bBusy := TRUE;
+    END_IF
+END_IF
+bError := stMotionStage.bError;
+sError := stMotionStage.sErrorMessage;
+
+fActPosition := stMotionStage.stAxisStatus.fActPosition;
+fLowPos := stPositionState.fPosition - stPositionState.fDelta;
+fHighPos := stPositionState.fPosition + stPositionState.fDelta;
+IF (fLowPos < fActPosition) AND (fHighPos > fActPosition) THEN
+    bAtState := TRUE;
+    IF NOT stMotionStage.bBusy THEN
+        bDone := TRUE;
+        bBusy := FALSE;
+        bExecute := FALSE;
+    END_IF
+ELSE
+    bAtState := FALSE;
+END_IF
+
+bExecEnd(CLK:=bExecute);
+IF bExecEnd.Q AND bBusy THEN
+    stMotionStage.bExecute := FALSE;
+END_IF
+
+IF NOT stMotionStage.bExecute OR NOT bExecute THEN
+    bDone := TRUE;
+    bBusy := FALSE;
+    bExecute := FALSE;
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_StateSetupHelper

+
FUNCTION_BLOCK FB_StateSetupHelper
+(*
+    This is a helper for setting up large numbers of ST_PositionState instances.
+
+    This is typically verbose to do by hand in the normal ways and can be error-prone.
+
+    Calling with bSetDefault:=TRUE will set the default values to all the values
+    from the input stPositionState. Note that the other args will be ignored in this case.
+    This must be done at least once. If you forget to do this, there will be a warning and
+    bValid will be set to FALSE, making it so we cannot move to that state.
+
+    Calling without bSetDefault or with it set to FALSE will apply values to the
+    input stPositionState with the following priority order:
+
+    1. The value used in the function block call
+    2. The value from the template stPositionState used in the most recent
+       call with bSetDefault:=TRUE
+    3. The original default value as defined on ST_PositionState
+
+    For ease of use, to enable EPICS writes if unlocked, and to avoid repeated
+    self-overwrites in the encoder count use case, this function block will not
+    reapply the values to the same state again after the state has been fully
+    initialized by the states function blocks, as determined by the bUpdated struct
+    member. If you want to force the function block to reapply every cycle you can
+    set bForceUpdate to TRUE, but it is not recommended. Without this feature,
+    you would be required to wrap this function block in a guard to make sure it
+    was only called once per state, which is fairly annoying.
+
+    Example expected usage:
+    VAR
+        fbStateSetup: FB_StateSetupHelper;
+        stDefault: ST_PositionState := (
+            fDelta := 0.5,
+            fVelocity := 10,
+            bMoveOk := TRUE,
+            bValid := TRUE
+        );
+        astStates1: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+        astStates2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+        astStates2: ARRAY[1..GeneralConstants.MAX_STATES] OF ST_PositionState;
+    END_VAR
+
+    fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE);
+
+    fbStateSetup(stPositionState:=astStates1[1], sName:='OUT', fPosition:=10);
+    fbStateSetup(stPositionState:=astStates1[2], sName:='YAG', fPosition:=20);
+    fbStateSetup(stPositionState:=astStates1[3], sName:='TT', fPosition:=30);
+
+    fbStateSetup(stPositionState:=astStates2[1], sName:='OUT', fPosition:=-30);
+    fbStateSetup(stPositionState:=astStates2[2], sName:='YAG', fPosition:=35);
+    fbStateSetup(stPositionState:=astStates2[3], sName:='TT', fPosition:=70);
+
+    fbStateSetup(stPositionState:=astStates3[1], sName:='OUT', fPosition:=0.4, fDelta:=0.1);
+    fbStateSetup(stPositionState:=astStates3[2], sName:='YAG', fPosition:=2.3, fDelta:=0.1);
+    fbStateSetup(stPositionState:=astStates3[3], sName:='TT', fPosition:=5.6, fDelta:=0.1;
+*)
+VAR_IN_OUT
+    stPositionState: ST_PositionState;
+END_VAR
+VAR_INPUT
+    bSetDefault: BOOL;
+    bForceUpdate: BOOL;
+    sName: STRING;
+    fPosition: LREAL;
+    nEncoderCount: UDINT;
+    fDelta: LREAL;
+    fVelocity: LREAL;
+    fAccel: LREAL;
+    fDecel: LREAL;
+    bMoveOk: BOOL;
+    bLocked: BOOL;
+    bValid: BOOL;
+    bUseRawCounts: BOOL;
+    sPmpsState: STRING;
+END_VAR
+VAR
+    stDefault: ST_PositionState;
+    fbWarning: FB_LogMessage;
+    bHasDefault: BOOL;
+    bHasWarned: BOOL;
+    sJson: STRING;
+END_VAR
+IF bSetDefault THEN
+    bSetDefault := FALSE;
+    bHasDefault := TRUE;
+    stDefault := stPositionState;
+ELSIF bForceUpdate OR NOT stPositionState.bUpdated THEN
+    stPositionState.sName := sName;
+    stPositionState.fPosition := fPosition;
+    stPositionState.nEncoderCount := nEncoderCount;
+    stPositionState.fDelta := fDelta;
+    stPositionState.fVelocity := fVelocity;
+    stPositionState.fAccel := fAccel;
+    stPositionState.fDecel := fDecel;
+    stPositionState.bMoveOk := bMoveOk;
+    stPositionState.bLocked := bLocked;
+    stPositionState.bValid := bValid;
+    stPositionState.bUseRawCounts := bUseRawCounts;
+    stPositionState.stPMPS.sPmpsState := sPmpsState;
+    IF NOT bHasDefault THEN
+        stPositionState.bValid := FALSE;
+        IF NOT bHasWarned THEN
+            bHasWarned := TRUE;
+            sJson := CONCAT(CONCAT(CONCAT(CONCAT('{"sName": "', sName), '", "sPmpsState": "'), sPmpsState), '"}');
+            fbWarning(
+                sMsg:=CONCAT('Did not initialize any defaults in FB_StateSetupHelper! Some states are disabled, check your code! ', sJson),
+                eSevr:=TcEventSeverity.Warning,
+                eSubSystem:=E_Subsystem.MOTION,
+                sJson:=sJson,
+            );
+        END_IF
+    END_IF
+END_IF
+
+// Overwrite the input args so that unset args are the defaults in the next call
+sName := stDefault.sName;
+fPosition := stDefault.fPosition;
+nEncoderCount := stDefault.nEncoderCount;
+fDelta := stDefault.fDelta;
+fVelocity := stDefault.fVelocity;
+fAccel := stDefault.fAccel;
+fDecel := stDefault.fDecel;
+bMoveOk := stDefault.bMoveOk;
+bLocked := stDefault.bLocked;
+bValid := stDefault.bValid;
+bUseRawCounts := stDefault.bUseRawCounts;
+sPmpsState := stDefault.stPMPS.sPmpsState;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_StateSetupHelper_Test

+
FUNCTION_BLOCK FB_StateSetupHelper_Test EXTENDS FB_TestSuite
+VAR
+    astStates: ARRAY[1..10] OF ST_PositionState;
+    stDefaultDefault: ST_PositionState;
+END_VAR
+TestNormalCase();
+TestDefaultOnly();
+TestManyOverrides();
+TestNoDefault();
+TestOnlyOnce();
+
+END_FUNCTION_BLOCK
+
+METHOD TestDefaultOnly
+VAR
+    fbStateSetup: FB_StateSetupHelper;
+    stDefault: ST_PositionState := (
+        sName := 'DEFAULT',
+        fPosition := 100,
+        nEncoderCount := 200,
+        fDelta := 0.5,
+        fVelocity := 10,
+        fAccel := 12,
+        fDecel := 24,
+        bMoveOk := TRUE,
+        bLocked := TRUE,
+        bValid := TRUE,
+        bUseRawCounts := TRUE
+    );
+    stOriginal: ST_PositionState;
+    stTarget: ST_PositionState;
+END_VAR
+TEST('TestDefaultOnly');
+
+// Add a pmps key
+stDefault.stPMPS.sPmpsState := 'KEY';
+// Cache the defaults to use as the check in case stDefault gets mutated by a bug
+stOriginal := stDefault;
+// Apply only defaults
+fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE);
+fbStateSetup(stPositionState:=stTarget);
+// Check everything
+AssertEquals_STRING(stOriginal.sName, stTarget.sName, 'Wrong sName');
+AssertEquals_LREAL(stOriginal.fPosition, stTarget.fPosition, 0, 'Wrong fPosition');
+AssertEquals_UDINT(stOriginal.nEncoderCount, stTarget.nEncoderCount, 'Wrong nEncoderCount');
+AssertEquals_LREAL(stOriginal.fDelta, stTarget.fDelta, 0, 'Wrong fDelta');
+AssertEquals_LREAL(stOriginal.fVelocity, stTarget.fVelocity, 0, 'Wrong fVelocity');
+AssertEquals_LREAL(stOriginal.fAccel, stTarget.fAccel, 0, 'Wrong fAccel');
+AssertEquals_LREAL(stOriginal.fDecel, stTarget.fDecel, 0, 'Wrong fDecel');
+AssertEquals_BOOL(stOriginal.bMoveOk, stTarget.bMoveOk, 'Wrong bMoveOk');
+AssertEquals_BOOL(stOriginal.bLocked, stTarget.bLocked, 'Wrong bLocked');
+AssertEquals_BOOL(stOriginal.bValid, stTarget.bValid, 'Wrong bValid');
+AssertEquals_BOOL(stOriginal.bUseRawCounts, stTarget.bUseRawCounts, 'Wrong bUseRawCounts');
+AssertEquals_STRING(stOriginal.stPMPS.sPmpsState, stTarget.stPMPS.sPmpsState, 'Wrong sPmpsState');
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestManyOverrides
+VAR
+    fbStateSetup: FB_StateSetupHelper;
+    stDefault: ST_PositionState := (
+        sName := 'POTATO',
+        fPosition := 23,
+        fDelta := 0.5,
+        fVelocity := 10
+    );
+    stOne: ST_PositionState;
+    stTwo: ST_PositionState;
+END_VAR
+TEST('TestManyOverrides');
+// This is the case where the defaults are always overriden
+
+fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE);
+fbStateSetup(stPositionState:=stOne, sName:='ONE', fPosition:=10, fDelta:=0.1, fVelocity:=20);
+fbStateSetup(stPositionState:=stTWO, sName:='TWO', fPosition:=30, fDelta:=0.23, fVelocity:=4);
+
+// Check Everything
+AssertEquals_STRING('ONE', stOne.sName, 'Wrong sName in state 1');
+AssertEquals_LREAL(10, stOne.fPosition, 0, 'Wrong fPosition in state 1');
+AssertEquals_UDINT(stDefaultDefault.nEncoderCount, stOne.nEncoderCount, 'Wrong nEncoderCount in state 1');
+AssertEquals_LREAL(0.1, stOne.fDelta, 0, 'Wrong fDelta in state 1');
+AssertEquals_LREAL(20, stOne.fVelocity, 0, 'Wrong fVelocity in state 1');
+AssertEquals_LREAL(stDefaultDefault.fAccel, stOne.fAccel, 0, 'Wrong fAccel in state 1');
+AssertEquals_LREAL(stDefaultDefault.fDecel, stOne.fDecel, 0, 'Wrong fDecel in state 1');
+AssertEquals_BOOL(stDefaultDefault.bMoveOk, stOne.bMoveOk, 'Wrong bMoveOk in state 1');
+AssertEquals_BOOL(stDefaultDefault.bLocked, stOne.bLocked, 'Wrong bLocked in state 1');
+AssertEquals_BOOL(stDefaultDefault.bValid, stOne.bValid, 'Wrong bValid in state 1');
+AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, stOne.bUseRawCounts, 'Wrong bUseRawCounts in state 1');
+AssertEquals_STRING(stDefaultDefault.stPMPS.sPmpsState, stOne.stPMPS.sPmpsState, 'Wrong sPmpsState in state 1');
+
+AssertEquals_STRING('TWO', stTwo.sName, 'Wrong sName in state 2');
+AssertEquals_LREAL(30, stTwo.fPosition, 0, 'Wrong fPosition in state 2');
+AssertEquals_UDINT(stDefaultDefault.nEncoderCount, stTwo.nEncoderCount, 'Wrong nEncoderCount in state 2');
+AssertEquals_LREAL(0.23, stTwo.fDelta, 0, 'Wrong fDelta in state 2');
+AssertEquals_LREAL(4, stTwo.fVelocity, 0, 'Wrong fVelocity in state 2');
+AssertEquals_LREAL(stDefaultDefault.fAccel, stTwo.fAccel, 0, 'Wrong fAccel in state 2');
+AssertEquals_LREAL(stDefaultDefault.fDecel, stTwo.fDecel, 0, 'Wrong fDecel in state 2');
+AssertEquals_BOOL(stDefaultDefault.bMoveOk, stTwo.bMoveOk, 'Wrong bMoveOk in state 2');
+AssertEquals_BOOL(stDefaultDefault.bLocked, stTwo.bLocked, 'Wrong bLocked in state 2');
+AssertEquals_BOOL(stDefaultDefault.bValid, stTwo.bValid, 'Wrong bValid in state 2');
+AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, stTwo.bUseRawCounts, 'Wrong bUseRawCounts in state 2');
+AssertEquals_STRING(stDefaultDefault.stPMPS.sPmpsState, stTwo.stPMPS.sPmpsState, 'Wrong sPmpsState in state 2');
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestNoDefault
+VAR
+    fbStateSetup: FB_StateSetupHelper;
+    stTarget: ST_PositionState;
+END_VAR
+TEST('TestNoDefault');
+// No default = invalid state + warning log message
+
+fbStateSetup(stPositionState:=stTarget, sName:='TestNoDefault', sPmpsState:='TestPMPS', bValid:=TRUE);
+// Only bValid matters, it must not be valid!
+AssertFalse(stTarget.bValid, 'bValid should be FALSE with no default set.');
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestNormalCase
+VAR
+    fbStateSetup: FB_StateSetupHelper;
+    stDefault: ST_PositionState;
+END_VAR
+VAR CONSTANT
+    cDelta: LREAL := 0.5;
+    cVelocity: LREAL := 10;
+    cMoveOk: BOOL := TRUE;
+    cValid: BOOL := TRUE;
+END_VAR
+TEST('TestNormalCase');
+// Mimic what I might do in a real project
+
+stDefault.fDelta := cDelta;
+stDefault.fVelocity := cVelocity;
+stDefault.bMoveOk := cMoveOk;
+stDefault.bValid := cValid;
+
+fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE);
+fbStateSetup(stPositionState:=astStates[1], sName:='OUT', fPosition:=10, sPmpsState:='FAKE_OUT');
+fbStateSetup(stPositionState:=astStates[2], sName:='YAG', fPosition:=20, sPmpsState:='FAKE_YAG');
+fbStateSetup(stPositionState:=astStates[3], sName:='TT', fPosition:=30, sPmpsState:='FAKE_TT');
+
+// Check everything
+AssertEquals_STRING('OUT', astStates[1].sName, 'Wrong sName in state 1');
+AssertEquals_LREAL(10, astStates[1].fPosition, 0, 'Wrong fPosition in state 1');
+AssertEquals_UDINT(stDefaultDefault.nEncoderCount, astStates[1].nEncoderCount, 'Wrong nEncoderCount in state 1');
+AssertEquals_LREAL(cDelta, astStates[1].fDelta, 0, 'Wrong fDelta in state 1');
+AssertEquals_LREAL(cVelocity, astStates[1].fVelocity, 0, 'Wrong fVelocity in state 1');
+AssertEquals_LREAL(stDefaultDefault.fAccel, astStates[1].fAccel, 0, 'Wrong fAccel in state 1');
+AssertEquals_LREAL(stDefaultDefault.fDecel, astStates[1].fDecel, 0, 'Wrong fDecel in state 1');
+AssertEquals_BOOL(cMoveOk, astStates[1].bMoveOk, 'Wrong bMoveOk in state 1');
+AssertEquals_BOOL(stDefaultDefault.bLocked, astStates[1].bLocked, 'Wrong bLocked in state 1');
+AssertEquals_BOOL(cValid, astStates[1].bValid, 'Wrong bValid in state 1');
+AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, astStates[1].bUseRawCounts, 'Wrong bUseRawCounts in state 1');
+AssertEquals_STRING('FAKE_OUT', astStates[1].stPMPS.sPmpsState, 'Wrong sPmpsState in state 1');
+
+AssertEquals_STRING('YAG', astStates[2].sName, 'Wrong sName in state 2');
+AssertEquals_LREAL(20, astStates[2].fPosition, 0, 'Wrong fPosition in state 2');
+AssertEquals_UDINT(stDefaultDefault.nEncoderCount, astStates[2].nEncoderCount, 'Wrong nEncoderCount in state 2');
+AssertEquals_LREAL(cDelta, astStates[2].fDelta, 0, 'Wrong fDelta in state 2');
+AssertEquals_LREAL(cVelocity, astStates[2].fVelocity, 0, 'Wrong fVelocity in state 2');
+AssertEquals_LREAL(stDefaultDefault.fAccel, astStates[2].fAccel, 0, 'Wrong fAccel in state 2');
+AssertEquals_LREAL(stDefaultDefault.fDecel, astStates[2].fDecel, 0, 'Wrong fDecel in state 2');
+AssertEquals_BOOL(cMoveOk, astStates[2].bMoveOk, 'Wrong bMoveOk in state 2');
+AssertEquals_BOOL(stDefaultDefault.bLocked, astStates[2].bLocked, 'Wrong bLocked in state 2');
+AssertEquals_BOOL(cValid, astStates[2].bValid, 'Wrong bValid in state 2');
+AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, astStates[2].bUseRawCounts, 'Wrong bUseRawCounts in state 2');
+AssertEquals_STRING('FAKE_YAG', astStates[2].stPMPS.sPmpsState, 'Wrong sPmpsState in state 2');
+
+AssertEquals_STRING('TT', astStates[3].sName, 'Wrong sName in state 3');
+AssertEquals_LREAL(30, astStates[3].fPosition, 0, 'Wrong fPosition in state 3');
+AssertEquals_UDINT(stDefaultDefault.nEncoderCount, astStates[3].nEncoderCount, 'Wrong nEncoderCount in state 3');
+AssertEquals_LREAL(cDelta, astStates[3].fDelta, 0, 'Wrong fDelta in state 3');
+AssertEquals_LREAL(cVelocity, astStates[3].fVelocity, 0, 'Wrong fVelocity in state 3');
+AssertEquals_LREAL(stDefaultDefault.fAccel, astStates[3].fAccel, 0, 'Wrong fAccel in state 3');
+AssertEquals_LREAL(stDefaultDefault.fDecel, astStates[3].fDecel, 0, 'Wrong fDecel in state 3');
+AssertEquals_BOOL(cMoveOk, astStates[3].bMoveOk, 'Wrong bMoveOk in state 3');
+AssertEquals_BOOL(stDefaultDefault.bLocked, astStates[3].bLocked, 'Wrong bLocked in state 3');
+AssertEquals_BOOL(cValid, astStates[3].bValid, 'Wrong bValid in state 3');
+AssertEquals_BOOL(stDefaultDefault.bUseRawCounts, astStates[3].bUseRawCounts, 'Wrong bUseRawCounts in state 3');
+AssertEquals_STRING('FAKE_TT', astStates[3].stPMPS.sPmpsState, 'Wrong sPmpsState in state 3');
+
+TEST_FINISHED();
+END_METHOD
+
+METHOD TestOnlyOnce
+VAR
+    fbStateSetup: FB_StateSetupHelper;
+    stDefault: ST_PositionState;
+    stTarget: ST_PositionState;
+END_VAR
+TEST('TestOnlyOnce');
+
+// Required call, even though we don't need anything here
+fbStateSetup(stPositionState:=stDefault, bSetDefault:=TRUE);
+// Start with no position
+AssertEquals_LREAL(stTarget.fPosition, 0, 0, 'Start position sanity check failed');
+// Apply a new position
+fbStateSetup(stPositionState:=stTarget, fPosition:=10);
+AssertEquals_LREAL(stTarget.fPosition, 10, 0, 'Basic set position failed');
+// Simulate the position state being used and updated via EPICS or otherwise
+stTarget.bUpdated := TRUE; // Set by FB_PositionStateInternal
+stTarget.fPosition := 12; // Someone tweaked the value in EPICS
+// Run through the state setup again
+fbStateSetup(stPositionState:=stTarget, fPosition:=10);
+// But we should still be at position 12
+AssertEquals_LREAL(stTarget.fPosition, 12, 0, 'FB_StateSetupHelper ran twice!');
+// Unless we override the behavior
+fbStateSetup(stPositionState:=stTarget, bForceUpdate:=TRUE, fPosition:=10);
+AssertEquals_LREAL(stTarget.fPosition, 10, 0, 'bForceUpdate failed');
+
+TEST_FINISHED();
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_StatesInputHandler

+
FUNCTION_BLOCK FB_StatesInputHandler
+(*
+    Handle the state enum EPICS input for any of the ND state function blocks.
+
+    The desired behavior is:
+    - Trigger a move to a new state when the enum PV is written to
+    - Interrupt an ongoing move with a new one if the enum changes mid-move
+    - Stop the move if the enum is set to an invalid value
+*)
+VAR_IN_OUT
+    // The user's inputs from EPICS. This is an IN_OUT variable because we will write values back to this to help us detect when the same value is re-caput
+    stUserInput: ST_StateEpicsToPlc;
+END_VAR
+VAR_INPUT
+    // The bBusy boolean from the motion FB
+    bMoveBusy: BOOL;
+    // The starting state number to seed nCurrGoal with
+    nStartingState: UINT;
+END_VAR
+VAR_OUTPUT
+    // The goal index to input to the motion FB. This will be clamped to the range 0..GeneralConstants.MAX_STATES
+    nCurrGoal: UINT;
+    // The bExecute boolean to input to the motion FB
+    bExecMove: BOOL;
+    // The bReset boolean to input to the motion FB
+    bResetMove: BOOL;
+END_VAR
+VAR
+    nState: UINT;
+    bInit: BOOL;
+    nQueuedGoal: UINT;
+    bNewMove: BOOL;
+END_VAR
+VAR CONSTANT
+    IDLE: UINT := 0;
+    GOING: UINT := 1;
+    WAIT_STOP: UINT := 2;
+END_VAR
+bResetMove := stUserInput.bReset;
+IF bResetMove OR NOT bInit THEN
+    bInit := TRUE;
+    stUserInput.nSetValue := 0;
+    nCurrGoal := nStartingState;
+    bExecMove := FALSE;
+    nState := IDLE;
+    bNewMove := FALSE;
+END_IF
+
+IF stUserInput.nSetValue <> 0 THEN
+    nQueuedGoal := stUserInput.nSetValue;
+    bNewMove := TRUE;
+END_IF
+
+CASE nState OF
+    IDLE:
+        IF bNewMove AND nQueuedGoal > 0 AND nQueuedGoal <= GeneralConstants.MAX_STATES THEN
+            // New request, currently idle -> ask for a move
+            nCurrGoal := nQueuedGoal;
+            bExecMove := TRUE;
+            bNewMove := FALSE;
+        ELSIF bMoveBusy THEN
+            // We're moving but used to be idle -> switch to GOING
+            nState := GOING;
+        END_IF
+    GOING:
+        IF bNewMove THEN
+            // New request, currently moving -> ask for a stop
+            nState := WAIT_STOP;
+            bExecMove := FALSE;
+        ELSIF NOT bMoveBusy THEN
+            nState := IDLE;
+            nQueuedGoal := 0;
+            bExecMove := FALSE;
+        END_IF
+    WAIT_STOP:
+        IF NOT bMoveBusy THEN
+            nState := IDLE;
+        END_IF
+END_CASE
+
+// Help us detect if there is an EPICS put before the next cycle
+stUserInput.nSetValue := 0;
+stUserInput.bReset := FALSE;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_TerminalError

+
FUNCTION_BLOCK FB_TerminalError
+
+VAR_INPUT
+    En                                      : BOOL;
+    iTerminal_ID            : INT;
+    bWcState                        : BOOL;
+    uiInfoData_State        : UINT;
+    pErrorSystem            : POINTER TO ST_ErrorSystem;                                    //Pointer to the error system
+END_VAR
+
+VAR_OUTPUT
+    EnO : BOOL;
+    bError : BOOL := FALSE;
+END_VAR
+
+VAR
+    iStateError : UINT;
+    iOtherError : UINT;
+    ErrorData       : DUT_TerminalError;
+    nErrSysCNT      : UINT;
+
+    //testing
+    bStateChanged : BOOL;                                           //Indicate if state change happened
+    uiInfoData_State_Prev : UINT := 16#8;           //Previous value of Infodata.State
+    bWcState_Prev : BOOL := FALSE;                          //Previous state of WcState
+
+    //FB-s
+
+END_VAR
+(*
+Currently:
+
+Problem:
+
+TODO:
+
+*)
+
+//Connect EN to EnO
+EnO:=En;
+
+//Check if pointer is OK
+IF pErrorSystem=0 THEN RETURN; END_IF
+
+//Any difference from normal state creates an error
+IF En AND (bWcState OR uiInfoData_State<>16#8) THEN
+    bError:=TRUE;
+ELSE
+    bError:=FALSE;
+END_IF
+
+//Change detection
+IF uiInfoData_State <> uiInfoData_State_Prev OR bWcState <> bWcState_Prev THEN
+    bStateChanged := TRUE;
+ELSE
+    bStateChanged := FALSE;
+END_IF
+
+//Update previous values
+uiInfoData_State_Prev := uiInfoData_State;
+bWcState_Prev := bWcState;
+
+//Decision tree
+IF bStateChanged THEN
+    IF bError THEN
+            IF ErrorData.ErrorState = DUT_ErrorState.Active THEN
+                    //Close active error
+                    //Read system time
+                    ErrorData.nDateTimeOff := Tc2_EtherCAT.F_GetActualDcTime64();
+                    ErrorData.sDateTimeOff := Tc2_EtherCat.DCTIME64_TO_STRING(ErrorData.nDateTimeOff);
+                    ErrorData.ErrorState := DUT_ErrorState.Inactive;
+                    //Write Off-time to Error System
+                    FOR nErrSysCNT := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO
+                            IF pErrorSystem^.aErrorData[nErrSysCNT].Error_ID = ErrorData.Error_ID THEN
+                                    pErrorSystem^.aErrorData[nErrSysCNT].nDateTimeOff := ErrorData.nDateTimeOff;
+                                    pErrorSystem^.aErrorData[nErrSysCNT].sDateTimeOff := ErrorData.sDateTimeOff;
+                                    pErrorSystem^.aErrorData[nErrSysCNT].ErrorState := DUT_ErrorState.Inactive;
+                                    EXIT;
+                            END_IF
+                    END_FOR
+
+                    //Clear ErrorData
+                    MEMSET(ADR(ErrorData), 0, SIZEOF(ErrorData));
+            END_IF
+
+            //Open a new error
+            ErrorData.ErrorState := DUT_ErrorState.Active;                                                                                          //Set Error State
+            ErrorData.nDateTimeOn := Tc2_EtherCAT.F_GetActualDcTime64();                                                            //Get system time
+            ErrorData.sDateTimeOn := Tc2_EtherCat.DCTIME64_TO_STRING(ErrorData.nDateTimeOn);                        //Convert to string
+            ErrorData.iTerminalID := iTerminal_ID;                                                                                                          //Terminal_ID
+            ErrorData.bWcState := bWcState;                                                                                                                         //WcState bit
+            ErrorData.uiInfoDataState := uiInfoData_State;                                                                                          //uiInfoData_State
+
+            //Error message according to uiInfoData_State and WcState
+            iStateError := (uiInfoData_State AND 16#000F);                                                                                          //Mask for operation state
+            iOtherError := (uiInfoData_State AND 16#00F0);                                                                                          //Mask for the other 3 kind of errors
+            //Error messages according to the least significant digit
+            CASE iStateError OF
+                    16#0001 : ErrorData.sErrorMessage := 'Slave in INIT state;   ';
+                    16#0002 : ErrorData.sErrorMessage := 'Slave in PREOP state;   ';
+                    16#0003 : ErrorData.sErrorMessage := 'Slave in BOOT state;   ';
+                    16#0004 : ErrorData.sErrorMessage := 'Slave in SAFEOP state;   ';
+                    16#0008 : ;                                                                                                                                                     //Normal operation state
+            ELSE
+                    ErrorData.sErrorMessage := 'Undefined State of operation;   ';                                          //I hope we will never see this message
+                    ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, UINT_TO_STRING(iStateError));
+                    ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, '   ');
+            END_CASE
+
+            //Error messages according to the second least significant digit
+            CASE iOtherError OF
+                    16#0000 : ;                                                                                                                                                     //No error case
+                    16#0010 : ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Slave signals error;   ');
+                    16#0020 : ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Invalid vendorID/productCode read;   ');
+                    16#0040 : ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Initialisation error occured;   ');
+            ELSE
+                    ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Undefined Error ID: ');
+                    ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, UINT_TO_STRING(iOtherError));
+                    ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, '   ');
+            END_CASE
+
+            //Errormessage according to WcState bit
+            IF bWcState THEN
+                    ErrorData.sErrorMessage := CONCAT (ErrorData.sErrorMessage, 'Invalid Data;');
+            END_IF
+
+            //Check for overflow
+            IF pErrorSystem^.nNoErrors = GVL_ErrorSystem.cSizeOfErrorData THEN
+                    pErrorSystem^.nNoOverflows := pErrorSystem^.nNoOverflows+1;
+            END_IF
+
+            //Write Error Data into Error System
+            ErrorData.Error_ID := pErrorSystem^.lNextErrorID ;
+            MEMMOVE( ADR(pErrorSystem^.aErrorData[1]), ADR(pErrorSystem^.aErrorData[0]), (GVL_ErrorSystem.cSizeOfErrorData-1) * SIZEOF(DUT_TerminalError));
+            pErrorSystem^.aErrorData[0] := ErrorData;
+            pErrorSystem^.lNextErrorID := pErrorSystem^.lNextErrorID+1;
+
+    ELSE
+            //Close Active Error
+            //Read system time
+            ErrorData.nDateTimeOff := Tc2_EtherCAT.F_GetActualDcTime64();
+            ErrorData.sDateTimeOff := Tc2_EtherCat.DCTIME64_TO_STRING(ErrorData.nDateTimeOff);
+            ErrorData.ErrorState := DUT_ErrorState.Inactive;
+
+            //Write Off time to Error System
+            FOR nErrSysCNT := 0 TO GVL_ErrorSystem.cSizeOfErrorData - 1 DO
+                    IF pErrorSystem^.aErrorData[nErrSysCNT].Error_ID = ErrorData.Error_ID THEN
+                            pErrorSystem^.aErrorData[nErrSysCNT].nDateTimeOff := ErrorData.nDateTimeOff;
+                            pErrorSystem^.aErrorData[nErrSysCNT].sDateTimeOff := ErrorData.sDateTimeOff;
+                            pErrorSystem^.aErrorData[nErrSysCNT].ErrorState := DUT_ErrorState.Inactive;
+                            EXIT;
+                    END_IF
+            END_FOR
+
+            //Clear ErrorData
+            MEMSET(ADR(ErrorData), 0, SIZEOF(ErrorData));
+    END_IF
+END_IF
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_TestHelperSetAndMove

+
FUNCTION_BLOCK FB_TestHelperSetAndMove
+(*
+    Set an stMotionStage to a start position, then cause a move.
+    On rising edge of bExecute, errors are cleared, the user enable is set to FALSE, and the position is set.
+    After the position is set, user enable is re-introduced and a move begins.
+
+    The progress of this function block for the purposes of a unit test can be monitored via the outputs.
+
+    The motion stage should have its own FB_MotionStage or some stand-in for it running on outside of the FB.
+
+    This is, in itself, tested in FB_TestHelperSetAndMove_Test.
+*)
+VAR_IN_OUT
+    // The motion state to test with
+    stMotionStage: ST_MotionStage;
+END_VAR
+VAR_INPUT
+    // Begin on rising edge, stop on falling edge.
+    bExecute: BOOL;
+    // The position to set the motor to
+    fStartPosition: LREAL;
+    // The goal to move the motor towards
+    fGoalPosition: LREAL;
+    // The velocity to move at
+    fVelocity: LREAL;
+    // If TRUE, we'll set all the hardware enable signals. Leave this as FALSE if your testing involves any of the hardware enables.
+    bHWEnable: BOOL;
+END_VAR
+VAR_OUTPUT
+    // Goes to TRUE once the motor has no errors and is deactivated.
+    bResetDone: BOOL;
+    // Goes to TRUE once the set position completes.
+    bSetDone: BOOL;
+    // Goes to TRUE once the motor begins moving.
+    bMotionStarted: BOOL;
+    // Goes to TRUE once the motor reaches its destination.
+    bMoveDone: BOOL;
+    // If bBusy is FALSE, the function block is ready for a new request. Goes to TRUE after bExecute rises and back to FALSE after bMoveDone or bError rises. Also goes to FALSE after the motor stops following bExecute being dropped to FALSE.
+    bBusy: BOOL;
+    // Goes to TRUE in case of an error from FB_MotionRequest
+    bError: BOOL;
+    // Counts up from bExecute's rising trigger. Can be used to implement a timeout.
+    tElapsed: TIME;
+    // Current motor position in case you're looking for it
+    fActPosition: LREAL;
+    // Goes to TRUE if we're trying to stop a move. We'll stop an in-progress move when bExecute goes to FALSE, and we'll make sure the motor fully stops before responding to the next bExecute rising edge.
+    bStoppingMotor: BOOL;
+END_VAR
+VAR
+    fbMoveRequest: FB_MotionRequest;
+    mcSetPos: MC_SetPosition;
+    tonTimeout: TON;
+    rtExec: R_TRIG;
+    ftExec: F_TRIG;
+    bExecQueued: BOOL;
+    nLatchError: UDINT;
+END_VAR
+tonTimeout(
+    IN:=bExecute,
+    PT:=T#1h,
+    ET=>tElapsed,
+);
+rtExec(CLK:=bExecute);
+ftExec(CLK:=bExecute);
+
+// Set the outputs to known values on exec
+bResetDone R= rtExec.Q;
+bSetDone R= rtExec.Q;
+bMotionStarted R= rtExec.Q;
+bMoveDone R= rtExec.Q;
+bBusy S= rtExec.Q;
+bError R= rtExec.Q;
+
+bExecQueued S= rtExec.Q;
+bExecQueued R= ftExec.Q;
+bStoppingMotor S= ftExec.Q;
+
+// Set the hardware enables if asked
+IF bHWEnable THEN
+    stMotionStage.bLimitForwardEnable := TRUE;
+    stMotionStage.bLimitBackwardEnable := TRUE;
+    stMotionStage.bHardwareEnable := TRUE;
+    stMotionStage.bPowerSelf := TRUE;
+END_IF
+
+
+// Note that we only reset if it's needed, e.g. the motor has an error or is enabled or moving etc. etc.
+bResetDone S= stMotionStage.bError = FALSE AND stMotionStage.bBusy = FALSE AND stMotionStage.bAllEnable = FALSE;
+
+// All uses of fbMoveRequest are in this IF/ELSE tree
+IF bStoppingMotor THEN
+    // Continue stopping the motor from previous cycles
+    fbMoveRequest(
+        stMotionStage:=stMotionStage,
+        bExecute:=FALSE,
+    );
+    stMotionStage.bExecute := FALSE;
+    bStoppingMotor R= NOT stMotionStage.Axis.Status.ControlLoopClosed AND NOT fbMoveRequest.bBusy;
+ELSIF bExecQueued THEN
+    // First exec cycle: bring these to FALSE for later use
+    bExecQueued := FALSE;
+    stMotionStage.bUserEnable := FALSE;
+    fbMoveRequest(
+        stMotionStage:=stMotionStage,
+        bExecute:=FALSE,
+        bReset:=FALSE,
+    );
+ELSIF NOT bResetDone THEN
+    // Other cycles: reset until we're done resetting
+    fbMoveRequest(
+        stMotionStage:=stMotionStage,
+        bReset:=bExecute,
+    );
+ELSIF fStartPosition <> fGoalPosition THEN
+    // Later: do the move
+    // Important to not enable the motor until the set position is done
+    stMotionStage.bUserEnable := bSetDone;
+    fbMoveRequest(
+        stMotionStage:=stMotionStage,
+        bExecute:=bSetDone AND bExecute AND NOT bMoveDone AND NOT bError,
+        bReset:=FALSE,
+        enumMotionRequest:=E_MotionRequest.INTERRUPT,
+        fPos:=fGoalPosition,
+        fVel:=fVelocity,
+    );
+    bMotionStarted S= bSetDone AND fbMoveRequest.bExecute AND stMotionStage.bBusy AND stMotionStage.stAxisStatus.fActPosition <> fStartPosition;
+    bMoveDone S= bMotionStarted AND stMotionStage.stAxisStatus.fActPosition = fGoalPosition;
+END_IF
+
+// Set the position prior to the move but after the reset.
+mcSetPos(
+    Axis:=stMotionStage.Axis,
+    Execute:=bResetDone AND bExecute AND NOT bSetDone AND NOT bError,
+    Position:=fStartPosition,
+);
+IF mcSetPos.Done OR mcSetPos.Error THEN
+    nLatchError := mcSetPos.ErrorID;
+END_IF
+bSetDone S= mcSetPos.Done AND NOT mcSetPos.Error AND stMotionStage.stAxisStatus.fActPosition = fStartPosition;
+
+// Any sub-error is an error here
+bError := fbMoveRequest.bError OR mcSetPos.Error;
+
+// Reset bBusy when appropriate
+bBusy R= (bMoveDone AND NOT bStoppingMotor) OR bError OR ftExec.Q;
+
+// Extract the motor position
+fActPosition := stMotionStage.stAxisStatus.fActPosition;
+
+END_FUNCTION_BLOCK
+
+
+
+
Related:
+
+
+
+
+

FB_TestHelperSetAndMove_Test

+
FUNCTION_BLOCK FB_TestHelperSetAndMove_Test EXTENDS TcUnit.FB_TestSuite
+(*
+    Ensure that the test helper function block works as needed.
+    Without this, all tests that need motion cannot pass.
+*)
+VAR
+    stMotionStage: ST_MotionStage;
+    fbMotionStage: FB_MotionStage;
+    fbTestMove: FB_TestHelperSetAndMove;
+    rtResetDone: R_TRIG;
+    rtSetDone: R_TRIG;
+    rtMotionStart: R_TRIG;
+    rtMoveDone: R_TRIG;
+END_VAR
+fbMotionStage(stMotionStage:=stMotionstage);
+BasicMotion();
+
+END_FUNCTION_BLOCK
+
+METHOD PRIVATE BasicMotion
+VAR_INPUT
+END_VAR
+TEST('BasicMotion');
+
+IF NOT fbTestMove.bExecute THEN
+    stMotionStage.bError := TRUE;
+END_IF
+fbTestMove(
+    stMotionStage:=stMotionStage,
+    bExecute:=TRUE,
+    fStartPosition:=15.0,
+    fGoalPosition:=17.0,
+    fVelocity:=1.0,
+    bHWEnable:=TRUE,
+);
+rtResetDone(CLK:=fbTestMove.bResetDone);
+rtSetDone(CLK:=fbTestMove.bSetDone);
+rtMotionStart(CLK:=fbTestMove.bMotionStarted);
+rtMoveDone(CLK:=fbTestMove.bMoveDone);
+IF rtResetDone.Q THEN
+    AssertFalse(
+        Condition:=stMotionStage.bError,
+        Message:='Reset did not clear error',
+    );
+    AssertEquals_LREAL(
+        Expected:=stMotionStage.stAxisStatus.fActPosition,
+        Actual:=fbTestMove.fActPosition,
+        Delta:=0,
+        Message:='Real position output does not match real position.',
+    );
+END_IF
+IF rtSetDone.Q THEN
+    AssertEquals_LREAL(
+        Expected:=fbTestMove.fStartPosition,
+        Actual:=fbTestMove.fActPosition,
+        Delta:=0,
+        Message:='Was not set to start position after set done',
+    );
+END_IF
+IF rtMotionStart.Q THEN
+    AssertTrue(
+        Condition:=stMotionStage.bBusy,
+        Message:='stMotionStage is not busy, but motion is said to have started.',
+    );
+    AssertTrue(
+        Condition:=fbTestMove.fActPosition > fbTestMove.fStartPosition,
+        Message:='stMotionStage has not moved, but motion is said to have started.',
+    );
+END_IF
+IF rtMoveDone.Q THEN
+    AssertEquals_LREAL(
+        Expected:=fbTestMove.fGoalPosition,
+        Actual:=fbTestMove.fActPosition,
+        Delta:=0.001,
+        Message:='Did not reach destination at move done',
+    );
+END_IF
+IF fbTestMove.bError OR fbTestMove.tElapsed > T#5s OR (fbTestMove.bResetDone AND fbTestMove.bSetDone AND fbTestMove.bMotionStarted AND fbTestMove.bMoveDone) THEN
+    AssertFalse(
+        Condition:=fbTestMove.bError,
+        Message:='Error in fbTestMove',
+    );
+    AssertFalse(
+        Condition:=fbTestMove.tElapsed > T#5s,
+        Message:='Timeout in basic motion test',
+    );
+    TEST_FINISHED();
+END_IF
+END_METHOD
+
+
+
+
Related:
+
+
+
+
+

FB_WriteFloatParameter

+
///#########################################################
+///Function block to write parameter in Nc.
+///
+/// Library:
+/// Tc2_MC2.lib
+/// Tc2_System.lib
+///
+/// Global Variables:
+///
+/// Data types:
+///
+/// External functions:
+///
+/// History:
+/// 2014-02-05      v1.00   NB      Release code.
+///
+/// Known bugs:
+///
+///
+///
+///###########################################################
+FUNCTION_BLOCK FB_WriteFloatParameter
+VAR_INPUT
+    bExecute: BOOL;
+    ///16#4000=Axisdata, 16#5000=Encoderdata, 16#6000=Controldata, 16#7000=Drivedata
+    nDeviceGroup: UDINT;
+    nIndexOffset: UDINT;
+    nData: LREAL;
+END_VAR
+VAR_OUTPUT
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR
+    nState: UINT;
+    fbADSWRITE: ADSWRITE;
+END_VAR
+(*Sequence to write parameter in Nc*)
+CASE nState OF
+0:  (*Start sequence. Wait until bExecute is TRUE*)
+    IF bExecute THEN
+            bBusy:=TRUE;
+            bError:=FALSE;
+            nErrorId:=0;
+            nState:=10;
+    END_IF
+
+10: (*Write parameter in Nc*)
+    fbADSWRITE(
+            PORT:=500,
+            IDXGRP:=nDeviceGroup+Axis.NcToPlc.AxisId,
+            IDXOFFS:=nIndexOffset,
+            LEN:=SIZEOF(nData),
+            SRCADDR:=ADR(nData),
+            WRITE:=TRUE);
+
+    (*Wait until it's done or if an error occurs*)
+    IF NOT fbADSWRITE.ERR THEN
+            IF NOT fbADSWRITE.BUSY THEN
+                    fbADSWRITE(WRITE:=FALSE);
+                    nState:=20;
+            END_IF
+    ELSE
+            nErrorId:=fbADSWRITE.ERRID;
+            nState:=999;
+    END_IF
+
+20: (*Sequense is done. Waits until bExecute is FALSE*)
+    bBusy:=FALSE;
+    bDone:=TRUE;
+    IF NOT bExecute THEN
+            bDone:=FALSE;
+            nState:=0;
+    END_IF
+
+999: (*Error in sequence*)
+    bError:=TRUE;
+    bBusy:=FALSE;
+    bDone:=FALSE;
+    fbADSWRITE(WRITE:=FALSE);
+    IF NOT bExecute THEN
+            nState:=0;
+    END_IF
+
+END_CASE
+
+END_FUNCTION_BLOCK
+
+
+
+
+

FB_WriteParameterInNc_v1_00

+
///#########################################################
+///Function block to write parameter in Nc.
+///
+/// Library:
+/// Tc2_MC2.lib
+/// Tc2_System.lib
+///
+/// Global Variables:
+///
+/// Data types:
+///
+/// External functions:
+///
+/// History:
+/// 2014-02-05      v1.00   NB      Release code.
+///
+/// Known bugs:
+///
+///
+///
+///###########################################################
+FUNCTION_BLOCK FB_WriteParameterInNc_v1_00
+VAR_INPUT
+    bExecute: BOOL;
+    ///16#4000=Axisdata, 16#5000=Encoderdata, 16#6000=Controldata, 16#7000=Drivedata
+    nDeviceGroup: UDINT;
+    nIndexOffset: UDINT;
+    nData: DWORD;
+END_VAR
+VAR_OUTPUT
+    bBusy: BOOL;
+    bDone: BOOL;
+    bError: BOOL;
+    nErrorId: UDINT;
+END_VAR
+VAR_IN_OUT
+    Axis: AXIS_REF;
+END_VAR
+VAR
+    nState: UINT;
+    fbADSWRITE: ADSWRITE;
+END_VAR
+(*Sequence to write parameter in Nc*)
+CASE nState OF
+0:  (*Start sequence. Wait until bExecute is TRUE*)
+    IF bExecute THEN
+            bBusy:=TRUE;
+            bError:=FALSE;
+            nErrorId:=0;
+            nState:=10;
+    END_IF
+
+10: (*Write parameter in Nc*)
+    fbADSWRITE(
+            PORT:=500,
+            IDXGRP:=nDeviceGroup+Axis.NcToPlc.AxisId,
+            IDXOFFS:=nIndexOffset,
+            LEN:=SIZEOF(nData),
+            SRCADDR:=ADR(nData),
+            WRITE:=TRUE);
+
+    (*Wait until it's done or if an error occurs*)
+    IF NOT fbADSWRITE.ERR THEN
+            IF NOT fbADSWRITE.BUSY THEN
+                    fbADSWRITE(WRITE:=FALSE);
+                    nState:=20;
+            END_IF
+    ELSE
+            nErrorId:=fbADSWRITE.ERRID;
+            nState:=999;
+    END_IF
+
+20: (*Sequense is done. Waits until bExecute is FALSE*)
+    bBusy:=FALSE;
+    bDone:=TRUE;
+    IF NOT bExecute THEN
+            bDone:=FALSE;
+            nState:=0;
+    END_IF
+
+999: (*Error in sequence*)
+    bError:=TRUE;
+    bBusy:=FALSE;
+    bDone:=FALSE;
+    fbADSWRITE(WRITE:=FALSE);
+    IF NOT bExecute THEN
+            nState:=0;
+    END_IF
+
+END_CASE
+
+END_FUNCTION_BLOCK
+
+
+
+
+

PRG_TEST

+
PROGRAM PRG_TEST
+VAR
+    fb_TestHelperSetAndMove_Test: FB_TestHelperSetAndMove_Test;
+    fb_AtPositionState_Test: FB_AtPositionState_Test;
+    fb_PositionStateRead_Test: FB_PositionStateRead_Test;
+    fb_PositionStateReadND_Test: FB_PositionStateReadND_Test;
+    fb_PositionStateMove_Test: FB_PositionStateMove_Test;
+    fb_PositionStateMoveND_Test: FB_PositionStateMoveND_Test;
+    fb_PositionStateND_Test: FB_PositionStateND_Test;
+    fb_NCErrorFFO_Test: FB_NCErrorFFO_Test;
+    fb_MiscStatesErrorFFO_Test: FB_MiscStatesErrorFFO_Test;
+    fb_MotionBPTM_Test: FB_MotionBPTM_Test;
+    fb_MotionClearAsserts_Test: FB_MotionClearAsserts_Test;
+    fb_StatePMPSEnables_Test: FB_StatePMPSEnables_Test;
+    fb_MotionReadPMPSDBND_Test: FB_MotionReadPMPSDBND_Test;
+    fb_PerMotorFFOND_Test: FB_PerMotorFFOND_Test;
+    fb_StatePMPSEnablesND_Test: FB_StatePMPSEnablesND_Test;
+    fb_PositionStatePMPSND_Test: FB_PositionStatePMPSND_Test;
+    fb_StateSetupHelper_Test: FB_StateSetupHelper_Test;
+END_VAR
+TcUnit.RUN();
+
+END_PROGRAM
+
+
+
+
Related:
+
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/lcls-twincat-motion_Library_summary.html b/v4.0.3/lcls-twincat-motion_Library_summary.html new file mode 100644 index 00000000..7fad7b08 --- /dev/null +++ b/v4.0.3/lcls-twincat-motion_Library_summary.html @@ -0,0 +1,225 @@ + + + + + + + Settings — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Settings

+ + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Description

AMS Net ID

172.21.148.148.1.1

Target IP address

172.21.148.148

Based on AMS Net ID by convention

AMS Port

851

+
+
+

Pragmas

+

Total pragmas found: 190 +Total linter errors: 0

+
+
+

Libraries

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Library

Vendor

Default

Version

LCLS General

SLAC

Unset

Unset

PMPS

SLAC - LCLS

Unset

Unset

Tc2_EtherCAT

Beckhoff Automation GmbH

Unset

Unset

Tc2_Math

Beckhoff Automation GmbH

Unset

Unset

Tc2_MC2

Beckhoff Automation GmbH

Unset

Unset

Tc2_Standard

Beckhoff Automation GmbH

Unset

Unset

Tc2_System

Beckhoff Automation GmbH

Unset

Unset

Tc2_Utilities

Beckhoff Automation GmbH

Unset

Unset

Tc3_JsonXml

Beckhoff Automation GmbH

Unset

Unset

Tc3_Module

Beckhoff Automation GmbH

Unset

Unset

TcUnit

www.tcunit.org

Unset

Unset

+
+
+

Symbols

+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/lcls-twincat-motion_boxes.html b/v4.0.3/lcls-twincat-motion_boxes.html new file mode 100644 index 00000000..0a1c9747 --- /dev/null +++ b/v4.0.3/lcls-twincat-motion_boxes.html @@ -0,0 +1,126 @@ + + + + + + + Boxes — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Boxes

+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/lcls-twincat-motion_ethercat.html b/v4.0.3/lcls-twincat-motion_ethercat.html new file mode 100644 index 00000000..3a8e96e9 --- /dev/null +++ b/v4.0.3/lcls-twincat-motion_ethercat.html @@ -0,0 +1,126 @@ + + + + + + + Box Hierarchy — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Box Hierarchy

+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/lcls-twincat-motion_links.html b/v4.0.3/lcls-twincat-motion_links.html new file mode 100644 index 00000000..6ce60f65 --- /dev/null +++ b/v4.0.3/lcls-twincat-motion_links.html @@ -0,0 +1,347 @@ + + + + + + + Links — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ + + + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/lcls-twincat-motion_nc.html b/v4.0.3/lcls-twincat-motion_nc.html new file mode 100644 index 00000000..cc422ead --- /dev/null +++ b/v4.0.3/lcls-twincat-motion_nc.html @@ -0,0 +1,937 @@ + + + + + + + NC Settings — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

NC Settings

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Axis ID

Name

3

Axis_PositionStateRead_Test

4

Axis_AtPositionState_Test

5

Axis_TestHelperSetAndMove_Test

6

Axis_PositionStateReadND_Test_1

7

Axis_PositionStateReadND_Test_2

8

Axis_PositionStateReadND_Test_3

9

Axis_PositionStateMove_Test

10

Axis_PositionStateMoveND_Test_1

11

Axis_PositionStateMoveND_Test_2

12

Axis_PositionStateMoveND_Test_3

13

Axis_PositionStateND_Test_1

14

Axis_PositionStateND_Test_2

15

Axis_PositionStateND_Test_3

16

Axis_NCErrorFFO_Test

17

Axis_PositionStatePMPSND_Test_1

18

Axis_PositionStatePMPSND_Test_2

19

Axis_PositionStatePMPSND_Test_3

20

Axis_StatePMPSEnable_Test

21

Axis_PositionStateReadND_Test_4

22

Axis_PositionStateReadND_Test_5

+
+

Axis 3: Axis_PositionStateRead_Test

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

3

Name

Axis_PositionStateRead_Test

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

3

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 4: Axis_AtPositionState_Test

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

4

Name

Axis_AtPositionState_Test

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

4

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 5: Axis_TestHelperSetAndMove_Test

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

5

Name

Axis_TestHelperSetAndMove_Test

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

5

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 6: Axis_PositionStateReadND_Test_1

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

6

Name

Axis_PositionStateReadND_Test_1

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

6

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 7: Axis_PositionStateReadND_Test_2

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

7

Name

Axis_PositionStateReadND_Test_2

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

7

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 8: Axis_PositionStateReadND_Test_3

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

8

Name

Axis_PositionStateReadND_Test_3

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

8

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 9: Axis_PositionStateMove_Test

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

9

Name

Axis_PositionStateMove_Test

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

9

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 10: Axis_PositionStateMoveND_Test_1

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

10

Name

Axis_PositionStateMoveND_Test_1

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

10

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 11: Axis_PositionStateMoveND_Test_2

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

11

Name

Axis_PositionStateMoveND_Test_2

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

11

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 12: Axis_PositionStateMoveND_Test_3

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

12

Name

Axis_PositionStateMoveND_Test_3

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

12

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 13: Axis_PositionStateND_Test_1

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

13

Name

Axis_PositionStateND_Test_1

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

13

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 14: Axis_PositionStateND_Test_2

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

14

Name

Axis_PositionStateND_Test_2

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

14

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 15: Axis_PositionStateND_Test_3

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

15

Name

Axis_PositionStateND_Test_3

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

15

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 16: Axis_NCErrorFFO_Test

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

16

Name

Axis_NCErrorFFO_Test

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

16

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 17: Axis_PositionStatePMPSND_Test_1

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

17

Name

Axis_PositionStatePMPSND_Test_1

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

17

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 18: Axis_PositionStatePMPSND_Test_2

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

18

Name

Axis_PositionStatePMPSND_Test_2

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

18

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 19: Axis_PositionStatePMPSND_Test_3

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

19

Name

Axis_PositionStatePMPSND_Test_3

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

19

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 20: Axis_StatePMPSEnable_Test

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

20

Name

Axis_StatePMPSEnable_Test

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

20

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 21: Axis_PositionStateReadND_Test_4

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

21

Name

Axis_PositionStateReadND_Test_4

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

21

OtherSettings:AllowMotionCmdToSlave

true

+
+
+

Axis 22: Axis_PositionStateReadND_Test_5

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Setting

Value

Axis ID

22

Name

Axis_PositionStateReadND_Test_5

AxisFolder

Unit Test Axes

AxisType

1

CreateSymbols

true

Enc:EncType

1

Id

22

OtherSettings:AllowMotionCmdToSlave

true

+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/lcls-twincat-motion_pragmas.html b/v4.0.3/lcls-twincat-motion_pragmas.html new file mode 100644 index 00000000..fd9cd403 --- /dev/null +++ b/v4.0.3/lcls-twincat-motion_pragmas.html @@ -0,0 +1,148 @@ + + + + + + + Pragmas — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Pragmas

+ + + + + + + + + + + + + +

PLC Name

Total Pragmas

Errors

Library

190

0

+
+

Library

+

Total pragmas found: 190 +Total linter errors: 0

+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/v4.0.3/objects.inv b/v4.0.3/objects.inv new file mode 100644 index 00000000..b4a985ad --- /dev/null +++ b/v4.0.3/objects.inv @@ -0,0 +1,5 @@ +# Sphinx inventory version 2 +# Project: pcdshub/lcls-twincat-motion +# Version: +# The remainder of this file is compressed using zlib. +xڍMo0 H;gҮ;n=lR7!;W!X-( m05܈dHB_HϭW|Nf/ D+Q3O";Ee ֬g4t-|T Wjf?M@en}YL`su |J"$'3I<_Q,U!C!?2 lY)`hЈ 3ٍO R&R- 4_%U^E3i[&//Y \ No newline at end of file diff --git a/v4.0.3/search.html b/v4.0.3/search.html new file mode 100644 index 00000000..f0dc3aa0 --- /dev/null +++ b/v4.0.3/search.html @@ -0,0 +1,137 @@ + + + + + + Search — pcdshub/lcls-twincat-motion documentation + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Search
    • +
  • +
    • +
+
+
+
+
+ + + + +
+ +
+ +
+
+
+ +
+ +
+

© Copyright 2023, SLAC National Accelerator Laboratory.

+
+ + Built with Sphinx using a + theme + provided by Read the Docs. + + +
+
+
+
+
+ + + + + + + + + \ No newline at end of file diff --git a/v4.0.3/searchindex.js b/v4.0.3/searchindex.js new file mode 100644 index 00000000..dc6e1f17 --- /dev/null +++ b/v4.0.3/searchindex.js @@ -0,0 +1 @@ +Search.setIndex({"docnames": ["index", "lcls-twincat-motion_Library_epics", "lcls-twincat-motion_Library_source", "lcls-twincat-motion_Library_summary", "lcls-twincat-motion_boxes", "lcls-twincat-motion_ethercat", "lcls-twincat-motion_links", "lcls-twincat-motion_nc", "lcls-twincat-motion_pragmas"], "filenames": ["index.rst", "lcls-twincat-motion_Library_epics.rst", "lcls-twincat-motion_Library_source.rst", "lcls-twincat-motion_Library_summary.rst", "lcls-twincat-motion_boxes.rst", "lcls-twincat-motion_ethercat.rst", "lcls-twincat-motion_links.rst", "lcls-twincat-motion_nc.rst", "lcls-twincat-motion_pragmas.rst"], "titles": ["lcls-twincat-motion", "Data Types", "DUTs", "Settings", "Boxes", "Box Hierarchy", "Links", "NC Settings", "Pragmas"], "terms": {"pragma": [0, 2], "nc": [0, 2, 6], "set": [0, 2], "axi": [0, 2, 6], "3": [0, 2, 6], "axis_positionstateread_test": [0, 6], "4": [0, 2], "axis_atpositionstate_test": [0, 6], "5": [0, 2], "axis_testhelpersetandmove_test": [0, 6], "6": [0, 2], "axis_positionstatereadnd_test_1": [0, 6], "7": [0, 2], "axis_positionstatereadnd_test_2": [0, 6], "8": [0, 2], "axis_positionstatereadnd_test_3": [0, 6], "9": [0, 2], "axis_positionstatemove_test": [0, 6], "10": [0, 2], "axis_positionstatemovend_test_1": [0, 6], "11": [0, 2], "axis_positionstatemovend_test_2": [0, 6], "12": [0, 2], "axis_positionstatemovend_test_3": [0, 6], "13": 0, "axis_positionstatend_test_1": [0, 6], "14": 0, "axis_positionstatend_test_2": [0, 6], "15": [0, 2], "axis_positionstatend_test_3": [0, 6], "16": [0, 2], "axis_ncerrorffo_test": [0, 6], "17": [0, 2], "axis_positionstatepmpsnd_test_1": [0, 6], "18": 0, "axis_positionstatepmpsnd_test_2": [0, 6], "19": [0, 2], "axis_positionstatepmpsnd_test_3": [0, 6], "20": [0, 2], "axis_statepmpsenable_test": [0, 6], "21": [0, 2, 3], "axis_positionstatereadnd_test_4": [0, 6], "22": 0, "axis_positionstatereadnd_test_5": [0, 6], "box": 0, "hierarchi": 0, "link": [0, 2], "symbol": 0, "data": [0, 2], "type": [0, 2], "databas": [0, 2], "record": [0, 2], "dut": 0, "dut_axisstatus_v0_01": 0, "dut_errorst": 0, "dut_motionpneumaticactu": 0, "dut_motionstag": 0, "dut_positionst": 0, "dut_terminalerror": 0, "dutel2521_ctrl": 0, "dutel2521_statu": 0, "e_epicshomecmd": 0, "e_epicsinout": 0, "e_epicsmotorcmd": 0, "e_motionfftyp": 0, "e_motionrequest": 0, "e_pnuematicactuatorpositionst": 0, "e_stagebrakemod": 0, "e_stageenablemod": 0, "e_statepmpsstatu": 0, "e_testst": 0, "el5042_statu": 0, "enum_epicshomecmd": 0, "enum_epicsinout": 0, "enum_epicsinout_int": 0, "enum_epicsmotorcmd": 0, "enum_motionfftyp": 0, "enum_motionrequest": 0, "enum_pnuematicactuatorpositionst": 0, "enum_stagebrakemod": 0, "enum_stageenablemod": 0, "enum_statepmpsstatu": 0, "st_el5042_statu": 0, "st_errorsystem": 0, "st_motionpneumaticactu": 0, "st_motionstag": 0, "st_positionst": 0, "st_renishawabsenc": 0, "st_stateepicstoplc": 0, "st_stateplctoep": 0, "st_statepmpsepicstoplc": 0, "st_statepmpsplctoep": 0, "gvl": 0, "global_vers": 0, "gvl_errorsystem": 0, "motion_gvl": 0, "motionconst": 0, "pou": 0, "checkbound": 0, "checkdivdint": 0, "checkdivlint": 0, "checkdivlr": 0, "checkdivr": 0, "ek1200": 0, "el1008": 0, "el1018": 0, "el1808": 0, "el1809": 0, "el1819": 0, "el2014": 0, "el2252": 0, "el2808": 0, "el2819": 0, "el3174_0002": 0, "el3214": 0, "el3255": 0, "el5002": 0, "el5021": 0, "el5042": 0, "el5101": 0, "el7211_v1_00": 0, "el9410": 0, "el9505": 0, "el9576_v1_00": 0, "f_atpositionst": 0, "f_motionerrorcodelookup": 0, "f_posoverlowerbound": 0, "f_posunderupperbound": 0, "f_poswithindelta": 0, "fb_atpositionstate_test": [0, 6], "fb_calculatefrequency_3702_v0_01": 0, "fb_causencerror": 0, "fb_drivevirtu": 0, "fb_el1252asm_v1_00": 0, "fb_encerrorffo": 0, "fb_encodervalu": 0, "fb_encsaverestor": 0, "fb_epicsinout": 0, "fb_errorlist": 0, "fb_gantryautocoupl": 0, "fb_gantrydiffvirtuallimitswitch": 0, "fb_homedirect": 0, "fb_homefinish": 0, "fb_homeprepar": 0, "fb_homereadncveloc": 0, "fb_homereadsoftlimen": 0, "fb_hometoswitch": 0, "fb_homevirtu": 0, "fb_homewritencveloc": 0, "fb_homewritesoftlimen": 0, "fb_logmotionerror": 0, "fb_microstepcounttest": 0, "fb_miscstateserrorffo": 0, "fb_miscstateserrorffo_test": 0, "fb_motionbptm": 0, "fb_motionbptm_test": 0, "fb_motionclearassert": 0, "fb_motionclearasserts_test": 0, "fb_motionhom": 0, "fb_motionpneumaticactu": 0, "fb_motionreadpmpsdbnd": 0, "fb_motionreadpmpsdbnd_test": 0, "fb_motionrequest": 0, "fb_motionstag": 0, "fb_motionstagencparam": 0, "fb_motionstagesim": 0, "fb_motortestsuit": 0, "fb_ncaxi": 0, "fb_ncerrorffo": 0, "fb_ncerrorffo_test": [0, 6], "fb_permotorffond": 0, "fb_permotorffond_test": 0, "fb_pmpsjsontesthelp": 0, "fb_positionstate1d": 0, "fb_positionstate1d_inout": 0, "fb_positionstate2d": 0, "fb_positionstate2d_inout": 0, "fb_positionstate3d": 0, "fb_positionstatebas": 0, "fb_positionstatebase_withpmp": 0, "fb_positionstatebase_withpmps_test": 0, "fb_positionstateinout": 0, "fb_positionstateinout_withpmp": 0, "fb_positionstateinout_withpmps_test": 0, "fb_positionstateintern": 0, "fb_positionstateinternalnd": 0, "fb_positionstatelock": 0, "fb_positionstatemanag": 0, "fb_positionstatemov": 0, "fb_positionstatemove_test": [0, 6], "fb_positionstatemovend": 0, "fb_positionstatemovend_test": [0, 6], "fb_positionstatend_cor": 0, "fb_positionstatend_test": [0, 6], "fb_positionstatepmp": 0, "fb_positionstatepmps1d": 0, "fb_positionstatepmps1d_inout": 0, "fb_positionstatepmps2d": 0, "fb_positionstatepmps2d_inout": 0, "fb_positionstatepmps3d": 0, "fb_positionstatepmps_bas": 0, "fb_positionstatepmps_test": 0, "fb_positionstatepmpsnd_cor": 0, "fb_positionstatepmpsnd_test": [0, 6], "fb_positionstateread": 0, "fb_positionstateread_test": [0, 6], "fb_positionstatereadnd": 0, "fb_positionstatereadnd_test": [0, 6], "fb_rawcountconvert": 0, "fb_readfloatparamet": 0, "fb_readparameterinnc_v1_00": 0, "fb_seten": 0, "fb_standard_pmpsdb": 0, "fb_statepmpsen": 0, "fb_statepmpsenables_test": [0, 6], "fb_statepmpsenablesnd": 0, "fb_statepmpsenablesnd_test": 0, "fb_stateptpmov": 0, "fb_statesetuphelp": 0, "fb_statesetuphelper_test": 0, "fb_statesinputhandl": 0, "fb_terminalerror": 0, "fb_testhelpersetandmov": 0, "fb_testhelpersetandmove_test": [0, 6], "fb_writefloatparamet": 0, "fb_writeparameterinnc_v1_00": 0, "prg_test": [0, 6], "index": [0, 2], "modul": 0, "search": [0, 2], "page": 0, "pcdshub": [0, 1, 2, 3, 4, 5, 6, 7, 8], "No": [1, 2], "defin": [1, 2], "lcl": [1, 2, 3, 4, 5, 6, 7, 8], "twincat": [1, 2, 3, 4, 5, 6, 7, 8], "motion": [1, 2, 3, 4, 5, 6, 7, 8], "struct": 2, "benabl": 2, "bool": 2, "breset": 2, "bexecut": 2, "ncommand": 2, "uint": 2, "ncmddata": 2, "fveloc": 2, "lreal": 2, "fposit": 2, "facceler": 2, "fdeceler": 2, "bjogfwd": 2, "bjogbwd": 2, "blimitfwd": 2, "blimitbwd": 2, "foverrid": 2, "100": 2, "bhomesensor": 2, "berror": 2, "nerrorid": 2, "udint": 2, "factveloc": 2, "factposit": 2, "factdiff": 2, "bhome": 2, "bbusi": 2, "end_struct": 2, "end_typ": 2, "relat": 2, "attribut": 2, "qualified_onli": 2, "strict": 2, "none": 2, "activ": 2, "inact": 2, "acknowledg": 2, "obsolet": 2, "ha": 2, "been": 2, "renam": 2, "error": [2, 3, 8], "system": 2, "iterminalid": 2, "int": 2, "id": [2, 3, 7], "termin": 2, "error_id": 2, "ulint": 2, "0": [2, 3, 8], "entri": 2, "errorst": 2, "state": 2, "ndatetimeon": 2, "date": 2, "time": 2, "when": 2, "occur": 2, "raw": 2, "sdatetimeon": 2, "string": 2, "24": 2, "readabl": 2, "format": 2, "ndatetimeoff": 2, "disapear": 2, "sdatetimeoff": 2, "bwcstate": 2, "wcstate": 2, "variabl": 2, "uiinfodatast": 2, "infodata": 2, "serrormessag": 2, "128": 2, "messag": 2, "correspond": 2, "errortyp": 2, "prioriti": 2, "need": 2, "develop": 2, "The": 2, "control": 2, "word": 2, "cw": 2, "i": 2, "locat": 2, "output": [2, 6], "process": 2, "imag": 2, "transmit": 2, "from": 2, "freq_sel": 2, "0bin": 2, "1bin": 2, "rapid": 2, "chang": 2, "base": [2, 3], "frequenc": 2, "onli": 2, "ramp": 2, "function": 2, "1": [2, 3, 6, 7], "object": 2, "8001": 2, "02": 2, "2": [2, 6], "03": 2, "ramp_di": 2, "oper": 2, "cancel": 2, "spite": 2, "8000": 2, "06": 2, "being": 2, "travel": 2, "distanc": 2, "interrupt": 2, "thi": 2, "bit": 2, "go_count": 2, "If": 2, "0a": 2, "pre": 2, "counter": 2, "valu": [2, 3, 7], "approach": 2, "cnt_clr": 2, "content": 2, "clear": 2, "0b": 2, "ani": 2, "overflow": 2, "underflow": 2, "might": 2, "ar": 2, "also": 2, "can": 2, "edg": 2, "trigger": 2, "level": 2, "05": 2, "statu": 2, "sw": 2, "input": [2, 6], "sel_ack": 2, "end_count": 2, "confirm": 2, "At": 2, "target": [2, 3], "reach": 2, "ramp_act": 2, "current": 2, "follow": 2, "65535": 2, "It": 2, "reset": 2, "drop": 2, "below": 2, "two": 2, "third": 2, "its": 2, "measur": 2, "rang": 2, "43690": 2, "43689": 2, "immedi": 2, "an": 2, "exce": 2, "one": 2, "21845": 2, "21846": 2, "input_t": 2, "input_z": 2, "gener": [2, 3], "includ": 2, "valid": 2, "option": 2, "home": 2, "low_limit": 2, "low": 2, "limit": 2, "switch": 2, "high_limit": 2, "high": 2, "home_via_low": 2, "via": 2, "home_via_high": 2, "absolute_set": 2, "here": 2, "fhomeposit": 2, "do": 2, "ever": 2, "exampl": 2, "epic": 2, "enum": 2, "us": 2, "all": 2, "version": [2, 3], "fb": 2, "remov": 2, "easier": 2, "handl": 2, "unknown": 2, "must": 2, "slot": 2, "break": 2, "out": 2, "convent": [2, 3], "IN": 2, "command": 2, "jog": 2, "move_veloc": 2, "move_rel": 2, "move_absolut": 2, "move_modulo": 2, "gear": 2, "30": 2, "stopper_fault": 2, "1000": 2, "zero_r": 2, "1001": 2, "bptm_timeout": 2, "1002": 2, "bptm_error": 2, "1003": 2, "maint_mod": 2, "1004": 2, "not_a_st": 2, "1005": 2, "invalid_go": 2, "1006": 2, "too_many_trip": 2, "1007": 2, "bp_mismatch": 2, "1008": 2, "internal_error": 2, "1009": 2, "pneumatic_mov": 2, "1010": 2, "mot_gener": 2, "1011": 2, "low_reserved_nc": 2, "2000": 2, "high_reserved_nc": 2, "20ff": 2, "device_mov": 2, "2100": 2, "behavior": 2, "run": 2, "dure": 2, "move": 2, "anoth": 2, "sourc": 2, "wait": 2, "abort": 2, "posit": 2, "pnuemat": 2, "actuat": 2, "retract": 2, "insert": 2, "In": 2, "neither": 2, "invalid": 2, "send": 2, "brake": 2, "disengag": 2, "signal": 2, "if_en": 2, "motor": 2, "enabl": 2, "if_mov": 2, "no_brak": 2, "condit": 2, "automat": 2, "alwai": 2, "true": [2, 7], "never": 2, "during_mot": 2, "befor": 2, "disabl": 2, "after": 2, "other": 2, "describ": 2, "toward": 2, "known": 2, "transit": 2, "within": 2, "try": 2, "leav": 2, "at_stat": 2, "pmp": [2, 3], "some": 2, "wai": 2, "either": 2, "maint": 2, "mode": 2, "arbit": 2, "target1": 2, "target2": 2, "arrai": 2, "size": 2, "csizeoferrordata": 2, "aerrordata": 2, "OF": 2, "lnexterrorid": 2, "errorid": 2, "next": 2, "nnoerror": 2, "number": 2, "list": 2, "nnooverflow": 2, "how": 2, "mani": 2, "have": 2, "lost": 2, "interfac": 2, "pneumat": 2, "stage": 2, "hardwar": 2, "readback": 2, "pytmc": 2, "pv": 2, "plc": [2, 8], "binlimitswitch": 2, "io": 2, "field": 2, "znam": 2, "fals": 2, "onam": 2, "desc": 2, "i_binlimitswitch": 2, "boutlimitswitch": 2, "i_boutlimitswitch": 2, "digit": 2, "bretractdigitaloutput": 2, "q_bretract": 2, "binsertdigitaloutput": 2, "q_binsert": 2, "logic": 2, "supervisori": 2, "binterlockok": 2, "permiss": 2, "direct": 2, "bilk_ok": 2, "binserten": 2, "had": 2, "binsertok": 2, "bretracten": 2, "bretractok": 2, "comand": 2, "cmd": 2, "intern": 2, "request": 2, "binsert_sw": 2, "bretract_sw": 2, "return": 2, "middl": 2, "we": 2, "ve": 2, "done": 2, "finish": 2, "bdone": 2, "successfulli": 2, "re": 2, "code": 2, "nonzero": 2, "identifi": 2, "npositionst": 2, "mbbi": 2, "zrst": 2, "onst": 2, "twst": 2, "thst": 2, "estat": 2, "refer": 2, "axis_ref": 2, "forward": 2, "ok": 2, "blimitforwarden": 2, "AT": 2, "backward": 2, "blimitbackwarden": 2, "NO": 2, "releas": 2, "bbrakereleas": 2, "q": 2, "sto": 2, "bhardwareen": 2, "hit": 2, "encod": 2, "biss": 2, "c": 2, "nrawencoderulint": 2, "rel": 2, "nrawencoderuint": 2, "lvdt": 2, "nrawencoderint": 2, "psuedo": 2, "ep": 2, "summari": 2, "ballforwarden": 2, "ballbackwarden": 2, "encapsul": 2, "emerg": 2, "stop": 2, "button": 2, "addit": 2, "prevent": 2, "ballen": 2, "virtual": 2, "gantri": 2, "bgantryforwarden": 2, "bgantrybackwarden": 2, "count": 2, "abov": 2, "nencodercount": 2, "stepsf": 2, "interlock": 2, "stepsforwarden": 2, "dut_ep": 2, "stepsb": 2, "stepsbackwarden": 2, "power": 2, "stepsp": 2, "stepspoweren": 2, "name": [2, 7, 8], "log": 2, "fast": 2, "fault": 2, "etc": 2, "sname": 2, "want": 2, "independ": 2, "safeti": 2, "bpowerself": 2, "determin": 2, "nenablemod": 2, "nbrakemod": 2, "our": 2, "strategi": 2, "nhomingmod": 2, "bgantryaxi": 2, "differ": 2, "toler": 2, "ngantrytol": 2, "lint": 2, "which": 2, "align": 2, "nencref": 2, "ioc": 2, "start": 2, "buseren": 2, "entir": 2, "shortcut": 2, "bmovecmd": 2, "routin": 2, "bhomecmd": 2, "arg": 2, "pick": 2, "what": 2, "kind": 2, "pass": 2, "destin": 2, "veloc": 2, "acceler": 2, "deceler": 2, "info": 2, "uniqu": 2, "assign": 2, "each": 2, "nmotionaxisid": 2, "benabledon": 2, "doe": 2, "bsafetyreadi": 2, "updat": 2, "100hz": 2, "notifi": 2, "hook": 2, "custom": 2, "scustomerrormessag": 2, "mc_readparameterset": 2, "staxisparamet": 2, "st_axisparameterset": 2, "least": 2, "onc": 2, "baxisparamsinit": 2, "misc": 2, "inform": 2, "staxisstatu": 2, "user": 2, "lag": 2, "fposdiff": 2, "specif": 2, "queri": 2, "associ": 2, "setpoint": 2, "maximum": 2, "allow": 2, "deviat": 2, "while": 2, "fdelta": 2, "speed": 2, "velo": 2, "faccel": 2, "fdecel": 2, "paramet": 2, "program": 2, "expect": 2, "move_ok": 2, "would": 2, "safe": 2, "bmoveok": 2, "signifi": 2, "should": 2, "immut": 2, "block": 2, "you": 2, "make": 2, "your": 2, "default": [2, 3], "so": 2, "uniniti": 2, "bvalid": 2, "buserawcount": 2, "call": 2, "bupdat": 2, "give": 2, "load": 2, "stpmp": 2, "st_dbstateparam": 2, "renishaw": 2, "absolut": 2, "connect": 2, "placehold": 2, "ref": 2, "zero": 2, "structur": 2, "contain": 2, "standard": 2, "point": 2, "mover": 2, "flow": 2, "everyth": 2, "except": 2, "cannot": 2, "applic": 2, "gather": 2, "own": 2, "That": 2, "actual": 2, "mean": 2, "hold": 2, "now": 2, "nsetvalu": 2, "even": 2, "though": 2, "expos": 2, "directli": 2, "avoid": 2, "manual": 2, "modifi": 2, "els": 2, "mai": 2, "interfer": 2, "normal": 2, "For": 2, "end": 2, "match": 2, "prefix": 2, "": 2, "Then": 2, "eenumset": 2, "in_out": 2, "var": 2, "let": 2, "new": 2, "goal": 2, "integ": 2, "written": 2, "get": 2, "ngetvalu": 2, "read": 2, "eenumget": 2, "particular": 2, "otherwis": 2, "busi": 2, "complet": 2, "most": 2, "recent": 2, "err": 2, "exist": 2, "left": 2, "errid": 2, "appropri": 2, "empti": 2, "errmsg": 2, "serrormsg": 2, "arb": 2, "barbiteren": 2, "mainten": 2, "free": 2, "bmaintmod": 2, "present": 2, "tran": 2, "sttransitiondb": 2, "tcgener": 2, "project": 2, "var_glob": 2, "constant": 2, "const_non_replac": 2, "linkalwai": 2, "stlibversion_lcls_twincat_mot": 2, "st_libvers": 2, "imajor": 2, "iminor": 2, "ibuild": 2, "irevis": 2, "sversion": 2, "end_var": 2, "nhomingerror": 2, "14d00": 2, "global": 2, "file": 2, "reader": 2, "instanc": [2, 6], "fbstandardpmpsdb": 2, "fbpmpsfileread": 2, "fb_jsonfiletojsondoc": 2, "db": 2, "handler": 2, "debug": 2, "highest": 2, "nd": 2, "max_state_motor": 2, "save": 2, "memori": 2, "usag": 2, "nmaxstatemotorcount": 2, "generalconst": 2, "max_stat": 2, "nmaxstat": 2, "configur": 2, "These": 2, "reconfigur": 2, "thei": 2, "prior": 2, "compil": 2, "runtim": 2, "arbitari": 2, "cap": 2, "multidimension": 2, "simplifi": 2, "statement": 2, "sure": 2, "per": 2, "check": 2, "implicitli": 2, "NOT": 2, "edit": 2, "dint": 2, "var_input": 2, "lower": 2, "upper": 2, "implement": 2, "suggest": 2, "noflow": 2, "IF": 2, "THEN": 2, "elsif": 2, "end_if": 2, "end_funct": 2, "divisor": 2, "real": 2, "function_block": 2, "en": 2, "var_output": 2, "eno": 2, "end_function_block": 2, "channel": 2, "v": 2, "dc": 2, "m": 2, "iterminal_id": 2, "errorsystem": 2, "pointer": 2, "TO": 2, "bdi_1": 2, "bdi_2": 2, "bdi_3": 2, "bdi_4": 2, "bdi_5": 2, "bdi_6": 2, "bdi_7": 2, "bdi_8": 2, "channel_1_input": 2, "channel_2_input": 2, "channel_3_input": 2, "channel_4_input": 2, "channel_5_input": 2, "channel_6_input": 2, "channel_7_input": 2, "channel_8_input": 2, "wcstate_wcst": 2, "infodata_st": 2, "el1008_error": 2, "uiinfodata_st": 2, "perrorsystem": 2, "\u00b5": 2, "el1018_error": 2, "hd": 2, "ethercat": 2, "wire": 2, "el1808_error": 2, "bdi_9": 2, "bdi_10": 2, "bdi_11": 2, "bdi_12": 2, "bdi_13": 2, "bdi_14": 2, "bdi_15": 2, "bdi_16": 2, "channel_9_input": 2, "channel_10_input": 2, "channel_11_input": 2, "channel_12_input": 2, "channel_13_input": 2, "channel_14_input": 2, "channel_15_input": 2, "channel_16_input": 2, "el1809_error": 2, "el1819_error": 2, "bdo_1": 2, "bdo_2": 2, "bdo_3": 2, "bdo_4": 2, "channel_1_output": 2, "channel_2_output": 2, "channel_3_output": 2, "channel_4_output": 2, "el2014_error": 2, "todo": 2, "diagnost": 2, "devic": 2, "diag": 2, "xfc": 2, "stamp": 2, "tri": 2, "el2252_error": 2, "add": 2, "sync": 2, "bdo_5": 2, "bdo_6": 2, "bdo_7": 2, "bdo_8": 2, "channel_5_output": 2, "channel_6_output": 2, "channel_7_output": 2, "channel_8_output": 2, "el2808_error": 2, "bdo_9": 2, "bdo_10": 2, "bdo_11": 2, "bdo_12": 2, "bdo_13": 2, "bdo_14": 2, "bdo_15": 2, "bdo_16": 2, "channel_9_output": 2, "channel_10_output": 2, "channel_11_output": 2, "channel_12_output": 2, "channel_13_output": 2, "channel_14_output": 2, "channel_15_output": 2, "channel_16_output": 2, "el2819_error": 2, "el3174": 2, "0002": 2, "analog": 2, "10v": 2, "20ma": 2, "differenti": 2, "iai_ch1_valu": 2, "iai_ch2_valu": 2, "iai_ch3_valu": 2, "iai_ch4_valu": 2, "ai_std_ch_1_statu": 2, "ai_std_ch_1_valu": 2, "ai_std_ch_2_statu": 2, "ai_std_ch_2_valu": 2, "ai_std_ch_3_statu": 2, "ai_std_ch_3_valu": 2, "ai_std_ch_4_statu": 2, "ai_std_ch_4_valu": 2, "el3174_0002_error": 2, "pt100": 2, "rtd": 2, "ai_rtd_ch_1_statu": 2, "ai_rtd_ch_1_valu": 2, "ai_rtd_ch_2_statu": 2, "ai_rtd_ch_2_valu": 2, "ai_rtd_ch_3_statu": 2, "ai_rtd_ch_3_valu": 2, "ai_rtd_ch_4_statu": 2, "ai_rtd_ch_4_valu": 2, "el3214_error": 2, "potentiomet": 2, "sensor": 2, "suppli": 2, "ch1_valu": 2, "ch2_valu": 2, "ch3_valu": 2, "ch4_valu": 2, "ch5_valu": 2, "ai_std_ch1_valu": 2, "ai_std_ch2_valu": 2, "ai_std_ch3_valu": 2, "ai_std_ch4_valu": 2, "ai_std_ch5_valu": 2, "el3255_error": 2, "chennel": 2, "ssi": 2, "ch1_counter_valu": 2, "ch2_counter_valu": 2, "udi_ch1_cnt_valu": 2, "udi_ch2_cnt_valu": 2, "el5002_error": 2, "sin": 2, "co": 2, "counter_valu": 2, "latch_valu": 2, "udicounter_valu": 2, "udilatch_valu": 2, "el5021_error": 2, "ch1_posit": 2, "ch2_posit": 2, "fb_inputs_ch1_posit": 2, "fb_inputs_ch2_posit": 2, "el5042_error": 2, "increment": 2, "5v": 2, "rs422": 2, "uicounter_valu": 2, "uilatch_valu": 2, "el5101_error": 2, "el7211": 2, "servo": 2, "termion": 2, "A": [2, 6], "AND": 2, "OR": 2, "e": 2, "bu": 2, "supplier": 2, "refresh": 2, "bstatus_us_uv": 2, "bstatus_up_uv": 2, "el9410_error": 2, "bstatus_uo_power_ok": 2, "bstatus_uo_overload": 2, "el9505_error": 2, "el9576": 2, "vap": 2, "resistor": 2, "overtemperatur": 2, "i2terror": 2, "i2twarn": 2, "overvoltag": 2, "undervoltag": 2, "chopperon": 2, "dclinkvoltag": 2, "dutycycl": 2, "resistorcurr": 2, "bctovertemperatur": 2, "bcti2terror": 2, "bcti2twarn": 2, "bctovervoltag": 2, "bctundervoltag": 2, "bctchopperon": 2, "bctdclinkvoltag": 2, "bctdutycycl": 2, "usint": 2, "bctresistorcurr": 2, "udint_to_lr": 2, "usint_to_lr": 2, "bound": 2, "properli": 2, "initi": 2, "stmotionstag": [2, 6], "stpositionst": 2, "delta": 2, "msg": 2, "case": 2, "common": 2, "4221": 2, "4222": 2, "4223": 2, "feed": 2, "4225": 2, "drive": 2, "readi": 2, "4260": 2, "42a0": 2, "coupl": 2, "4357": 2, "neg": 2, "4358": 2, "4395": 2, "4550": 2, "stall": 2, "monitor": 2, "4650": 2, "4655": 2, "4467": 2, "4b07": 2, "timeout": 2, "second": 2, "4fff": 2, "definit": 2, "7900": 2, "progress": 2, "7901": 2, "unsaf": 2, "7902": 2, "ffff": 2, "fake": 2, "test": [2, 7], "fallback": 2, "contact": 2, "pcd": 2, "end_cas": 2, "ab": 2, "extend": 2, "tcunit": [2, 3], "fb_testsuit": 2, "helper": 2, "multi": 2, "cycl": 2, "fbmotionstag": 2, "fbtestmov": 2, "stpositionstateinact": 2, "stpositionstateinvalid": 2, "stpositionstategood": 2, "toninact": 2, "ton": 2, "fbinternalgood": 2, "fbinternalinvalid": 2, "ntestcount": 2, "bonetestdon": 2, "singl": 2, "testposoverlowerboundy": 2, "testposoverlowerboundno": 2, "testposunderupperboundy": 2, "testposunderupperboundno": 2, "testposwithindeltatoolow": 2, "testposwithindeltatoohigh": 2, "testposwithindeltajustright": 2, "pt": 2, "t": 2, "testatpositionstatewithoutintern": 2, "40": 2, "testatpositionstateinvalid": 2, "good": 2, "50": 2, "testatpositionstatetoolow": 2, "testatpositionstatetoohigh": 2, "testatpositionstatejustright": 2, "testatpositionstatetweak": 2, "testatpositionstateleav": 2, "method": 2, "privat": 2, "right": 2, "fstartposit": 2, "fgoalposit": 2, "telaps": 2, "bsetdon": 2, "assertfals": 2, "wa": 2, "mark": 2, "test_finish": 2, "end_method": 2, "flocalgo": 2, "asserttru": 2, "outsid": 2, "awai": 2, "001": 2, "bhwenabl": 2, "bmotionstart": 2, "still": 2, "small": 2, "tweak": 2, "purpos": 2, "group": 2, "work": 2, "decid": 2, "25": 2, "200": 2, "sampl": 2, "period": 2, "cbuffers": 2, "bcalcul": 2, "abuffervalu": 2, "abufferdctim": 2, "curv": 2, "offset": 2, "ndcoffset": 2, "factfrequ": 2, "nindex": 2, "nfirstzerocross": 2, "nlastzerocross": 2, "rtimefirst": 2, "rtimelast": 2, "rtimer": 2, "ncross": 2, "var_temp": 2, "rrang": 2, "rtimespan": 2, "serach": 2, "cross": 2, "FOR": 2, "end_for": 2, "interpol": 2, "higher": 2, "accuraci": 2, "udint_to_r": 2, "buffer": 2, "more": 2, "than": 2, "int_to_r": 2, "span": 2, "first": 2, "last": 2, "consid": 2, "max": 2, "total": [2, 3, 8], "32bit": 2, "timestamp": 2, "29second": 2, "4294967296": 2, "1000000000": 2, "averag": 2, "over": 2, "simul": 2, "look": 2, "like": 2, "everyon": 2, "itself": 2, "var_in_out": 2, "nerrorcod": 2, "rtexec": 2, "r_trig": 2, "adswrit": 2, "mcreaddriveaddress": 2, "mc_readdriveaddress": 2, "clk": 2, "execut": 2, "driveaddress": 2, "port": [2, 3], "501": 2, "idxgrp": 2, "4200": 2, "ncdriveid": 2, "idxoff": 2, "0019": 2, "len": 2, "sizeof": 2, "srcaddr": 2, "adr": 2, "write": 2, "librari": [2, 6], "tc2_mc2": [2, 3], "lib": 2, "extern": 2, "ncommandloc": 2, "moveveloc": 2, "moverel": 2, "moveabsolut": 2, "movemodulo": 2, "superinp": 2, "tobe": 2, "nhomerevoffset": 2, "masteraxi": 2, "st_axisstatu": 2, "ncmddataloc": 2, "bfirstscan": 2, "fbreset": 2, "mc_reset": 2, "fbpower": 2, "mc_power": 2, "fbhalt": 2, "mc_halt": 2, "fbjog": 2, "mc_jog": 2, "fbmoveveloc": 2, "mc_moveveloc": 2, "fbmoverel": 2, "mc_moverel": 2, "fbmoveabsolut": 2, "mc_moveabsolut": 2, "fbmovemodulo": 2, "mc_movemodulo": 2, "fbhomevirtu": 2, "fbgearindyn": 2, "mc_gearindyn": 2, "fbgearout": 2, "mc_gearout": 2, "fbexecuteriseedg": 2, "transfer": 2, "local": 2, "copi": 2, "rise": 2, "issu": 2, "dut_axisstatu": 2, "later": 2, "enable_posit": 2, "enable_neg": 2, "overrid": 2, "buffermod": 2, "halt": 2, "jerk": 2, "commandabort": 2, "jogforward": 2, "jogbackward": 2, "uint_to_int": 2, "sel": 2, "mc_positive_direct": 2, "mc_negative_direct": 2, "inveloc": 2, "gearratio": 2, "master": 2, "slave": 2, "ingear": 2, "notmov": 2, "hasjob": 2, "homingbusi": 2, "fbhome": 2, "converes": 2, "word_to_hexstr": 2, "to_word": 2, "iprecis": 2, "blocas": 2, "nctoplc": [2, 6], "axisid": 2, "actvelo": 2, "opmod": 2, "modulo": 2, "moduloactpo": 2, "actpo": 2, "posdiff": 2, "commun": 2, "Or": 2, "di_1": 2, "di_2": 2, "di_1_latchtimepo": 2, "di_2_latchtimepo": 2, "di_1_latchtimeneg": 2, "di_2_latchtimeneg": 2, "coe": 2, "card": 2, "nickla": 2, "sinc": 2, "someth": 2, "wss": 2, "were": 2, "latch": 2, "onec": 2, "kkind": 2, "auto": 2, "di_1_latchneg": 2, "di_1_latchpo": 2, "di_2_latchneg": 2, "di_2_latchpo": 2, "latch_status1": 2, "latch_status2": 2, "latch_latchpos1": 2, "latch_latchneg1": 2, "latch_latchpos2": 2, "latch_latchneg2": 2, "op": 2, "ffo": 2, "trip": 2, "fbffhwo": 2, "fb_hardwareffoutput": 2, "bautoreset": 2, "quick": 2, "nearbi": 2, "btrip": 2, "fbncerrorffo": 2, "nlowerrorid": 2, "4400": 2, "nhigherrorid": 2, "44ff": 2, "sdesc": 2, "few": 2, "problem": 2, "solv": 2, "show": 2, "consist": 2, "invert": 2, "displai": 2, "veri": 2, "down": 2, "instead": 2, "up": 2, "sign": 2, "unsign": 2, "To": 2, "figur": 2, "ulint_to_udint": 2, "18446744073709551615": 2, "uint_to_udint": 2, "int_to_udint": 2, "fbsetpo": 2, "mc_setposit": 2, "timer": 2, "binit": 2, "bload": 2, "nlatcherror": 2, "bencerror": 2, "tretrydelai": 2, "nmaxretri": 2, "ncurrtri": 2, "bwaitretri": 2, "tonretri": 2, "persist": 2, "bsave": 2, "anyth": 2, "clearpositionlag": 2, "startup": 2, "r": 2, "keep": 2, "disappear": 2, "alert": 2, "gone": 2, "wrong": 2, "previous": 2, "retri": 2, "again": 2, "0x44nn": 2, "u": 2, "simpl": 2, "see": 2, "note": 2, "comment": 2, "usabl": 2, "roll": 2, "appli": 2, "about": 2, "stout": 2, "happen": 2, "manag": 2, "stin": 2, "enumset": 2, "pleas": 2, "exactli": 2, "alreadi": 2, "between": 2, "ask": 2, "ongo": 2, "enumget": 2, "arrstat": 2, "fbstatemanag": 2, "fist": 2, "setup": 2, "stuff": 2, "element": 2, "everi": 2, "setstat": 2, "getstat": 2, "delet": 2, "lerrorid": 2, "acknoledg": 2, "back": 2, "given": 2, "nfreepo": 2, "nlistcnt1": 2, "descript": [2, 3], "core": 2, "warn": 2, "realiz": 2, "datastructur": 2, "collect": 2, "statist": 2, "under": 2, "ponter": 2, "memset": 2, "specifi": 2, "memmov": 2, "bgantryalreadycoupl": 2, "masterenc": 2, "slaveenc": 2, "bexecutecoupl": 2, "bexecutedecoupl": 2, "gantry_diff_limit": 2, "mc_gearin": 2, "decoupl": 2, "binitcomplet": 2, "fbseten": 2, "design": 2, "ax": [2, 6, 7], "penc": 2, "senc": 2, "gantdifftol": 2, "plimfwd": 2, "plimbwd": 2, "slimfwd": 2, "slimbwd": 2, "couplest": 2, "init": 2, "boolean": 2, "primari": 2, "usual": 2, "upstream": 2, "secondari": 2, "differenac": 2, "revers": 2, "gantrydiff": 2, "wallac": 2, "2017": 2, "due": 2, "increas": 2, "esd": 2, "ccw": 2, "clock": 2, "assembli": 2, "eg": 2, "x": 2, "x1": 2, "x2": 2, "downstream": 2, "therefor": 2, "ulint_to_lint": 2, "mc_home": 2, "homingmod": 2, "mc_direct": 2, "bcalibrationcam": 2, "bsoflimenablelow": 2, "bsoflimenablehigh": 2, "fbhomewritesoftlimen": 2, "bexecutewritenc": 2, "nstate": 2, "soft": 2, "bsoflimenableloworigin": 2, "bsoflimenablehighorigin": 2, "fvelocitytocam": 2, "fvelocityfromcam": 2, "fbhomereadsoftlimen": 2, "fbhomedisablesoftlimen": 2, "fbhomereadncveloc": 2, "fbhomeresetcalibrationflag": 2, "calibr": 2, "flag": 2, "bexecutereadnc": 2, "actuali": 2, "sequenc": 2, "movement": 2, "mc_resetcalibr": 2, "fbreadvelocitytocam": 2, "fbreadvelocityfromcam": 2, "ndevicegroup": 2, "4000": 2, "nindexoffset": 2, "ndata": 2, "fbreadsoftlimenablelow": 2, "fbreadsoftlimenablehigh": 2, "5000": 2, "b": [2, 6], "dword_to_bool": 2, "bcamsensor": 2, "nsearchdirtwoardscam": 2, "nsearchdiroffcam": 2, "fvelocitytocamnc": 2, "velcoiti": 2, "cam": 2, "fvelocityfromcamnc": 2, "found": [2, 3, 8], "fbwritehomedircamtonc": 2, "fbwritehomedirsynctonc": 2, "fbwritehomemodetonc": 2, "fbwritehomevelocitiestonc": 2, "bconfigncdon": 2, "fbrtrigg": 2, "prepar": 2, "101": 2, "bool_to_dword": 2, "bsearchdirtwoardscam": 2, "102": 2, "impul": 2, "bsearchdiroffcam": 2, "107": 2, "reason": 2, "task": [2, 6], "svb": 2, "10m": 2, "filter": 2, "fbhometoswitch": 2, "fbhomedirect": 2, "fbhomeprepar": 2, "fbhomefinish": 2, "nhomingst": 2, "bexecutehometoswitch": 2, "bexecutemoveveloc": 2, "bexecuteprepar": 2, "bexecutefinish": 2, "bexecutehomedirect": 2, "ensur": 2, "bsequencereadi": 2, "brestorencdataneed": 2, "rins": 2, "Not": 2, "stand": 2, "go": 2, "goe": 2, "restor": 2, "softlimit": 2, "simplest": 2, "main": 2, "just": 2, "fbwritevelocitytocam": 2, "fbwritevelocityfromcam": 2, "fbwritesoftlimenablelow": 2, "fbwritesoftlimenablehigh": 2, "catch": 2, "json": 2, "blob": 2, "fblogmessag": 2, "fb_logmessag": 2, "rtnewerror": 2, "bchangederror": 2, "spreverr": 2, "fbjson": 2, "fb_jsonsaxwrit": 2, "startobject": 2, "addkei": 2, "schema": 2, "addstr": 2, "dut_nam": 2, "axis_nam": 2, "saxisnam": 2, "axis_id": 2, "addudint": 2, "err_id": 2, "addlreal": 2, "position_lag": 2, "endobject": 2, "sjson": 2, "getdocu": 2, "smsg": 2, "esevr": 2, "tceventsever": 2, "esubsystem": 2, "e_subsystem": 2, "resetdocu": 2, "fstepsiz": 2, "nstep": 2, "fmicrostep": 2, "tsettletim": 2, "nstepscount": 2, "ntheorystep": 2, "fpercent": 2, "festmicros": 2, "fbsettletim": 2, "bdomov": 2, "nstepcount": 2, "arrposbuff": 2, "99": 2, "favgpo": 2, "narrindex": 2, "nloopindex": 2, "fstartpo": 2, "fprevpo": 2, "fstepchang": 2, "fstepsum": 2, "settl": 2, "calcul": 2, "mod": 2, "result": 2, "step": 2, "dint_to_uint": 2, "trunc": 2, "miscellan": 2, "better": 2, "organ": 2, "elsewher": 2, "ffbeamparamsok": 2, "beam": 2, "enough": 2, "ffzeror": 2, "rate": 2, "ffunknown": 2, "assert": 2, "ffdebounc": 2, "autoreset": 2, "off": 2, "multipl": 2, "too": 2, "quickli": 2, "where": 2, "creat": 2, "blink": 2, "mostli": 2, "non": 2, "heavili": 2, "reus": 2, "detail": 2, "fbarbit": 2, "fb_arbit": 2, "sdevicenam": 2, "stcurrentbeamreq": 2, "st_beamparam": 2, "doesn": 2, "matter": 2, "bknownstat": 2, "lookup": 2, "ntransitionid": 2, "dword": 2, "consecut": 2, "debounc": 2, "nmaxtrip": 2, "decreas": 2, "much": 2, "ttripreset": 2, "encompass": 2, "fb_fastfault": 2, "sc": 2, "cut": 2, "earli": 2, "somewhat": 2, "redund": 2, "far": 2, "ntripcount": 2, "whenev": 2, "fttripcount": 2, "f_trig": 2, "tontripcount": 2, "bfirstcycl": 2, "i_xok": 2, "f_safebpcompar": 2, "pmps_gvl": 2, "stcurrentbeamparamet": 2, "i_xautoreset": 2, "i_devnam": 2, "i_desc": 2, "mismatch": 2, "i_typecod": 2, "io_fbffhwo": 2, "nmachinemod": 2, "nrate": 2, "nbcrang": 2, "ambigu": 2, "checkrequestinpool": 2, "nreqid": 2, "requir": 2, "come": 2, "permit": 2, "i_xreset": 2, "unit": [2, 7], "testbeamparamsnotok": 2, "testzeror": 2, "testunknownst": 2, "testtransitionst": 2, "testdebounc": 2, "var_inst": 2, "fbmiscffo": 2, "stbeamreq": 2, "evaluateoutput": 2, "q_xfastfaultout": 2, "cstfullbeam": 2, "ntran": 2, "did": 2, "bad": 2, "attenu": 2, "niter": 2, "through": 2, "full": 2, "untrip": 2, "tripuntrip": 2, "fail": 2, "addrequest": 2, "streqbp": 2, "sdevnam": 2, "unittest": 2, "stnobeam": 2, "testbeamzeror": 2, "cst0ratebeam": 2, "correct": 2, "togeth": 2, "share": 2, "stgoalparam": 2, "sttransparam": 2, "argument": 2, "build": 2, "intend": 2, "astmotionstag": [2, 6], "nactivemotorcount": 2, "bptm": 2, "physic": 2, "batstat": 2, "gui": 2, "long": 2, "tarbitertimeout": 2, "whether": 2, "bmoveonarbitertimeout": 2, "bresetbptmtimeout": 2, "becom": 2, "btransitionauthor": 2, "bmotorcounterror": 2, "beamparametertransitionmanag": 2, "bdonemov": 2, "nprevid": 2, "binternalauth": 2, "bdoneresetqueu": 2, "tonarbit": 2, "barbitertimeout": 2, "ffbptmtimeoutandmov": 2, "ffbptmerror": 2, "checkcount": 2, "setdonemov": 2, "runbptm": 2, "handletimeout": 2, "action": 2, "less": 2, "equal": 2, "end_act": 2, "ff": 2, "i_sdevicenam": 2, "i_transitionassertionid": 2, "nrequestassertionid": 2, "i_sttransitionassert": 2, "stbeamparam": 2, "i_nrequestedassertionid": 2, "i_strequestedassert": 2, "i_xdonemov": 2, "q_xtransitionauthor": 2, "place": 2, "without": 2, "author": 2, "wrap": 2, "n": 2, "basic": 2, "push": 2, "reserv": 2, "take": 2, "care": 2, "across": 2, "stgoal1": 2, "stgoal2": 2, "sttran": 2, "spmpsstate": 2, "put": 2, "blanket": 2, "won": 2, "testinit": 2, "test3dmov": 2, "testnomov": 2, "testcount": 2, "assertinpool": 2, "stdbstateparam": 2, "binpool": 2, "scontext": 2, "concat": 2, "pool": 2, "unexpectedli": 2, "setmotordon": 2, "forc": 2, "post": 2, "setmotormov": 2, "setmotorstartup": 2, "sort": 2, "3d": 2, "fbbptm": 2, "fbsubsysio": 2, "fb_dummyarbio": 2, "tontim": 2, "establish": 2, "baselin": 2, "goal1": 2, "auth": 2, "same": 2, "situat": 2, "la": 2, "forgot": 2, "tonwait": 2, "miss": 2, "hopefulli": 2, "protect": 2, "both": 2, "kept": 2, "whole": 2, "goal2": 2, "repeat": 2, "deactiv": 2, "static": 2, "astdbstateparam": 2, "who": 2, "made": 2, "removerequest": 2, "testbas": 2, "fbclear": 2, "udint_to_str": 2, "ftexec": 2, "nhomestatemachin": 2, "idl": 2, "nstateafterstop": 2, "nmove": 2, "bfirstdirect": 2, "bathom": 2, "bmove": 2, "nerrcount": 2, "binterrupt": 2, "next_mov": 2, "check_fwd": 2, "check_bwd": 2, "final_mov": 2, "final_setpo": 2, "wait_stop": 2, "simpler": 2, "realli": 2, "obviou": 2, "turn": 2, "track": 2, "risk": 2, "ridicul": 2, "stuck": 2, "rather": 2, "silent": 2, "failur": 2, "fwd_start": 2, "99999999": 2, "bwd_start": 2, "until": 2, "find": 2, "e_jogmod": 2, "mc_jogmode_contin": 2, "frefvelosearch": 2, "lim": 2, "slowli": 2, "frefvelosync": 2, "blcok": 2, "signl": 2, "doubl": 2, "act": 2, "ibsinglecntrl": 2, "accordingli": 2, "ibcntrlhold": 2, "ibinsertok": 2, "ibretractok": 2, "ibpmps_ok": 2, "retain": 2, "iboverrideinterlock": 2, "ignor": 2, "ffo_reset": 2, "ffo_autoreset": 2, "stpneumaticactu": 2, "mps_ok": 2, "mp": 2, "xmps_ok": 2, "fbff": 2, "mpa": 2, "xfirstpass": 2, "fbfsinit": 2, "ttimeoutdur": 2, "tinserttimeout": 2, "tretracttimeout": 2, "tlimitswitchlatchdur": 2, "tinsertlimitswitch": 2, "tretractlimitswitch": 2, "fblogger": 2, "eprevst": 2, "taction": 2, "insert_do": 2, "retract_do": 2, "toverrideactiv": 2, "i_xinsertedl": 2, "i_xretractedl": 2, "q_xinsert_do": 2, "q_xretract_do": 2, "map": 2, "act_io": 2, "yet": 2, "fulli": 2, "seat": 2, "postion": 2, "timout": 2, "act_logg": 2, "valv": 2, "open": 2, "critic": 2, "meant": 2, "support": 2, "dimension": 2, "kei": 2, "them": 2, "alloc": 2, "conflict": 2, "disagre": 2, "longer": 2, "assum": 2, "event": 2, "provid": 2, "respect": 2, "along": 2, "astpositionst": 2, "stransitionkei": 2, "onlin": 2, "breadnow": 2, "rest": 2, "indic": 2, "success": 2, "bfirstreaddon": 2, "fferror": 2, "fbreadpmpsdb": 2, "fb_jsondoctosafebp": 2, "ftdbbusi": 2, "ftread": 2, "breadpmpsdb": 2, "nitermotor": 2, "niterst": 2, "niterstate2": 2, "sloopnewkei": 2, "sloopprevkei": 2, "abstateerror": 2, "aslookupkei": 2, "asprevlookupkei": 2, "bnewkei": 2, "stempbackfil": 2, "selectlookupkei": 2, "readdatabas": 2, "runfastfault": 2, "backfillinfo": 2, "pure": 2, "clobber": 2, "origin": 2, "compat": 2, "futur": 2, "jsondoc": 2, "bp_jsondoc": 2, "programm": 2, "select": 2, "fill": 2, "posibl": 2, "overwrit": 2, "outer": 2, "loop": 2, "inner": 2, "thing": 2, "redud": 2, "don": 2, "duplic": 2, "spot": 2, "erron": 2, "param": 2, "prev": 2, "exit": 2, "submit": 2, "subset": 2, "astcorrectst": 2, "astnonsensest": 2, "astduplicatedst": 2, "asthalffullst": 2, "uint_to_str": 2, "asdf": 2, "uint_to_bool": 2, "state0": 2, "state1": 2, "testsolo": 2, "testtrio": 2, "testnonsens": 2, "testdup": 2, "testbackfil": 2, "testhalfful": 2, "fbread": 2, "stdefaultbp": 2, "999": 2, "777": 2, "bbeamparamsload": 2, "know": 2, "got": 2, "assertequals_udint": 2, "backfil": 2, "assertequals_bool": 2, "assertequals_str": 2, "spare": 2, "nonsens": 2, "With": 2, "possibl": 2, "fight": 2, "fall": 2, "enummotionrequest": 2, "fpo": 2, "fvel": 2, "facc": 2, "fdec": 2, "rtreset": 2, "ftbusi": 2, "bmymov": 2, "bcausederror": 2, "machin": 2, "wait_exec": 2, "pick_request": 2, "wait_other_mov": 2, "stop_other_mov": 2, "start_mov": 2, "wait_my_mov": 2, "stop_my_mov": 2, "done_mov": 2, "watch": 2, "lock": 2, "replac": 2, "aris": 2, "fbdrivevirtu": 2, "fbmotionhom": 2, "fbsaverestor": 2, "fblogerror": 2, "bexecmov": 2, "bexechom": 2, "bfwdhit": 2, "bbwdhit": 2, "rtuserexec": 2, "rttarget": 2, "rthome": 2, "bposgoal": 2, "bneggoal": 2, "fbencodervalu": 2, "fbncparam": 2, "bnewmovereq": 2, "bpreparedis": 2, "rtmovecmdshortcut": 2, "rthomecmdshortcut": 2, "accur": 2, "readstatu": 2, "circumv": 2, "caus": 2, "exec": 2, "past": 2, "super": 2, "rare": 2, "float": 2, "previou": 2, "sai": 2, "well": 2, "ess": 2, "int_to_uint": 2, "inject": 2, "infinit": 2, "spam": 2, "positivedirect": 2, "negativedirect": 2, "intargetposit": 2, "delai": 2, "standstil": 2, "race": 2, "motionst": 2, "mc_axisstate_standstil": 2, "mc_axisstate_undefin": 2, "mc_axisstate_dis": 2, "mc_axisstate_errorstop": 2, "dmov": 2, "auxiliari": 2, "trefreshdelai": 2, "mcreadparam": 2, "nlatcherrid": 2, "movabl": 2, "govern": 2, "eas": 2, "class": 2, "instanti": 2, "form": 2, "access": 2, "succinctli": 2, "suit": 2, "seten": 2, "setenablespmp": 2, "setgoodst": 2, "4xxx": 2, "40xx": 2, "41xx": 2, "42xx": 2, "43xx": 2, "44xx": 2, "45xx": 2, "46xx": 2, "4axx": 2, "tabl": 2, "4bxx": 2, "4cxx": 2, "kinemat": 2, "transform": 2, "There": 2, "spars": 2, "popul": 2, "8xxx": 2, "8100": 2, "811f": 2, "bode": 2, "plot": 2, "diagnosi": 2, "8120": 2, "8fff": 2, "further": 2, "simpli": 2, "lowest": 2, "sent": 2, "20xx": 2, "xx": 2, "hex": 2, "nerrortypecod": 2, "rttrip": 2, "unnam": 2, "udint_to_uint": 2, "shr": 2, "min": 2, "report": 2, "fbcausencerror": 2, "fbencerrorffo": 2, "isol": 2, "enc": [2, 7], "4500": 2, "45ff": 2, "testnc": 2, "testenc": 2, "ntestid": 2, "testencerror": 2, "causer": 2, "broken": 2, "testncerror": 2, "consider": 2, "trust": 2, "afbencerror": 2, "ffprogrammererror": 2, "handleloop": 2, "handleffo": 2, "illog": 2, "ll": 2, "legit": 2, "ad": 2, "testblankcount": 2, "testtwomotorencerror": 2, "fbffo": 2, "blank": 2, "doc": 2, "simplic": 2, "astbeamparam": 2, "jsonroot": 2, "sjsonvalu": 2, "jsondevic": 2, "ajsonst": 2, "fb_jsondompars": 2, "nid": 2, "asevrang": 2, "asrat": 2, "asbcrang": 2, "astran": 2, "newdocu": 2, "addobjectmemb": 2, "lower_bound": 2, "upper_bound": 2, "addintmemb": 2, "member": 2, "addstringmemb": 2, "beamlin": 2, "tst": 2, "bitmasktostr": 2, "nevrang": 2, "32": 2, "ap_ygap": 2, "ap_xgap": 2, "damage_limit": 2, "reactive_temp": 2, "reactive_pressur": 2, "nbeamclassrang": 2, "real_to_str": 2, "ap_nam": 2, "ap_ycent": 2, "ap_xcent": 2, "pulse_energi": 2, "addboolmemb": 2, "special": 2, "nbitmask": 2, "nbit": 2, "dword_to_str": 2, "among": 2, "begin": 2, "accept": 2, "possibli": 2, "unus": 2, "expand": 2, "2d": 2, "stepicstoplc": 2, "stplctoepic": 2, "fbcore": 2, "astmotionstagemax": 2, "astpositionstatemax": 2, "1d": 2, "construct": 2, "continu": 2, "estatereq": 2, "estateget": 2, "fbpositionstate1d": 2, "assembl": 2, "clariti": 2, "astpositionstate1": 2, "astpositionstate2": 2, "1st": 2, "stmotionstage1": [2, 6], "2nd": 2, "stmotionstage2": [2, 6], "01": 2, "stin1": 2, "stout1": 2, "stin2": 2, "stout2": 2, "estateset": 2, "fbpositionstate2d": 2, "astpositionstate3": 2, "3rd": 2, "stmotionstage3": [2, 6], "subclass": 2, "bodi": 2, "On": 2, "flip": 2, "goalstat": 2, "stunknown": 2, "stgoal": 2, "fbstatemov": 2, "fbstateintern": 2, "bnewgoal": 2, "binnerexec": 2, "binnerreset": 2, "bmoverequest": 2, "me": 2, "translat": 2, "statehandl": 2, "favor": 2, "mutual": 2, "exclus": 2, "branch": 2, "unclear": 2, "becaus": 2, "bring": 2, "spmpsdevicenam": 2, "fstateboundarydeadband": 2, "bbpokautoreset": 2, "fbstatepmp": 2, "fbencerrffo": 2, "pmpshandler": 2, "stpmpsdoc": 2, "brequesttransit": 2, "sttransitionbeam": 2, "ntransitionassertionid": 2, "binoutinit": 2, "_withpmp": 2, "_withpmps_test": 2, "proper": 2, "engin": 2, "quantiti": 2, "featur": 2, "nomin": 2, "fbencconvert": 2, "fblock": 2, "po": 2, "egu": 2, "stparamet": 2, "ncountcheck": 2, "fposcheck": 2, "fposget": 2, "ncountget": 2, "individu": 2, "afbstateintern": 2, "subsequ": 2, "stcachedpositionst": 2, "cach": 2, "haven": 2, "skip": 2, "noth": 2, "unlock": 2, "insid": 2, "space": 2, "besid": 2, "fbmotionrequest": 2, "ballowmov": 2, "veto": 2, "standalon": 2, "And": 2, "api": 2, "behav": 2, "afbintern": 2, "stdummypo": 2, "stinvalid": 2, "stnotupd": 2, "stunsaf": 2, "fbmove": 2, "fteststartpo": 2, "bstatesreadi": 2, "uno": 2, "tre": 2, "warm": 2, "runthrough": 2, "testmov": 2, "testbadst": 2, "ntestindex": 2, "testinvalid": 2, "nstateindex": 2, "blocalinit": 2, "binterruptstart": 2, "assertequals_lr": 2, "coordin": 2, "twintcat": 2, "nerrorcount": 2, "compon": 2, "summar": 2, "nshownerror": 2, "One": 2, "afbpositionstatemov": 2, "nlowerbound": 2, "nupperbound": 2, "dostatemov": 2, "combineoutput": 2, "afbmotionstag": 2, "astgoalposit": 2, "resetgo": 2, "somewher": 2, "goal3": 2, "fmotor1po": 2, "fmotor2po": 2, "fmotor3po": 2, "g": 2, "essenti": 2, "suppos": 2, "ncurrgoal": 2, "fbinput": 2, "fbintern": 2, "astmovego": 2, "stinvalidpo": 2, "bmovingst": 2, "npositionindex": 2, "stuserinput": 2, "bmovebusi": 2, "nstartingst": 2, "bresetmov": 2, "saniti": 2, "sensibli": 2, "regress": 2, "197": 2, "deadlock": 2, "fb_move1d": 2, "fb_move2d": 2, "fb_move3d": 2, "esetpo": 2, "egetpo": 2, "test1d": 2, "test2d": 2, "test3d": 2, "testinputdeadlock": 2, "nlocalinit": 2, "test1d_stat": 2, "dint_to_str": 2, "assertequals_dint": 2, "test2d_stat": 2, "test3d_stat": 2, "reproduc": 2, "fix": 2, "attempt": 2, "succe": 2, "regardless": 2, "could": 2, "nteststep": 2, "enewgo": 2, "easiest": 2, "potenti": 2, "bug": 2, "resum": 2, "assertequals_uint": 2, "rais": 2, "wors": 2, "sthighbeamthreshold": 2, "arrpmp": 2, "nbpindex": 2, "nlastreqassertionid": 2, "rtreaddbexec": 2, "ffmaint": 2, "bffoxok": 2, "batsafest": 2, "asserther": 2, "ststatereq": 2, "clearassert": 2, "handlebptm": 2, "late": 2, "btransdon": 2, "forev": 2, "stai": 2, "rtdolatefinish": 2, "blatefinish": 2, "swap": 2, "bbptmdone": 2, "stbeamneed": 2, "rapidli": 2, "train": 2, "wheel": 2, "ultim": 2, "think": 2, "bintransit": 2, "handlepmpsdb": 2, "BY": 2, "sttransitionst": 2, "benablemot": 2, "benablebeamparam": 2, "benablepositionlimit": 2, "screen": 2, "stpmpsepicstoplc": 2, "breaddbnow": 2, "stpmpsplctoepic": 2, "fbpmpscore": 2, "outward": 2, "face": 2, "nearli": 2, "ident": 2, "fbpositionstatepmps1d": 2, "m1": 2, "m2": 2, "fbpositionstatepmps2d": 2, "m3": 2, "bforwardauthor": 2, "bbackwardauthor": 2, "rttransreq": 2, "rtbptmdone": 2, "ftmotorexec": 2, "rttransdon": 2, "tondon": 2, "mcpower": 2, "fupperbound": 2, "flowerbound": 2, "ngoalstat": 2, "stgoalstat": 2, "factpo": 2, "freqpo": 2, "bfwdok": 2, "bbwdok": 2, "parent": 2, "reiniti": 2, "100m": 2, "getstatestruct": 2, "unstuck": 2, "toggl": 2, "dummi": 2, "grant": 2, "deni": 2, "getbeamfromst": 2, "ststate": 2, "getstatecod": 2, "c0371": 2, "implicit": 2, "__isvalidref": 2, "offlin": 2, "explicit": 2, "tonreq": 2, "reciev": 2, "abl": 2, "tell": 2, "anywai": 2, "fbmotionreadpmpsdb": 2, "fbmotionbptm": 2, "fbmotionclearassert": 2, "fbstatepmpsen": 2, "fbmiscstateserrorffo": 2, "fbpermotorffo": 2, "estatepmpsstatu": 2, "ngoalstateindex": 2, "aben": 2, "abforwarden": 2, "abbackwarden": 2, "abvalidgo": 2, "astbeam": 2, "fbarbiter1d": 2, "fbarbiter2d": 2, "fbarbiter3d": 2, "fbsubsysio1d": 2, "fbsubsysio2d": 2, "fbsubsysio3d": 2, "jsonhelp": 2, "inspect": 2, "snoop": 2, "plctonc": [2, 6], "repres": 2, "complic": 2, "mayb": 2, "help": 2, "consum": 2, "teststartup1d": 2, "teststartup2d": 2, "teststartup3d": 2, "assertmotionlim": 2, "sid": 2, "nexpect": 2, "111": 2, "011": 2, "controldword": 2, "assertequals_dword": 2, "blimassert": 2, "directon": 2, "mot": 2, "bp": 2, "blimasserted1": 2, "blimasserted2": 2, "blimasserted3": 2, "sit": 2, "nor": 2, "didn": 2, "0001": 2, "why": 2, "motor1": 2, "motor2": 2, "motor3": 2, "overlap": 2, "arbitrarili": 2, "abatposit": 2, "confus": 2, "conveni": 2, "stcurrentposit": 2, "clarifi": 2, "accord": 2, "quatro": 2, "teststaticposit": 2, "stestnam": 2, "atpos1": 2, "outsidepos1delta": 2, "atinvalidpo": 2, "atpos3": 2, "testmovingposit": 2, "movingat3": 2, "movingfrom3": 2, "ttimeout": 2, "abexpect": 2, "incorrect": 2, "assertarrayequals_bool": 2, "combin": 2, "fb_positionstateread1d": 2, "fb_positionstateread2d": 2, "enclos": 2, "afbpositionstateread": 2, "niter2": 2, "dostateread": 2, "account": 2, "afbtestmov": 2, "boneassertdon": 2, "nassertcount": 2, "niter1": 2, "niter3": 2, "fbmisread": 2, "astgoodstag": 2, "astgoodstateshap": 2, "astsqmotionstag": [2, 6], "afbsqmotionstag": 2, "astsquarest": 2, "afbsqintern": 2, "afbsqtestmov": 2, "fbsqread": 2, "bsqassertdon": 2, "nsqassertcount": 2, "no_stat": 2, "out_stat": 2, "in_stat": 2, "in_tweak": 2, "last_test": 2, "test_count": 2, "permotor": 2, "squaresetup": 2, "testforgot": 2, "testcombo": 2, "testsquar": 2, "bresetdon": 2, "doassert": 2, "nmotorcase1": 2, "nmotorcase2": 2, "nmotorcase3": 2, "bready1": 2, "bready2": 2, "bready3": 2, "stestcas": 2, "domov": 2, "nmotorindex": 2, "nmotorcas": 2, "smaller": 2, "lot": 2, "univers": 2, "doread": 2, "squar": 2, "geometri": 2, "y": 2, "corner": 2, "bot": 2, "top": 2, "nassertid": 2, "nmotor1cas": 2, "nmotor2cas": 2, "nmotor3cas": 2, "tontimeout": 2, "big": 2, "125": 2, "testallcombo": 2, "lreal_to_uint": 2, "floor": 2, "final": 2, "extra": 2, "assertresult": 2, "totalassert": 2, "forgotcount": 2, "notic": 2, "ngoal": 2, "util": 2, "convert": 2, "against": 2, "calc": 2, "fencscalefactorintern": 2, "lreal_to_udint": 2, "fencoffset": 2, "axisdata": 2, "encoderdata": 2, "6000": 2, "controldata": 2, "7000": 2, "drivedata": 2, "fbadsread": 2, "adsread": 2, "500": 2, "destaddr": 2, "sequens": 2, "tc2_system": [2, 3], "histori": 2, "2014": 2, "v1": 2, "00": 2, "nb": 2, "beps_ok": 2, "lfe": 2, "splcname": 2, "brefresh": 2, "directori": 2, "store": 2, "sdirectori": 2, "hard": 2, "disk": 2, "ftp": 2, "last_refresh": 2, "nlastrefreshtim": 2, "rtenabl": 2, "rtrefresh": 2, "liften": 2, "fbtime": 2, "fb_localsystemtim": 2, "dwcycl": 2, "fbtime_to_utc": 2, "fb_tzspecificlocaltimetosystemtim": 2, "fbgettimezon": 2, "fb_gettimezoneinform": 2, "ssrcpathnam": 2, "pmps_jsondoc": 2, "lift": 2, "snetid": 2, "systemtim": 2, "tzinfo": 2, "to_dint": 2, "to_dt": 2, "systemtime_to_dt": 2, "strang": 2, "bforwarden": 2, "bbackwarden": 2, "bvalidgo": 2, "nprevstateindex": 2, "flowerpo": 2, "fupperpo": 2, "ffnogoal": 2, "getbound": 2, "applyen": 2, "obei": 2, "constraint": 2, "fbinternal1": 2, "fbinternal2": 2, "ninvalidst": 2, "nnotupdatedst": 2, "testnotupd": 2, "testbelow": 2, "testabov": 2, "testat": 2, "testdis": 2, "testlimit": 2, "testmoveto": 2, "testmoveat": 2, "fbstateen": 2, "ran": 2, "correctli": 2, "kill": 2, "bmovedon": 2, "dimens": 2, "freeli": 2, "cost": 2, "afbstateen": 2, "dolimit": 2, "confid": 2, "restrict": 2, "spoof": 2, "testunderovergo": 2, "testmaint": 2, "fbenabl": 2, "relax": 2, "anywher": 2, "But": 2, "deprec": 2, "serror": 2, "bexectrig": 2, "bexecend": 2, "flowpo": 2, "fhighpo": 2, "larg": 2, "typic": 2, "verbos": 2, "hand": 2, "prone": 2, "bsetdefault": 2, "forget": 2, "order": 2, "templat": 2, "self": 2, "reappli": 2, "bforceupd": 2, "recommend": 2, "guard": 2, "fairli": 2, "annoi": 2, "fbstatesetup": 2, "stdefault": 2, "aststates1": 2, "aststates2": 2, "yag": 2, "tt": 2, "35": 2, "70": 2, "aststates3": 2, "fbwarn": 2, "bhasdefault": 2, "bhaswarn": 2, "unset": [2, 3], "aststat": 2, "stdefaultdefault": 2, "testnormalcas": 2, "testdefaultonli": 2, "testmanyoverrid": 2, "testnodefault": 2, "testonlyonc": 2, "storigin": 2, "sttarget": 2, "mutat": 2, "potato": 2, "23": 2, "stone": 2, "sttwo": 2, "overriden": 2, "ONE": 2, "testpmp": 2, "cdelta": 2, "cveloc": 2, "cmoveok": 2, "cvalid": 2, "mimic": 2, "fake_out": 2, "fake_yag": 2, "fake_tt": 2, "someon": 2, "twice": 2, "unless": 2, "desir": 2, "mid": 2, "detect": 2, "caput": 2, "seed": 2, "clamp": 2, "nqueuedgoal": 2, "bnewmov": 2, "istateerror": 2, "iothererror": 2, "errordata": 2, "nerrsyscnt": 2, "bstatechang": 2, "uiinfodata_state_prev": 2, "bwcstate_prev": 2, "decis": 2, "tree": 2, "close": 2, "tc2_ethercat": [2, 3], "f_getactualdctime64": 2, "dctime64_to_str": 2, "terminal_id": 2, "000f": 2, "mask": 2, "00f0": 2, "signific": 2, "preop": 2, "0003": 2, "boot": 2, "0004": 2, "safeop": 2, "0008": 2, "undefin": 2, "hope": 2, "0000": 2, "0010": 2, "0020": 2, "vendorid": 2, "productcod": 2, "0040": 2, "initialis": 2, "errormessag": 2, "introduc": 2, "involv": 2, "respond": 2, "bstoppingmotor": 2, "fbmoverequest": 2, "mcsetpo": 2, "bexecqueu": 2, "1h": 2, "et": 2, "controlloopclos": 2, "import": 2, "sub": 2, "extract": 2, "rtresetdon": 2, "rtsetdon": 2, "rtmotionstart": 2, "rtmovedon": 2, "basicmot": 2, "said": 2, "fbadswrit": 2, "end_program": 2, "am": 3, "net": 3, "172": 3, "148": 3, "ip": 3, "address": 3, "851": 3, "190": [3, 8], "linter": [3, 8], "vendor": 3, "slac": 3, "beckhoff": 3, "autom": 3, "gmbh": 3, "tc2_math": 3, "tc2_standard": 3, "tc2_util": 3, "tc3_jsonxml": 3, "tc3_modul": 3, "www": 3, "org": 3, "owner": 6, "item": 6, "inputdst": 6, "fb_statepmpslimits_test": 6, "tinc": 6, "saf": 6, "axis_statepmpslimits_test": 6, "toplc": 6, "plctask": 6, "fromplc": 6, "outputsrc": 6, "axisfold": 7, "axistyp": 7, "createsymbol": 7, "enctyp": 7, "otherset": 7, "allowmotioncmdtoslav": 7}, "objects": {}, "objtypes": {}, "objnames": {}, "titleterms": {"lcl": 0, "twincat": 0, "motion": 0, "librari": [0, 3, 8], "indic": 0, "tabl": 0, "data": 1, "type": 1, "databas": 1, "record": 1, "dut": 2, "dut_axisstatus_v0_01": 2, "dut_errorst": 2, "dut_motionpneumaticactu": 2, "dut_motionstag": 2, "dut_positionst": 2, "dut_terminalerror": 2, "dutel2521_ctrl": 2, "dutel2521_statu": 2, "e_epicshomecmd": 2, "e_epicsinout": 2, "e_epicsmotorcmd": 2, "e_motionfftyp": 2, "e_motionrequest": 2, "e_pnuematicactuatorpositionst": 2, "e_stagebrakemod": 2, "e_stageenablemod": 2, "e_statepmpsstatu": 2, "e_testst": 2, "el5042_statu": 2, "enum_epicshomecmd": 2, "enum_epicsinout": 2, "enum_epicsinout_int": 2, "enum_epicsmotorcmd": 2, "enum_motionfftyp": 2, "enum_motionrequest": 2, "enum_pnuematicactuatorpositionst": 2, "enum_stagebrakemod": 2, "enum_stageenablemod": 2, "enum_statepmpsstatu": 2, "st_el5042_statu": 2, "st_errorsystem": 2, "st_motionpneumaticactu": 2, "st_motionstag": 2, "st_positionst": 2, "st_renishawabsenc": 2, "st_stateepicstoplc": 2, "st_stateplctoep": 2, "st_statepmpsepicstoplc": 2, "st_statepmpsplctoep": 2, "gvl": 2, "global_vers": 2, "gvl_errorsystem": 2, "motion_gvl": 2, "motionconst": 2, "pou": 2, "checkbound": 2, "checkdivdint": 2, "checkdivlint": 2, "checkdivlr": 2, "checkdivr": 2, "ek1200": 2, "el1008": 2, "el1018": 2, "el1808": 2, "el1809": 2, "el1819": 2, "el2014": 2, "el2252": 2, "el2808": 2, "el2819": 2, "el3174_0002": 2, "el3214": 2, "el3255": 2, "el5002": 2, "el5021": 2, "el5042": 2, "el5101": 2, "el7211_v1_00": 2, "el9410": 2, "el9505": 2, "el9576_v1_00": 2, "f_atpositionst": 2, "f_motionerrorcodelookup": 2, "f_posoverlowerbound": 2, "f_posunderupperbound": 2, "f_poswithindelta": 2, "fb_atpositionstate_test": 2, "fb_calculatefrequency_3702_v0_01": 2, "fb_causencerror": 2, "fb_drivevirtu": 2, "fb_el1252asm_v1_00": 2, "fb_encerrorffo": 2, "fb_encodervalu": 2, "fb_encsaverestor": 2, "fb_epicsinout": 2, "fb_errorlist": 2, "fb_gantryautocoupl": 2, "fb_gantrydiffvirtuallimitswitch": 2, "fb_homedirect": 2, "fb_homefinish": 2, "fb_homeprepar": 2, "fb_homereadncveloc": 2, "fb_homereadsoftlimen": 2, "fb_hometoswitch": 2, "fb_homevirtu": 2, "fb_homewritencveloc": 2, "fb_homewritesoftlimen": 2, "fb_logmotionerror": 2, "fb_microstepcounttest": 2, "fb_miscstateserrorffo": 2, "fb_miscstateserrorffo_test": 2, "fb_motionbptm": 2, "fb_motionbptm_test": 2, "fb_motionclearassert": 2, "fb_motionclearasserts_test": 2, "fb_motionhom": 2, "fb_motionpneumaticactu": 2, "fb_motionreadpmpsdbnd": 2, "fb_motionreadpmpsdbnd_test": 2, "fb_motionrequest": 2, "fb_motionstag": 2, "fb_motionstagencparam": 2, "fb_motionstagesim": 2, "fb_motortestsuit": 2, "fb_ncaxi": 2, "fb_ncerrorffo": 2, "fb_ncerrorffo_test": 2, "fb_permotorffond": 2, "fb_permotorffond_test": 2, "fb_pmpsjsontesthelp": 2, "fb_positionstate1d": 2, "fb_positionstate1d_inout": 2, "fb_positionstate2d": 2, "fb_positionstate2d_inout": 2, "fb_positionstate3d": 2, "fb_positionstatebas": 2, "fb_positionstatebase_withpmp": 2, "fb_positionstatebase_withpmps_test": 2, "fb_positionstateinout": 2, "fb_positionstateinout_withpmp": 2, "fb_positionstateinout_withpmps_test": 2, "fb_positionstateintern": 2, "fb_positionstateinternalnd": 2, "fb_positionstatelock": 2, "fb_positionstatemanag": 2, "fb_positionstatemov": 2, "fb_positionstatemove_test": 2, "fb_positionstatemovend": 2, "fb_positionstatemovend_test": 2, "fb_positionstatend_cor": 2, "fb_positionstatend_test": 2, "fb_positionstatepmp": 2, "fb_positionstatepmps1d": 2, "fb_positionstatepmps1d_inout": 2, "fb_positionstatepmps2d": 2, "fb_positionstatepmps2d_inout": 2, "fb_positionstatepmps3d": 2, "fb_positionstatepmps_bas": 2, "fb_positionstatepmps_test": 2, "fb_positionstatepmpsnd_cor": 2, "fb_positionstatepmpsnd_test": 2, "fb_positionstateread": 2, "fb_positionstateread_test": 2, "fb_positionstatereadnd": 2, "fb_positionstatereadnd_test": 2, "fb_rawcountconvert": 2, "fb_readfloatparamet": 2, "fb_readparameterinnc_v1_00": 2, "fb_seten": 2, "fb_standard_pmpsdb": 2, "fb_statepmpsen": 2, "fb_statepmpsenables_test": 2, "fb_statepmpsenablesnd": 2, "fb_statepmpsenablesnd_test": 2, "fb_stateptpmov": 2, "fb_statesetuphelp": 2, "fb_statesetuphelper_test": 2, "fb_statesinputhandl": 2, "fb_terminalerror": 2, "fb_testhelpersetandmov": 2, "fb_testhelpersetandmove_test": 2, "fb_writefloatparamet": 2, "fb_writeparameterinnc_v1_00": 2, "prg_test": 2, "set": [3, 7], "pragma": [3, 8], "symbol": 3, "box": [4, 5], "hierarchi": 5, "link": 6, "nc": 7, "axi": 7, "3": 7, "axis_positionstateread_test": 7, "4": 7, "axis_atpositionstate_test": 7, "5": 7, "axis_testhelpersetandmove_test": 7, "6": 7, "axis_positionstatereadnd_test_1": 7, "7": 7, "axis_positionstatereadnd_test_2": 7, "8": 7, "axis_positionstatereadnd_test_3": 7, "9": 7, "axis_positionstatemove_test": 7, "10": 7, "axis_positionstatemovend_test_1": 7, "11": 7, "axis_positionstatemovend_test_2": 7, "12": 7, "axis_positionstatemovend_test_3": 7, "13": 7, "axis_positionstatend_test_1": 7, "14": 7, "axis_positionstatend_test_2": 7, "15": 7, "axis_positionstatend_test_3": 7, "16": 7, "axis_ncerrorffo_test": 7, "17": 7, "axis_positionstatepmpsnd_test_1": 7, "18": 7, "axis_positionstatepmpsnd_test_2": 7, "19": 7, "axis_positionstatepmpsnd_test_3": 7, "20": 7, "axis_statepmpsenable_test": 7, "21": 7, "axis_positionstatereadnd_test_4": 7, "22": 7, "axis_positionstatereadnd_test_5": 7}, "envversion": {"sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.viewcode": 1, "sphinx": 60}, "alltitles": {"lcls-twincat-motion": [[0, "lcls-twincat-motion"], [0, null]], "Library": [[0, null], [8, "library"]], "Indices and tables": [[0, "indices-and-tables"]], "Data Types": [[1, "data-types"]], "Database Records": [[1, "database-records"]], "DUTs": [[2, "duts"]], "DUT_AxisStatus_v0_01": [[2, "dut-axisstatus-v0-01"]], "DUT_ErrorState": [[2, "dut-errorstate"]], "DUT_MotionPneumaticActuator": [[2, "dut-motionpneumaticactuator"]], "DUT_MotionStage": [[2, "dut-motionstage"]], "DUT_PositionState": [[2, "dut-positionstate"]], "DUT_TerminalError": [[2, "dut-terminalerror"]], "dutEL2521_Ctrl": [[2, "dutel2521-ctrl"]], "dutEL2521_Status": [[2, "dutel2521-status"]], "E_EpicsHomeCmd": [[2, "e-epicshomecmd"]], "E_EpicsInOut": [[2, "e-epicsinout"]], "E_EpicsMotorCmd": [[2, "e-epicsmotorcmd"]], "E_MotionFFType": [[2, "e-motionfftype"]], "E_MotionRequest": [[2, "e-motionrequest"]], "E_PnuematicActuatorPositionState": [[2, "e-pnuematicactuatorpositionstate"]], "E_StageBrakeMode": [[2, "e-stagebrakemode"]], "E_StageEnableMode": [[2, "e-stageenablemode"]], "E_StatePMPSStatus": [[2, "e-statepmpsstatus"]], "E_TestStates": [[2, "e-teststates"]], "EL5042_Status": [[2, "el5042-status"]], "ENUM_EpicsHomeCmd": [[2, "enum-epicshomecmd"]], "ENUM_EpicsInOut": [[2, "enum-epicsinout"]], "ENUM_EpicsInOut_INT": [[2, "enum-epicsinout-int"]], "ENUM_EpicsMotorCmd": [[2, "enum-epicsmotorcmd"]], "ENUM_MotionFFType": [[2, "enum-motionfftype"]], "ENUM_MotionRequest": [[2, "enum-motionrequest"]], "ENUM_PnuematicActuatorPositionState": [[2, "enum-pnuematicactuatorpositionstate"]], "ENUM_StageBrakeMode": [[2, "enum-stagebrakemode"]], "ENUM_StageEnableMode": [[2, "enum-stageenablemode"]], "ENUM_StatePMPSStatus": [[2, "enum-statepmpsstatus"]], "ST_EL5042_Status": [[2, "st-el5042-status"]], "ST_ErrorSystem": [[2, "st-errorsystem"]], "ST_MotionPneumaticActuator": [[2, "st-motionpneumaticactuator"]], "ST_MotionStage": [[2, "st-motionstage"]], "ST_PositionState": [[2, "st-positionstate"]], "ST_RenishawAbsEnc": [[2, "st-renishawabsenc"]], "ST_StateEpicsToPlc": [[2, "st-stateepicstoplc"]], "ST_StatePlcToEpics": [[2, "st-stateplctoepics"]], "ST_StatePMPSEpicsToPlc": [[2, "st-statepmpsepicstoplc"]], "ST_StatePMPSPlcToEpics": [[2, "st-statepmpsplctoepics"]], "GVLs": [[2, "gvls"]], "Global_Version": [[2, "global-version"]], "GVL": [[2, "gvl"]], "GVL_ErrorSystem": [[2, "gvl-errorsystem"]], "MOTION_GVL": [[2, "motion-gvl"]], "MotionConstants": [[2, "motionconstants"]], "POUs": [[2, "pous"]], "CheckBounds": [[2, "checkbounds"]], "CheckDivDInt": [[2, "checkdivdint"]], "CheckDivLInt": [[2, "checkdivlint"]], "CheckDivLReal": [[2, "checkdivlreal"]], "CheckDivReal": [[2, "checkdivreal"]], "EK1200": [[2, "ek1200"]], "EL1008": [[2, "el1008"]], "EL1018": [[2, "el1018"]], "EL1808": [[2, "el1808"]], "EL1809": [[2, "el1809"]], "EL1819": [[2, "el1819"]], "EL2014": [[2, "el2014"]], "EL2252": [[2, "el2252"]], "EL2808": [[2, "el2808"]], "EL2819": [[2, "el2819"]], "EL3174_0002": [[2, "el3174-0002"]], "EL3214": [[2, "el3214"]], "EL3255": [[2, "el3255"]], "EL5002": [[2, "el5002"]], "EL5021": [[2, "el5021"]], "EL5042": [[2, "el5042"]], "EL5101": [[2, "el5101"]], "EL7211_v1_00": [[2, "el7211-v1-00"]], "EL9410": [[2, "el9410"]], "EL9505": [[2, "el9505"]], "EL9576_v1_00": [[2, "el9576-v1-00"]], "F_AtPositionState": [[2, "f-atpositionstate"]], "F_MotionErrorCodeLookup": [[2, "f-motionerrorcodelookup"]], "F_PosOverLowerBound": [[2, "f-posoverlowerbound"]], "F_PosUnderUpperBound": [[2, "f-posunderupperbound"]], "F_PosWithinDelta": [[2, "f-poswithindelta"]], "FB_AtPositionState_Test": [[2, "fb-atpositionstate-test"]], "FB_CalculateFrequency_3702_v0_01": [[2, "fb-calculatefrequency-3702-v0-01"]], "FB_CauseNCError": [[2, "fb-causencerror"]], "FB_DriveVirtual": [[2, "fb-drivevirtual"]], "FB_EL1252ASM_v1_00": [[2, "fb-el1252asm-v1-00"]], "FB_EncErrorFFO": [[2, "fb-encerrorffo"]], "FB_EncoderValue": [[2, "fb-encodervalue"]], "FB_EncSaveRestore": [[2, "fb-encsaverestore"]], "FB_EpicsInOut": [[2, "fb-epicsinout"]], "FB_ErrorList": [[2, "fb-errorlist"]], "FB_GantryAutoCoupling": [[2, "fb-gantryautocoupling"]], "FB_GantryDiffVirtualLimitSwitch": [[2, "fb-gantrydiffvirtuallimitswitch"]], "FB_HomeDirect": [[2, "fb-homedirect"]], "FB_HomeFinish": [[2, "fb-homefinish"]], "FB_HomePrepare": [[2, "fb-homeprepare"]], "FB_HomeReadNcVelocities": [[2, "fb-homereadncvelocities"]], "FB_HomeReadSoftLimEnable": [[2, "fb-homereadsoftlimenable"]], "FB_HomeToSwitch": [[2, "fb-hometoswitch"]], "FB_HomeVirtual": [[2, "fb-homevirtual"]], "FB_HomeWriteNcVelocities": [[2, "fb-homewritencvelocities"]], "FB_HomeWriteSoftLimEnable": [[2, "fb-homewritesoftlimenable"]], "FB_LogMotionError": [[2, "fb-logmotionerror"]], "FB_MicroStepCountTest": [[2, "fb-microstepcounttest"]], "FB_MiscStatesErrorFFO": [[2, "fb-miscstateserrorffo"]], "FB_MiscStatesErrorFFO_Test": [[2, "fb-miscstateserrorffo-test"]], "FB_MotionBPTM": [[2, "fb-motionbptm"]], "FB_MotionBPTM_Test": [[2, "fb-motionbptm-test"]], "FB_MotionClearAsserts": [[2, "fb-motionclearasserts"]], "FB_MotionClearAsserts_Test": [[2, "fb-motionclearasserts-test"]], "FB_MotionHoming": [[2, "fb-motionhoming"]], "FB_MotionPneumaticActuator": [[2, "fb-motionpneumaticactuator"]], "FB_MotionReadPMPSDBND": [[2, "fb-motionreadpmpsdbnd"]], "FB_MotionReadPMPSDBND_Test": [[2, "fb-motionreadpmpsdbnd-test"]], "FB_MotionRequest": [[2, "fb-motionrequest"]], "FB_MotionStage": [[2, "fb-motionstage"]], "FB_MotionStageNCParams": [[2, "fb-motionstagencparams"]], "FB_MotionStageSim": [[2, "fb-motionstagesim"]], "FB_MotorTestSuite": [[2, "fb-motortestsuite"]], "FB_NcAxis": [[2, "fb-ncaxis"]], "FB_NCErrorFFO": [[2, "fb-ncerrorffo"]], "FB_NCErrorFFO_Test": [[2, "fb-ncerrorffo-test"]], "FB_PerMotorFFOND": [[2, "fb-permotorffond"]], "FB_PerMotorFFOND_Test": [[2, "fb-permotorffond-test"]], "FB_PMPSJsonTestHelper": [[2, "fb-pmpsjsontesthelper"]], "FB_PositionState1D": [[2, "fb-positionstate1d"]], "FB_PositionState1D_InOut": [[2, "fb-positionstate1d-inout"]], "FB_PositionState2D": [[2, "fb-positionstate2d"]], "FB_PositionState2D_InOut": [[2, "fb-positionstate2d-inout"]], "FB_PositionState3D": [[2, "fb-positionstate3d"]], "FB_PositionStateBase": [[2, "fb-positionstatebase"]], "FB_PositionStateBase_WithPMPS": [[2, "fb-positionstatebase-withpmps"]], "FB_PositionStateBase_WithPMPS_Test": [[2, "fb-positionstatebase-withpmps-test"]], "FB_PositionStateInOut": [[2, "fb-positionstateinout"]], "FB_PositionStateInOut_WithPMPS": [[2, "fb-positionstateinout-withpmps"]], "FB_PositionStateInOut_WithPMPS_Test": [[2, "fb-positionstateinout-withpmps-test"]], "FB_PositionStateInternal": [[2, "fb-positionstateinternal"]], "FB_PositionStateInternalND": [[2, "fb-positionstateinternalnd"]], "FB_PositionStateLock": [[2, "fb-positionstatelock"]], "FB_PositionStateManager": [[2, "fb-positionstatemanager"]], "FB_PositionStateMove": [[2, "fb-positionstatemove"]], "FB_PositionStateMove_Test": [[2, "fb-positionstatemove-test"]], "FB_PositionStateMoveND": [[2, "fb-positionstatemovend"]], "FB_PositionStateMoveND_Test": [[2, "fb-positionstatemovend-test"]], "FB_PositionStateND_Core": [[2, "fb-positionstatend-core"]], "FB_PositionStateND_Test": [[2, "fb-positionstatend-test"]], "FB_PositionStatePMPS": [[2, "fb-positionstatepmps"]], "FB_PositionStatePMPS1D": [[2, "fb-positionstatepmps1d"]], "FB_PositionStatePMPS1D_InOut": [[2, "fb-positionstatepmps1d-inout"]], "FB_PositionStatePMPS2D": [[2, "fb-positionstatepmps2d"]], "FB_PositionStatePMPS2D_InOut": [[2, "fb-positionstatepmps2d-inout"]], "FB_PositionStatePMPS3D": [[2, "fb-positionstatepmps3d"]], "FB_PositionStatePMPS_Base": [[2, "fb-positionstatepmps-base"]], "FB_PositionStatePMPS_Test": [[2, "fb-positionstatepmps-test"]], "FB_PositionStatePMPSND_Core": [[2, "fb-positionstatepmpsnd-core"]], "FB_PositionStatePMPSND_Test": [[2, "fb-positionstatepmpsnd-test"]], "FB_PositionStateRead": [[2, "fb-positionstateread"]], "FB_PositionStateRead_Test": [[2, "fb-positionstateread-test"]], "FB_PositionStateReadND": [[2, "fb-positionstatereadnd"]], "FB_PositionStateReadND_Test": [[2, "fb-positionstatereadnd-test"]], "FB_RawCountConverter": [[2, "fb-rawcountconverter"]], "FB_ReadFloatParameter": [[2, "fb-readfloatparameter"]], "FB_ReadParameterInNc_v1_00": [[2, "fb-readparameterinnc-v1-00"]], "FB_SetEnables": [[2, "fb-setenables"]], "FB_Standard_PMPSDB": [[2, "fb-standard-pmpsdb"]], "FB_StatePMPSEnables": [[2, "fb-statepmpsenables"]], "FB_StatePMPSEnables_Test": [[2, "fb-statepmpsenables-test"]], "FB_StatePMPSEnablesND": [[2, "fb-statepmpsenablesnd"]], "FB_StatePMPSEnablesND_Test": [[2, "fb-statepmpsenablesnd-test"]], "FB_StatePTPMove": [[2, "fb-stateptpmove"]], "FB_StateSetupHelper": [[2, "fb-statesetuphelper"]], "FB_StateSetupHelper_Test": [[2, "fb-statesetuphelper-test"]], "FB_StatesInputHandler": [[2, "fb-statesinputhandler"]], "FB_TerminalError": [[2, "fb-terminalerror"]], "FB_TestHelperSetAndMove": [[2, "fb-testhelpersetandmove"]], "FB_TestHelperSetAndMove_Test": [[2, "fb-testhelpersetandmove-test"]], "FB_WriteFloatParameter": [[2, "fb-writefloatparameter"]], "FB_WriteParameterInNc_v1_00": [[2, "fb-writeparameterinnc-v1-00"]], "PRG_TEST": [[2, "prg-test"]], "Settings": [[3, "settings"]], "Pragmas": [[3, "pragmas"], [8, "pragmas"]], "Libraries": [[3, "libraries"]], "Symbols": [[3, "symbols"]], "Boxes": [[4, "boxes"]], "Box Hierarchy": [[5, "box-hierarchy"]], "Links": [[6, "links"]], "NC Settings": [[7, "nc-settings"]], "Axis 3: Axis_PositionStateRead_Test": [[7, "axis-3-axis-positionstateread-test"]], "Axis 4: Axis_AtPositionState_Test": [[7, "axis-4-axis-atpositionstate-test"]], "Axis 5: Axis_TestHelperSetAndMove_Test": [[7, "axis-5-axis-testhelpersetandmove-test"]], "Axis 6: Axis_PositionStateReadND_Test_1": [[7, "axis-6-axis-positionstatereadnd-test-1"]], "Axis 7: Axis_PositionStateReadND_Test_2": [[7, "axis-7-axis-positionstatereadnd-test-2"]], "Axis 8: Axis_PositionStateReadND_Test_3": [[7, "axis-8-axis-positionstatereadnd-test-3"]], "Axis 9: Axis_PositionStateMove_Test": [[7, "axis-9-axis-positionstatemove-test"]], "Axis 10: Axis_PositionStateMoveND_Test_1": [[7, "axis-10-axis-positionstatemovend-test-1"]], "Axis 11: Axis_PositionStateMoveND_Test_2": [[7, "axis-11-axis-positionstatemovend-test-2"]], "Axis 12: Axis_PositionStateMoveND_Test_3": [[7, "axis-12-axis-positionstatemovend-test-3"]], "Axis 13: Axis_PositionStateND_Test_1": [[7, "axis-13-axis-positionstatend-test-1"]], "Axis 14: Axis_PositionStateND_Test_2": [[7, "axis-14-axis-positionstatend-test-2"]], "Axis 15: Axis_PositionStateND_Test_3": [[7, "axis-15-axis-positionstatend-test-3"]], "Axis 16: Axis_NCErrorFFO_Test": [[7, "axis-16-axis-ncerrorffo-test"]], "Axis 17: Axis_PositionStatePMPSND_Test_1": [[7, "axis-17-axis-positionstatepmpsnd-test-1"]], "Axis 18: Axis_PositionStatePMPSND_Test_2": [[7, "axis-18-axis-positionstatepmpsnd-test-2"]], "Axis 19: Axis_PositionStatePMPSND_Test_3": [[7, "axis-19-axis-positionstatepmpsnd-test-3"]], "Axis 20: Axis_StatePMPSEnable_Test": [[7, "axis-20-axis-statepmpsenable-test"]], "Axis 21: Axis_PositionStateReadND_Test_4": [[7, "axis-21-axis-positionstatereadnd-test-4"]], "Axis 22: Axis_PositionStateReadND_Test_5": [[7, "axis-22-axis-positionstatereadnd-test-5"]]}, "indexentries": {}}) \ No newline at end of file diff --git a/versions.json b/versions.json index 68a59839..43944b85 100644 --- a/versions.json +++ b/versions.json @@ -1 +1 @@ -{"folders": ["master", "v1.4.3", "v1.4.4", "v1.5.0", "v1.6.0", "v1.7.0", "v1.8.0", "v2.0.0", "v2.0.1", "v2.1.0", "v2.2.0", "v3.0.0", "v3.0.1", "v4.0.0", "v4.0.1", "v4.0.2"], "default-branch": "master", "labels": {"master": "master", "v1.4.3": "v1.4.3", "v1.4.4": "v1.4.4", "v1.5.0": "v1.5.0", "v1.6.0": "v1.6.0", "v1.7.0": "v1.7.0", "v1.8.0": "v1.8.0", "v2.0.0": "v2.0.0", "v2.0.1": "v2.0.1", "v2.1.0": "v2.1.0", "v2.2.0": "v2.2.0", "v3.0.0": "v3.0.0", "v3.0.1": "v3.0.1", "v4.0.0": "v4.0.0", "v4.0.1": "v4.0.1", "v4.0.2": "v4.0.2 (latest)"}, "versions": ["master", "v4.0.2", "v4.0.1", "v4.0.0", "v3.0.1", "v3.0.0", "v2.2.0", "v2.1.0", "v2.0.1", "v2.0.0", "v1.8.0", "v1.7.0", "v1.6.0", "v1.5.0", "v1.4.4", "v1.4.3"], "warnings": {"master": ["unreleased"], "v1.4.3": ["outdated"], "v1.4.4": ["outdated"], "v1.5.0": ["outdated"], "v1.6.0": ["outdated"], "v1.7.0": ["outdated"], "v1.8.0": ["outdated"], "v2.0.0": ["outdated"], "v2.0.1": ["outdated"], "v2.1.0": ["outdated"], "v2.2.0": ["outdated"], "v3.0.0": ["outdated"], "v3.0.1": ["outdated"], "v4.0.0": ["outdated"], "v4.0.1": ["outdated"], "v4.0.2": []}, "latest": "v4.0.2", "downloads": {"master": [], "v1.4.3": [], "v1.4.4": [], "v1.5.0": [], "v1.6.0": [], "v1.7.0": [], "v1.8.0": [], "v2.0.0": [], "v2.0.1": [], "v2.1.0": [], "v2.2.0": [], "v3.0.0": [], "v3.0.1": [], "v4.0.0": [], "v4.0.1": [], "v4.0.2": []}} \ No newline at end of file +{"folders": ["master", "v1.4.3", "v1.4.4", "v1.5.0", "v1.6.0", "v1.7.0", "v1.8.0", "v2.0.0", "v2.0.1", "v2.1.0", "v2.2.0", "v3.0.0", "v3.0.1", "v4.0.0", "v4.0.1", "v4.0.2", "v4.0.3"], "default-branch": "master", "labels": {"master": "master", "v1.4.3": "v1.4.3", "v1.4.4": "v1.4.4", "v1.5.0": "v1.5.0", "v1.6.0": "v1.6.0", "v1.7.0": "v1.7.0", "v1.8.0": "v1.8.0", "v2.0.0": "v2.0.0", "v2.0.1": "v2.0.1", "v2.1.0": "v2.1.0", "v2.2.0": "v2.2.0", "v3.0.0": "v3.0.0", "v3.0.1": "v3.0.1", "v4.0.0": "v4.0.0", "v4.0.1": "v4.0.1", "v4.0.2": "v4.0.2", "v4.0.3": "v4.0.3 (latest)"}, "versions": ["master", "v4.0.3", "v4.0.2", "v4.0.1", "v4.0.0", "v3.0.1", "v3.0.0", "v2.2.0", "v2.1.0", "v2.0.1", "v2.0.0", "v1.8.0", "v1.7.0", "v1.6.0", "v1.5.0", "v1.4.4", "v1.4.3"], "warnings": {"master": ["unreleased"], "v1.4.3": ["outdated"], "v1.4.4": ["outdated"], "v1.5.0": ["outdated"], "v1.6.0": ["outdated"], "v1.7.0": ["outdated"], "v1.8.0": ["outdated"], "v2.0.0": ["outdated"], "v2.0.1": ["outdated"], "v2.1.0": ["outdated"], "v2.2.0": ["outdated"], "v3.0.0": ["outdated"], "v3.0.1": ["outdated"], "v4.0.0": ["outdated"], "v4.0.1": ["outdated"], "v4.0.2": ["outdated"], "v4.0.3": []}, "latest": "v4.0.3", "downloads": {"master": [], "v1.4.3": [], "v1.4.4": [], "v1.5.0": [], "v1.6.0": [], "v1.7.0": [], "v1.8.0": [], "v2.0.0": [], "v2.0.1": [], "v2.1.0": [], "v2.2.0": [], "v3.0.0": [], "v3.0.1": [], "v4.0.0": [], "v4.0.1": [], "v4.0.2": [], "v4.0.3": []}} \ No newline at end of file