InputOutput.cs

 
using RSI.RapidCode.dotNET; // Import our RapidCode Library.
using NUnit.Framework;
using System;
 
[TestFixture]
[Category("Software")]
class InputOutput : SampleAppTestBase
  {
    [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 input0 = IOPoint.CreateDigitalInput(controller.IOGet(NODE_INDEX), INPUT_INDEX); // Automatically gets the memory index of a specified node and input index
      IOPoint output0 = IOPoint.CreateDigitalOutput(controller.IOGet(NODE_INDEX), OUTPUT_INDEX); // Automatically gets the memory index of a specified node and input index
 
      output0.Set(false);
 
      controller.SampleWait(1);
      Assert.False(output0.Get(), "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.False(output0.Get(), "The getter function should return a value equal to false");
      output0.Set(true);
      Assert.True(output0.Get(), "The getter function should return a value equal to true");
      controller.MemorySet(input0.AddressGet(), 0);
      Assert.False(input0.Get(), "The getter function should return a value equal to false");
      controller.MemorySet(input0.AddressGet(), 1);
      Assert.True(input0.Get(), "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.IOGet(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.AreEqual(output0.Get(), true, "The output should be triggered");
        }
        else
        {
          Assert.AreEqual(output0.Get(), false, "The output should NOT be triggered");
        }
      }
 
      axis.StreamingOutputsEnableSet(false);                                                              // Disable Sync Outputs.
      axis.AmpEnableSet(false);                                                                           // Disable the motor.
    }
  }