UserLimitInterruptUserDataAddressSet()

void UserLimitInterruptUserDataAddressSet	(	int32_t	number,
		uint32_t	userDataIndex,
		uint64_t	address )

Description:

UserLimitInterruptUserDataAddressSet will allow you to specify set the user data object address that will be recorded when the user limit specified triggers.

Your specified address can be any address, including all RSIAxisAddressType addresses.

Parameters

number	Number of the UserLimit.
userDataIndex	There are only 5 User Data objects. (userDataIndex is zero ordinate and must be a value from 0 to 4)
address	This is the address of the object that you want to keep track of when the User Limit interrupt triggers..

Part of the User Limit method group.

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");
 
// set sample config params
const int AXIS_COUNT = 1;
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);
 
    // configure user limits
    controller.AxisCountSet(AXIS_COUNT);
    controller.UserLimitCountSet(USER_LIMIT_COUNT);
 
    // get axis
    Axis axis = controller.AxisGet(Constants.AXIS_0_INDEX);
    Helpers.CheckErrors(axis);
    Helpers.PhantomAxisReset(axis);
 
    // set the triggered modify values to stop very quickly
    axis.TriggeredModifyDecelerationSet(1000);
    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.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeDIGITAL_INPUTS),
        userLimitMask:    0x400000,
        limitValueUInt32: 0x400000);
 
    // 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);
    axis.MoveVelocity(velocity: 10, accel: 100);
 
    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);
 
    // cleanup
    axis.Abort();
    controller.UserLimitDisable(USER_LIMIT_FIRST);
    controller.UserLimitDisable(USER_LIMIT_SECOND);
 
    Console.WriteLine("\nUser limit command position direct set complete.");
}
// handle errors as needed
finally
{
    controller.Delete();  // dispose
}
 
// 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)
{
    bool done = false;
    int timeout_milliseconds = 100;
    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();
                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;
        }
    }
}

Examples

userlimit-command-position-direct.cs.