InputOutput.cs

 
using RSI.RapidCode.dotNET; // Import our RapidCode Library.
using NUnit.Framework;
using System;
 
#if DOXYGEN 
// needed for docs generation
using RSI.RapidCode;
#else
// needed for project to compile (NetworkNode alias maps to RapidCodeNetworkNode for Doxygen)
using NetworkNode = RSI.RapidCode.dotNET.RapidCodeNetworkNode;
#endif
 
[TestFixture]
[Category("Software")]
class InputOutput : SampleAppTestBase
{
 
  [Test, Timeout(Constants.MAX_TEST_TIME)]
  [Ignore("Needs a network with a real node to run, but we want the snippet for docs.  At least it's compiled!")]
  public void GeneralPurposeIO()
  {
    Assert.DoesNotThrow(() =>
    {
      const int nodeIndex = 0;
      const int digitalInIndex = 0;
      const int digitalOutIndex = 0;
      const int analogIndex = 0;
 
      // get node
      NetworkNode node = controller.NetworkNodeGet(nodeIndex);
      HelperFunctions.CheckErrors(node);
 
      // digital io
      bool dIn = node.DigitalInGet(digitalInIndex);
      bool dOut = node.DigitalOutGet(digitalOutIndex);
      node.DigitalOutSet(digitalOutIndex, true);
 
      // analog io
      int aIn = node.AnalogInGet(analogIndex);
      int aOut = node.AnalogOutGet(analogIndex);
      node.AnalogOutSet(analogIndex, 1234);
    });
  }
 
  [Test, Timeout(Constants.MAX_TEST_TIME)]
  public void DedicatedIO()
  {
    // Retrieve dedicated inputs with generic and specific function.
    Console.WriteLine("RSIMotorDedicatedInLIMIT_HW_NEG: {0} and {1}",
                        axis.DedicatedInGet(RSIMotorDedicatedIn.RSIMotorDedicatedInLIMIT_HW_NEG),
                        axis.NegativeLimitGet());
 
    Console.WriteLine("RSIMotorDedicatedInLIMIT_HW_POS: {0} and {1}",
                        axis.DedicatedInGet(RSIMotorDedicatedIn.RSIMotorDedicatedInLIMIT_HW_POS),
                        axis.PositiveLimitGet());
 
    Console.WriteLine("RSIMotorDedicatedInHOME: {0} and {1}",
                        axis.DedicatedInGet(RSIMotorDedicatedIn.RSIMotorDedicatedInHOME),
                        axis.HomeSwitchGet());
 
    Console.WriteLine("RSIMotorDedicatedInAMP_FAULT: {0} and {1}",
                        axis.DedicatedInGet(RSIMotorDedicatedIn.RSIMotorDedicatedInAMP_FAULT),
                        axis.AmpFaultGet());
 
    Console.WriteLine("RSIMotorDedicatedInAMP_ACTIVE: {0} and {1}",
                        axis.DedicatedInGet(RSIMotorDedicatedIn.RSIMotorDedicatedInAMP_ACTIVE),
                        axis.AmpEnableGet());
  }
 
  [Test, Timeout(Constants.MAX_TEST_TIME)]
  public void NetworkInputsAndOutputs()
  {
    // Get Input Values
    int inputCount = controller.NetworkInputCountGet();                         // Get number of Network Inputs (PDOs)
 
    for (int i = 0; i < inputCount; i++)
    {
      int size = controller.NetworkInputBitSizeGet(i);     // Read Input BitSize
      int offset = controller.NetworkInputBitOffsetGet(i); // Read Input BitOffset
      string name = controller.NetworkInputNameGet(i);     // Read Input Name
      UInt64 value = controller.NetworkInputValueGet(i);   // Read Input Value
    }
 
    // Get Output Values
    int outputCount = controller.NetworkOutputCountGet();    // Get number of Network Outputs (SDOs)
 
    for (int i = 0; i < outputCount; i++)
    {
      int size = controller.NetworkOutputBitSizeGet(i);       // Read Output BitSize
      int offset = controller.NetworkOutputBitOffsetGet(i);   // Read Output BitOffset
      string name = controller.NetworkOutputNameGet(i);       // Read Output Name
      UInt64 value = controller.NetworkOutputSentValueGet(i); // Read Output Value
      controller.NetworkOutputOverrideValueSet(i, value);
    }
  }
 
 
  //TODO expand examples once iopoint is expanded.
  [Test]
  public void IOPoints()
  {
    const int NODE_INDEX = 0;   // The EtherCAT Node we will be communicating with
                                //const int INPUT_INDEX = 0; // The PDO Index in that Node
    const int OUTPUT_INDEX = 0; // The PDO Index in that Node
 
    IOPoint output0 = IOPoint.CreateDigitalOutput(controller.NetworkNodeGet(NODE_INDEX), OUTPUT_INDEX); // Automatically gets the memory index of a specified node and input index
 
    output0.Set(false);
 
    controller.SampleWait(1);
    Assert.That(output0.Get(), Is.False, "The getter function should return a value equal to false");
  }
 
  //TODO expand examples once iopoint is expanded.
  [Test]
  public void IOPointUserBuffer()
  {
    const int INPUT_INDEX = 0;
    const int OUTPUT_INDEX = 1; // The PDO Index in that Node
 
    UInt64 userBufferAddress = controller.AddressGet(RSIControllerAddressType.RSIControllerAddressTypeUSER_BUFFER, 0); // Grabing an memory address to store a simulated IO point.
 
    IOPoint input0 = IOPoint.CreateDigitalInput(controller, userBufferAddress, INPUT_INDEX);    // Automatically gets the memory index of a specified node and input index
    IOPoint output0 = IOPoint.CreateDigitalOutput(controller, userBufferAddress, OUTPUT_INDEX); // Automatically gets the memory index of a specified node and input index
 
    //---ACT/ASSERT---
    output0.Set(false);
    Assert.That(output0.Get(), Is.False, "The getter function should return a value equal to false");
    output0.Set(true);
    Assert.That(output0.Get(), Is.True, "The getter function should return a value equal to true");
    controller.MemorySet(input0.AddressGet(), 0);
    Assert.That(input0.Get(), Is.False, "The getter function should return a value equal to false");
    controller.MemorySet(input0.AddressGet(), 1);
    Assert.That(input0.Get(), Is.True, "The getter function should return a value equal to true");
  }
 
  [Test]
  public void SingleAxisSyncOutputs()
  {
    const int TOTAL_POINTS = 4;                  // total number of points
    const int EMPTY_CT = -1;                     // Number of points that remains in the buffer before an e-stop
    const int OUTPUT_INDEX = 0;                  // This is the index of the digital output that will go active when the user limit triggers.
    const int NODE_INDEX = 0;                    // The EtherCAT Node we will be communicating with
 
    double[] positions = { 1.0, 2.0, 3.0, 4.0 }; // These will be the streaming motion 5 positions.
    double[] times = { 0.5, 0.1, 0.2, 0.4 };     // These will be the streaming motion 5 positions' time. 
    int outputEnableID = 2;                      // The motion element ID at which to set the output
    int outputDisableID = 3;                     // The motion element ID at which to set the output
 
    // Set up the inputs
    // IOPoint output0 = IOPoint.CreateDigitalOutput(axis, RSIMotorGeneralIo.RSIMotorGeneralIo16);      // Retrieve DOUT 1, Method 1: requires you know the io adress in memory, slightly faster
    IOPoint output0 = IOPoint.CreateDigitalOutput(controller.NetworkNodeGet(NODE_INDEX), OUTPUT_INDEX); // Retrieve DOUT 1  Method 2: only need to know node index
    output0.Set(false); // Set the output low
 
    // Set up Sync Outputs
    axis.StreamingOutputsEnableSet(true);                                                               // Enable streaming output.
 
    // ENABLE the Sync Output(s)
    axis.StreamingOutputAdd(output0, true, outputEnableID);                                             // This will turn DOUT1 High when the streaming motion reaches its 3rd motion point.
    axis.StreamingOutputAdd(output0, false, outputDisableID);                                           // This will turn DOUT1 Low when the streaming motion reaches its 4th motion point.
 
    // DISABLE the Sync Output(s)
    // axis.StreamingOutputAdd(output0, false, outPutEnableID);
 
    axis.MovePT(RSIMotionType.RSIMotionTypePT, positions, times, TOTAL_POINTS, EMPTY_CT, false, true);  // Start Streaming Motion
 
    while (!axis.MotionDoneGet())
    {
      if (axis.MotionIdExecutingGet() > outputEnableID && axis.CommandPositionGet() < outputEnableID)
      {
        Assert.That(output0.Get(), Is.EqualTo(true), "The output should be triggered");
      }
      else
      {
        Assert.That(output0.Get(), Is.EqualTo(false), "The output should NOT be triggered");
      }
    }
 
    axis.StreamingOutputsEnableSet(false);                                                              // Disable Sync Outputs.
    axis.AmpEnableSet(false);                                                                           // Disable the motor.
  }
}