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..

Remarks

This function is also available in RapidSequencer.

Part of the User Limit method group.

Sample Code:

UserLimitCommandPositionDirectSet

    // Constants
    const int AXIS_COUNT = 1;
    const int USER_LIMIT_FIRST = 0;                                                                     // Specify which user limit to use.
    const int USER_LIMIT_SECOND = 1;
    const int USER_LIMIT_COUNT = 2;
    const RSIUserLimitLogic LOGIC = RSIUserLimitLogic.RSIUserLimitLogicEQ;                              // Logic for input value comparison.
    const RSIUserLimitTriggerType TRIGGER_TYPE = RSIUserLimitTriggerType.RSIUserLimitTriggerTypeSINGLE_CONDITION;       // Choose the how the condition (s) should be evaluated. 
    const RSIAction ACTION = RSIAction.RSIActionTRIGGERED_MODIFY;                                       // Choose the action you want to cause when the User Limit triggers.
 
    const int DURATION = 0;                                                                             // Enter the time delay before the action is executed after the User Limit has triggered.
    const bool ONE_SHOT = true;                                                                         // if true, User Limit will only trigger ONCE
 
    // User Limit Interrupt constants
    const int COMMAND_POSITION_INDEX = 0;
    const int ACTUAL_POSITION_INDEX = 1;
    const int TC_COMMAND_POSITION_INDEX = 2;
    const int TC_ACTUAL_POSITION_INDEX = 3;
 
    public void UserLimitCommandPositionDirectSet()
    {
      // Some Necessary Pre User Limit Configuration
      controller.AxisCountSet(AXIS_COUNT);
      controller.UserLimitCountSet(USER_LIMIT_COUNT);   // Set the amount of UserLimits that you want to use.
      axis = CreateAndReadyAxis(Constants.AXIS_NUMBER); // Initialize your axis object.
 
      // set the triggered modify values to stop very quickly
      axis.TriggeredModifyDecelerationSet(Constants.DECELERATION);
      axis.TriggeredModifyJerkPercentSet(Constants.JERK_PERCENT);
 
      // USER LIMIT CONDITION 0 (trigger on digital input)
      controller.UserLimitConditionSet(USER_LIMIT_FIRST, 0, LOGIC, axis.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeDIGITAL_INPUTS), 0x400000, 0x400000); // Set your User Limit Condition (1st step to setting up your user limit)
 
      // controller.UserLimitOutputSet(USER_LIMIT_FIRST, RSIDataType.RSIDataTypeDOUBLE,  axis.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeTC_ACTUAL_POSITION), controller.AddressGet(RSIControllerAddressType.RSIControllerAddressTypeUSER_BUFFER), true);
 
      controller.UserLimitConfigSet(USER_LIMIT_FIRST, TRIGGER_TYPE, ACTION, axis.NumberGet(), DURATION, ONE_SHOT); // Set your User Limit Configuration. (2nd step to setting up your user limit)
 
      // CONDITION 0  (wait for first user limit to trigger)
      controller.UserLimitConditionSet(USER_LIMIT_SECOND, 0, RSIUserLimitLogic.RSIUserLimitLogicEQ, controller.AddressGet(RSIControllerAddressType.RSIControllerAddressTypeUSERLIMIT_STATUS, USER_LIMIT_FIRST), 1, 1);
 
      // CONDITION 1 (AND wait for Axis command velcity = 0.0)
      controller.UserLimitConditionSet(USER_LIMIT_SECOND, 1, RSIUserLimitLogic.RSIUserLimitLogicEQ, axis.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeCOMMAND_VELOCITY), 0.0);
 
      // OUTPUT (copy value from UserBuffer to TC.CommandPosition when trigered)
      //controller.UserLimitOutputSet(USER_LIMIT_SECOND, RSIDataType.RSIDataTypeDOUBLE, controller.AddressGet(RSIControllerAddressType.RSIControllerAddressTypeUSER_BUFFER), axis.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeTC_COMMAND_POSITION), true);
      controller.UserLimitConfigSet(USER_LIMIT_SECOND, RSIUserLimitTriggerType.RSIUserLimitTriggerTypeCONDITION_AND, RSIAction.RSIActionNONE, 0, 0, ONE_SHOT);
 
      // get the Axis moving
      axis.ClearFaults();
      axis.AmpEnableSet(true);
      axis.MoveVelocity(Constants.VELOCITY, Constants.ACCELERATION);
 
      // configure and enable interrupts
      ConfigureUserLimitInterrupts(USER_LIMIT_FIRST);
      ConfigureUserLimitInterrupts(USER_LIMIT_SECOND);
      controller.InterruptEnableSet(true);
 
      // wait for (and print) interrupts
      WaitForInterrupts();
    }
 
    public void ConfigureUserLimitInterrupts(int userLimitIndex)
    {
      controller.UserLimitInterruptUserDataAddressSet(userLimitIndex, COMMAND_POSITION_INDEX, axis.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeCOMMAND_POSITION));
      controller.UserLimitInterruptUserDataAddressSet(userLimitIndex, ACTUAL_POSITION_INDEX, axis.AddressGet(RSIAxisAddressType.RSIAxisAddressTypeACTUAL_POSITION));
    }
 
    public void WaitForInterrupts()
    {
      bool done = false;
      int timeout_millseconds = 10;
 
      while (!done)
      {
        RSIEventType eventType = controller.InterruptWait(timeout_millseconds);
 
        Console.WriteLine("IRQ: " + eventType.ToString() + " at sample " + controller.InterruptSampleTimeGet());
 
        switch (eventType)
        {
          case RSIEventType.RSIEventTypeUSER_LIMIT:
            Console.WriteLine("UserLimit " + controller.InterruptSourceNumberGet());
            Console.WriteLine("CmdPos: " + controller.InterruptUserDataDoubleGet(COMMAND_POSITION_INDEX));
            Console.WriteLine("ActPos: " + controller.InterruptUserDataDoubleGet(ACTUAL_POSITION_INDEX));
            Console.WriteLine("TC.CmdPos: " + controller.InterruptUserDataDoubleGet(TC_COMMAND_POSITION_INDEX));
            Console.WriteLine("TC.ActPos: " + controller.InterruptUserDataDoubleGet(TC_ACTUAL_POSITION_INDEX));
            break;
          case RSIEventType.RSIEventTypeTIMEOUT:
            done = true;
            break;
          default:
            break;
        }
      }
    }