HelperFunctionsCS.cs

 
using RSI.RapidCode.dotNET; // Import our RapidCode Library
using System;
 
#if DOXYGEN // RSI internal documentation use only
using RSI.RapidCode;
using RSI.RapidCode.Cartesian; 
#endif
 
public static class HelperFunctionsCS
{
  public static void CheckErrors(RapidCodeObject rsiObject)
  {
    bool hasErrors = false;
    System.Text.StringBuilder errorStringBuilder = new System.Text.StringBuilder();
    while (rsiObject.ErrorLogCountGet() > 0)
    {
      RsiError error = rsiObject.ErrorLogGet();
 
      if (error.isWarning)
      {
        errorStringBuilder.AppendLine("WARNING: " + error.Message);
      }
      else
      {
        hasErrors = true;
        errorStringBuilder.AppendLine("ERROR: " + error.Message);
      }
    }
 
    if (hasErrors)
    {
      throw new Exception(errorStringBuilder.ToString());
    }
  }
 
  public static void StartTheNetwork(MotionController controller)
  {
    // Initialize the Network
    if (controller.NetworkStateGet() != RSINetworkState.RSINetworkStateOPERATIONAL) // Check if network is started already.
    {
      Console.WriteLine("Starting Network..");
      controller.NetworkStart();                                                    // If not. Initialize The Network. (This can also be done from RapidSetup Tool)
    }
 
    if (controller.NetworkStateGet() != RSINetworkState.RSINetworkStateOPERATIONAL) // Check if network is started again.
    {
      int messagesToRead = controller.NetworkLogMessageCountGet();                  // Some kind of error starting the network, read the network log messages
 
      for (int i = 0; i < messagesToRead; i++)
      {
        Console.WriteLine(controller.NetworkLogMessageGet(i));                      // Print all the messages to help figure out the problem
      }
      throw new SystemException("Expected OPERATIONAL state but the network did not get there.");
    }
    else                                                                            // Else, of network is operational.
    {
      Console.WriteLine("Network Started");
    }
  }
 
  public static void ShutdownTheNetwork(MotionController controller)
  {
    // Check if the network is already shutdown
    if (controller.NetworkStateGet() == RSINetworkState.RSINetworkStateUNINITIALIZED ||
      controller.NetworkStateGet() == RSINetworkState.RSINetworkStateSHUTDOWN)
    {
      return;
    }
 
    // Shutdown the network
    Console.WriteLine("Shutting down the network..");
    controller.NetworkShutdown();
    if (controller.NetworkStateGet() != RSINetworkState.RSINetworkStateUNINITIALIZED &&
      controller.NetworkStateGet() != RSINetworkState.RSINetworkStateSHUTDOWN)              // Check if the network is shutdown.
    {
      int messagesToRead = controller.NetworkLogMessageCountGet();                          // Some kind of error shutting down the network, read the network log messages
 
      for (int i = 0; i < messagesToRead; i++)
      {
        Console.WriteLine(controller.NetworkLogMessageGet(i));                              // Print all the messages to help figure out the problem
      }
      throw new SystemException("Expected SHUTDOWN state but the network did not get there.");
    }
    else                                                                                    // Else, of network is shutdown.
    {
      Console.WriteLine("Network Shutdown");
    }
  }
 
  public static void SetupControllerForHardware(MotionController controller)
  {
    ShutdownTheNetwork(controller);
    controller.Reset();                   // Reset the controller to ensure it is in a known state.
    StartTheNetwork(controller);
  }
 
  public static void ClearControllerCounts(MotionController controller)
  {
    // Clear the counts
    controller.AxisCountSet(0);
    controller.MotionCountSet(0);
    controller.UserLimitCountSet(0);
  }
 
  public static void SetupControllerForPhantoms(MotionController controller, int axisCount, int[] axisNums)
  {
    ShutdownTheNetwork(controller);
 
    ClearControllerCounts(controller);
 
    controller.AxisCountSet(axisCount);
    foreach (int axisNum in axisNums)
    {
      ConfigurePhantomAxis(controller, axisNum);
    }
  }
  
  public static MotionController CreateController()
  {
    MotionController.CreationParameters creationParameters = App.GetCreationParameters();
    return MotionController.Create(creationParameters);
  } 
 
  public static MotionController CreateController(string rmpPath)
  {
    MotionController.CreationParameters creationParameters = App.GetCreationParameters();
    creationParameters.RmpPath = rmpPath;
    return MotionController.Create(creationParameters);
  }
 
  public static void ConfigurePhantomAxis(MotionController controller, int axisNumber)
  {
    // Check if the axis number is valid
    if (axisNumber < 0)
    {
      throw new SystemException("Error: " + axisNumber.ToString() + " is invalid. Axis numbers cannot be negative.");
    }
 
    if (axisNumber >= controller.AxisCountGet())
    {
      throw new SystemException("Error: " + axisNumber.ToString() + " is invalid. Axis numbers cannot be greater than the number of axes on the controller.");
    }
 
    // Configure the specified axis as a phantom axis
    Axis axis = controller.AxisGet(axisNumber);                   // Initialize Axis class
    HelperFunctionsCS.CheckErrors(axis);                          // [Helper Function] Check that the axis has been initialized correctly
 
    // These limits are not meaningful for a Phantom Axis (e.g., a phantom axis has no actual position so a position error trigger is not necessary)
    // Therefore, you must set all of their actions to "NONE".
    axis.PositionSet(0);                                          // Set the position to 0
    axis.ErrorLimitActionSet(RSIAction.RSIActionNONE);            // Set Error Limit Action.
    axis.HardwareNegLimitActionSet(RSIAction.RSIActionNONE);      // Set Hardware Negative Limit Action.
    axis.HardwarePosLimitActionSet(RSIAction.RSIActionNONE);      // Set Hardware Positive Limit Action.
    axis.HomeActionSet(RSIAction.RSIActionNONE);                  // Set Home Action.
    axis.SoftwareNegLimitActionSet(RSIAction.RSIActionNONE);      // Set Software Negative Limit Action.
    axis.SoftwarePosLimitActionSet(RSIAction.RSIActionNONE);      // Set Software Positive Limit Action.
 
    const double positionToleranceMax = Double.MaxValue / 10.0;   // Reduce from max slightly, so XML to string serialization and deserialization works without throwing System.OverflowException
    axis.PositionToleranceCoarseSet(positionToleranceMax);        // Set Settling Coarse Position Tolerance to max value
    axis.PositionToleranceFineSet(positionToleranceMax);          // Set Settling Fine Position Tolerance to max value (so Phantom axis will get immediate MotionDone when target is reached)
 
    axis.MotorTypeSet(RSIMotorType.RSIMotorTypePHANTOM);          // Set the MotorType to phantom
  }
}