InterruptUserDataGet()

uint64_t InterruptUserDataGet ( uint32_t userDataIndex )

inherited

Description:

InterruptUserDataGet returns the user data from the interrupt

Returns

(uint64) User data.

Sample Code:

IO: User Limits

/*  This sample demonstrates using two user limits in sequence.
    First user limit: triggers on digital input, executes triggered modify to decelerate, stores position.
    Second user limit: triggers when first completes and axis is idle, directly sets command position.
    This is an advanced example of coordinating multiple user limits.
*/
 
using RSI.RapidCode; // RSI.RapidCode.dotNET;
 
Console.WriteLine("📜 User Limit: Command Position Direct Set");
 
int exitCode = 0;
 
// set sample config params
const int USER_LIMIT_FIRST = 0;
const int USER_LIMIT_SECOND = 1;
const int USER_LIMIT_COUNT = 2;
const int DURATION = 0;
const bool ONE_SHOT = true;  // user limit triggers only once
 
// user limit interrupt constants
const int COMMAND_POSITION_INDEX = 0;
const int ACTUAL_POSITION_INDEX = 1;
 
// get rmp objects
MotionController controller = MotionController.Get();
 
try
{
    Helpers.CheckErrors(controller);
 
    Helpers.VerifyHardwareUsage(controller);
    Helpers.VerifyAxisCount(controller);
 
    int initialAxisCount = controller.AxisCountGet();
 
    // configure user limits
    controller.UserLimitCountSet(USER_LIMIT_COUNT);
 
    // get axis
    Axis axis = controller.AxisGet(Constants.AXIS_0_INDEX);
    Helpers.CheckErrors(axis);
    if (!Constants.USE_HARDWARE) Helpers.PhantomAxisReset(axis);
 
    // set the triggered modify values to stop very quickly
    axis.TriggeredModifyDecelerationSet(20);
    axis.TriggeredModifyJerkPercentSet(50);
 
    /*
    ┌──────────────────┐
    │ FIRST USER LIMIT │
    └──────────────────┘
    */
    // condition 0: trigger on digital input
    controller.UserLimitConditionSet(
        number:           USER_LIMIT_FIRST,
        conditionNumber:  0,
        logic:            RSIUserLimitLogic.RSIUserLimitLogicEQ,
        addressOfUInt32:  axis.NetworkNode.DigitalInAddressGet(0),
        userLimitMask:    (uint) axis.NetworkNode.DigitalInMaskGet(1),
        limitValueUInt32: (uint) axis.NetworkNode.DigitalInMaskGet(1));
 
    // configuration: cause a triggered_modify action on the axis
    controller.UserLimitConfigSet(
        number:      USER_LIMIT_FIRST,
        triggerType: RSIUserLimitTriggerType.RSIUserLimitTriggerTypeSINGLE_CONDITION,
        action:      RSIAction.RSIActionTRIGGERED_MODIFY,
        actionAxis:  axis.NumberGet(),
        duration:    DURATION,
        singleShot:  ONE_SHOT);
 
    /*
    ┌───────────────────┐
    │ SECOND USER LIMIT │
    └───────────────────┘
    */
    // condition 0: wait for first user limit to trigger
    controller.UserLimitConditionSet(
        number:           USER_LIMIT_SECOND,
        conditionNumber:  0,
        logic:            RSIUserLimitLogic.RSIUserLimitLogicEQ,
        addressOfUInt32:  controller.AddressGet(RSIControllerAddressType.RSIControllerAddressTypeUSERLIMIT_STATUS, USER_LIMIT_FIRST),
        userLimitMask:    1,
        limitValueUInt32: 1);
 
    // condition 1: AND wait for axis command velocity = 0.0
    controller.UserLimitConditionSet(
        number:           USER_LIMIT_SECOND,
        conditionNumber:  1,
        logic:            RSIUserLimitLogic.RSIUserLimitLogicEQ,
        addressOfDouble:  axis.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeCOMMAND_VELOCITY),
        limitValueDouble: 0.0);
 
    // configuration: no action, just monitoring
    controller.UserLimitConfigSet(
        number:      USER_LIMIT_SECOND,
        triggerType: RSIUserLimitTriggerType.RSIUserLimitTriggerTypeCONDITION_AND,
        action:      RSIAction.RSIActionNONE,
        actionAxis:  0,
        duration:    0,
        singleShot:  ONE_SHOT);
 
    // start motion
    axis.ClearFaults();
    axis.AmpEnableSet(true, Constants.AMP_ENABLE_MS);
    axis.MoveVelocity(velocity: 10, accel: 20);
 
    Console.WriteLine("Axis moving... waiting for user limit triggers");
 
    // configure and enable interrupts
    ConfigureUserLimitInterrupts(controller, axis, USER_LIMIT_FIRST);
    ConfigureUserLimitInterrupts(controller, axis, USER_LIMIT_SECOND);
    controller.InterruptEnableSet(true);
 
    // wait for and display interrupts
    WaitForInterrupts(controller, initialAxisCount);
 
    // cleanup
    axis.Abort();
    controller.UserLimitDisable(USER_LIMIT_FIRST);
    controller.UserLimitDisable(USER_LIMIT_SECOND);
 
    axis.ClearFaults();
 
    Console.WriteLine("\nUser limit command position direct set complete.");
 
    exitCode = Constants.EXIT_SUCCESS;
}
// handle errors as needed
catch (Exception e)
{
    Console.WriteLine($"❌ Error: {e.Message}");
    exitCode = Constants.EXIT_FAILURE;
}
finally
{
    controller.Delete();  // dispose
}
 
return exitCode;
 
// configure interrupt user data addresses for a user limit
void ConfigureUserLimitInterrupts(MotionController controller, Axis axis, int userLimitIndex)
{
    controller.UserLimitInterruptUserDataAddressSet(
        number:        userLimitIndex,
        userDataIndex: COMMAND_POSITION_INDEX,
        address:       axis.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeCOMMAND_POSITION));
    
    controller.UserLimitInterruptUserDataAddressSet(
        number:        userLimitIndex,
        userDataIndex: ACTUAL_POSITION_INDEX,
        address:       axis.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeACTUAL_POSITION));
}
 
// wait for and display user limit interrupts
void WaitForInterrupts(MotionController controller, int initialAxisCount)
{
    bool done = false;
    int timeout_milliseconds = 3000;
    int interruptCount = 0;
 
    while (!done)
    {
        RSIEventType eventType = controller.InterruptWait(timeout_milliseconds);
 
        if (eventType != RSIEventType.RSIEventTypeTIMEOUT)
        {
            interruptCount++;
            Console.WriteLine($"\nInterrupt {interruptCount}: {eventType} at sample {controller.InterruptSampleTimeGet()}");
        }
 
        switch (eventType)
        {
            case RSIEventType.RSIEventTypeUSER_LIMIT:
                int userLimitNum = controller.InterruptSourceNumberGet() - initialAxisCount;
                double cmdPos = controller.InterruptUserDataDoubleGet(COMMAND_POSITION_INDEX);
                double actPos = controller.InterruptUserDataDoubleGet(ACTUAL_POSITION_INDEX);
 
                Console.WriteLine($"  UserLimit: {userLimitNum}");
                Console.WriteLine($"  Command Position: {cmdPos}");
                Console.WriteLine($"  Actual Position: {actPos}");
                break;
 
            case RSIEventType.RSIEventTypeTIMEOUT:
                done = true;
                Console.WriteLine($"\n✓ Completed - received {interruptCount} interrupts");
                break;
 
            default:
                break;
        }
    }
}

See also

UserLimitInterruptUserDataAddressSet