using NUnit.Framework;
using System;
[TestFixture]
[Category("Software")]
public class UserLimit : StaticMemoryTestBase
{
[Test]
public void UserLimitDigitalInputOneCondition()
{
const int INPUT_INDEX = 0;
const int OUTPUT_INDEX = 1;
controller.AxisCountSet(1);
controller.UserLimitCountSet(1);
controller.InterruptEnableSet(true);
IOPoint input0 = IOPoint.CreateDigitalInput(controller, userBufferAddress, INPUT_INDEX);
IOPoint output0 = IOPoint.CreateDigitalOutput(controller, userBufferAddress, OUTPUT_INDEX);
int userLimitNumber = 0;
int condition = 0;
UInt64 inputAddress = input0.AddressGet();
uint test = (uint)input0.MaskGet();
uint inputMask = (uint)input0.MaskGet();
uint limtValue = (uint)input0.MaskGet();
controller.UserLimitConditionSet(userLimitNumber,
condition,
logic,
inputAddress,
inputMask,
limtValue);
int axisNumber = 0;
int duration = 0;
controller.UserLimitConfigSet(userLimitNumber,
triggerType,
action,
axisNumber,
duration);
uint andMask = (uint)output0.MaskGet();
uint orMask = (uint)output0.MaskGet();
UInt64 outputAddress = output0.AddressGet();
bool enableOutput = true;
controller.UserLimitOutputSet(userLimitNumber,
andMask,
orMask,
outputAddress,
enableOutput);
while (controller.InterruptWait(250) !=
RSIEventType.RSIEventTypeUSER_LIMIT)
{
Assert.False(output0.Get(), "We expect the output to NOT be triggered");
controller.MemorySet(input0.AddressGet(), 1);
}
Assert.True(output0.Get(), "We expect the output to be triggered");
controller.UserLimitDisable(userLimitNumber);
output0.Set(false);
}
[Test]
public void UserLimitDigitalInputTwoCondition()
{
const int INPUT_INDEX0 = 0;
const int INPUT_INDEX1 = 1;
const int OUTPUT_INDEX = 2;
controller.AxisCountSet(1);
controller.UserLimitCountSet(1);
controller.InterruptEnableSet(true);
int userLimitNumber = 0;
IOPoint input0 = IOPoint.CreateDigitalInput(controller, userBufferAddress, INPUT_INDEX0);
IOPoint input1 = IOPoint.CreateDigitalInput(controller, userBufferAddress, INPUT_INDEX1);
IOPoint output0 = IOPoint.CreateDigitalOutput(controller, userBufferAddress, OUTPUT_INDEX);
int condition0 = 0;
UInt64 input0Address = input0.AddressGet();
uint input0Mask = (uint)input0.MaskGet();
uint limitValue0 = (uint)input0.MaskGet();
int condition1 = 1;
UInt64 input1Address = input1.AddressGet();
uint input1Mask = (uint)input1.MaskGet();
uint limitValue1 = (uint)input1.MaskGet();
controller.UserLimitConditionSet(userLimitNumber,
condition0,
logic,
input0Address,
input0Mask,
limitValue0);
controller.UserLimitConditionSet(userLimitNumber,
condition1,
logic,
input1Address,
input1Mask,
limitValue1);
int axis = 0;
int duration = 0;
controller.UserLimitConfigSet(userLimitNumber,
triggerType,
action,
axis,
duration);
uint andMask = (uint)output0.MaskGet();
uint orMask = (uint)output0.MaskGet();
UInt64 outputAddress = output0.AddressGet();
bool enableOutput = true;
controller.UserLimitOutputSet(userLimitNumber,
andMask,
orMask,
outputAddress,
enableOutput);
while (controller.InterruptWait(250) !=
RSIEventType.RSIEventTypeUSER_LIMIT)
{
Assert.False(output0.Get(), "We expect the output to NOT be triggered");
controller.MemorySet(input0.AddressGet(), 1);
Assert.False(output0.Get(), "We expect the output to NOT be triggered");
controller.MemorySet(input0.AddressGet(), 2);
Assert.False(output0.Get(), "We expect the output to NOT be triggered");
controller.MemorySet(input0.AddressGet(), 3);
}
Assert.True(output0.Get(), "We expect the output to be triggered");
}
[Test]
public void UserLimitDigitalInputEStopStorePosition()
{
const int AXIS_INDEX = 0;
const int INPUT_INDEX = 0;
const int AXIS_COUNT = 1;
const int USER_LIMIT = 0;
const int CONDITION = 0;
const int LIMIT_VALUE = 1;
const double DURATION = 0.125;
const int USER_DATA_INDEX = 0;
controller.AxisCountSet(1);
controller.UserLimitCountSet(1);
controller.InterruptEnableSet(true);
IOPoint input0 = IOPoint.CreateDigitalInput(controller, userBufferAddress, INPUT_INDEX);
axis = CreateAndReadyAxis(Constants.AXIS_NUMBER);
axis.MoveVelocity(10.0, 20.0);
controller.UserLimitConditionSet(USER_LIMIT, CONDITION, LOGIC, input0.AddressGet(), (uint)input0.MaskGet(), LIMIT_VALUE);
controller.UserLimitConfigSet(USER_LIMIT, TRIGGER_TYPE, ACTION, AXIS_INDEX, DURATION);
controller.UserLimitInterruptUserDataAddressSet(USER_LIMIT,
USER_DATA_INDEX,
while (controller.InterruptWait(250) !=
RSIEventType.RSIEventTypeUSER_LIMIT)
{
controller.MemorySet(input0.AddressGet(), 1);
}
int triggeredUserLimit = controller.InterruptSourceNumberGet() - AXIS_COUNT;
double interruptPosition = controller.InterruptUserDataDoubleGet(USER_DATA_INDEX);
Console.WriteLine("TRIGGERED - User Limit Interrupt Position = " + interruptPosition / axis.UserUnitsGet());
controller.UserLimitDisable(USER_LIMIT);
}
[Test]
public void UserLimitFeedRate()
{
const int USER_LIMIT = 0;
const int USER_LIMIT_COUNT = 1;
const int AXIS_COUNT = 1;
const int CONDITION = 0;
const double POSITION_TRIGGER_VALUE = 5;
const int DURATION = 0;
const double DEFAULT_FEED_RATE = 1.0;
const double DESIRED_FEED_RATE = 2.0;
UInt64 feedRateAddress;
controller.AxisCountSet(AXIS_COUNT);
controller.UserLimitCountSet(USER_LIMIT_COUNT);
axis = CreateAndReadyAxis(Constants.AXIS_NUMBER);
axis.FeedRateSet(DEFAULT_FEED_RATE);
controller.UserLimitConditionSet(USER_LIMIT, CONDITION, LOGIC, axis.AddressGet(
RSIAxisAddressType.RSIAxisAddressTypeCOMMAND_POSITION), POSITION_TRIGGER_VALUE);
controller.UserLimitConfigSet(USER_LIMIT, TRIGGER_TYPE, ACTION, axis.NumberGet(), DURATION);
controller.UserLimitOutputSet(USER_LIMIT, DESIRED_FEED_RATE, feedRateAddress, true);
Assert.AreEqual(DEFAULT_FEED_RATE, axis.FeedRateGet(), "We expect the feedrate to be default");
axis.MoveSCurve(POSITION_TRIGGER_VALUE + 1);
axis.MotionDoneWait();
Assert.AreEqual(DESIRED_FEED_RATE, axis.FeedRateGet(), "We expect the feedrate to be changed");
}
[Test]
public void UserLimitPositionOneCondition()
{
const int AXIS_COUNT = 1;
const int USER_LIMIT_COUNT = 1;
const int USER_LIMIT_NUMBER = 0;
const double TRIGGER_POSITION = 0.05;
const double MOVE_POSITION = 1.0;
const int OUTPUT_INDEX = 1;
const int WAIT_FOR_TRIGGER_MILLISECONDS = 100;
controller.AxisCountSet(AXIS_COUNT);
controller.UserLimitCountSet(USER_LIMIT_COUNT);
controller.InterruptEnableSet(true);
IOPoint output0 = IOPoint.CreateDigitalOutput(controller, userBufferAddress, OUTPUT_INDEX);
output0.Set(false);
axis = CreateAndReadyAxis(Constants.AXIS_NUMBER);
int condition = 0;
double limitValue = TRIGGER_POSITION;
controller.UserLimitConditionSet(USER_LIMIT_NUMBER,
condition,
limitValue);
int duration = 0;
controller.UserLimitConfigSet(USER_LIMIT_NUMBER,
triggerType,
action,
axis.NumberGet(),
duration);
uint andMask = (uint)output0.MaskGet();
uint orMask = (uint)output0.MaskGet(); ;
UInt64 outputAddress = output0.AddressGet();
bool enableOutput = true;
controller.UserLimitOutputSet(USER_LIMIT_NUMBER,
andMask,
orMask,
outputAddress,
enableOutput);
Assert.False(output0.Get(), "We expect the output to NOT be triggered");
axis.MoveSCurve(MOVE_POSITION);
RSIEventType interruptType = controller.InterruptWait(WAIT_FOR_TRIGGER_MILLISECONDS);
{
Assert.That(controller.InterruptSourceNumberGet(), Is.EqualTo(USER_LIMIT_NUMBER + AXIS_COUNT), "We got a USER_LIMIT interrupt but it was the wrong one.");
Assert.True(output0.Get(), "We expect the output to be turned on when the user limit triggers.");
}
else
{
Assert.Fail("We expected a USER_LIMIT interrupt when the trigger position was exceeded but instead got " + interruptType.ToString());
}
axis.AmpEnableSet(false);
controller.UserLimitDisable(USER_LIMIT_NUMBER);
output0.Set(false);
}
}