userlimit-command-position-direct.cs

Note

See IO: User Limits 📜 for a detailed explanation of this sample code.

Warning

This is a sample program to assist in the integration of the RMP motion controller with your application. It may not contain all of the logic and safety features that your application requires. We recommend that you wire an external hardware emergency stop (e-stop) button for safety when using our code sample apps. Doing so will help ensure the safety of you and those around you and will prevent potential injury or damage.

The sample apps assume that the system (network, axes, I/O) are configured prior to running the code featured in the sample app. See the Configuration page for more information.

/*  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;
        }
    }
}