HelperFunctionsCpp.h

 
#ifndef CPP_HELPER_FUNCTIONS
#define CPP_HELPER_FUNCTIONS
 
#include "rsi.h"                                    // Import our RapidCode Library. 
#include <iostream>
#include <string>
#include <cstdlib>
#include <algorithm>
 
 
using namespace std;
using namespace RSI::RapidCode;
 
class HelperFunctionsCpp
{
public:
 
  static void CheckErrors(RapidCodeObject* rsiObject)
  {
    bool hasErrors = false;
    std::string errorStrings("");
    while (rsiObject->ErrorLogCountGet() > 0)
    {
      const RsiError* err = rsiObject->ErrorLogGet();
 
      errorStrings += err->what();
 
      if (!err->isWarning)
      {
        hasErrors = true;
      }
    }
 
    if (errorStrings.size() > 0)
    {
      printf("%s", errorStrings.c_str());
    }
 
    if (hasErrors)
    {
      throw std::runtime_error(errorStrings.c_str());
    }
  }
 
  static void StartTheNetwork(MotionController* controller)
  {
    // Initialize the Network
    if (controller->NetworkStateGet() != RSINetworkState::RSINetworkStateOPERATIONAL)        // Check if network is started already.
    {
      cout << "Starting Network.." << endl;
      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++)
      {
        cout << controller->NetworkLogMessageGet(i) << endl;                                // Print all the messages to help figure out the problem
      }
      throw std::runtime_error("Expected OPERATIONAL state but the network did not get there.");
    }
    else                                                                                    // Else, of network is operational.
    {
      cout << "Network Started" << endl << endl;
    }
  }
 
  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
    cout << "Shutting down the network.." << endl;
    controller->NetworkShutdown();
 
    if (controller->NetworkStateGet() != RSINetworkState::RSINetworkStateUNINITIALIZED &&
      controller->NetworkStateGet() != RSINetworkState::RSINetworkStateSHUTDOWN)            // Check if the netwrok 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++)
      {
        cout << controller->NetworkLogMessageGet(i) << endl;                                // Print all the messages to help figure out the problem
      }
      throw std::runtime_error("Expected SHUTDOWN state but the network did not get there.");
    }
    else                                                                                    // Else, of network is shutdown.
    {
      cout << "Network Shutdown" << endl << endl;
    }
  }
 
  static void SetupControllerForHardware(MotionController* controller)
  {
    ShutdownTheNetwork(controller);
    controller->Reset();                                                                    // Reset the controller to ensure it is in a known state.
    StartTheNetwork(controller);
  }
 
  static void ClearControllerCounts(MotionController* controller)
  {
    // Clear the counts
    controller->AxisCountSet(0);
    controller->MotionCountSet(0);
    controller->UserLimitCountSet(0);
  }
 
  static void SetupControllerForPhantoms(MotionController* controller, int axisCount, std::vector<int> axisNums)
  {
    ShutdownTheNetwork(controller);
 
    ClearControllerCounts(controller);
 
    controller->AxisCountSet(axisCount);
    for (auto axisNum : axisNums)
    {
      ConfigurePhantomAxis(controller, axisNum);
    }
  }
 
  static void ConfigurePhantomAxis(MotionController* controller, int axisNumber)
  {
    // Check if the axis number is valid
    if (axisNumber < 0)
    {
      throw std::invalid_argument("Error: " + std::to_string(axisNumber) + " is invalid. Axis numbers cannot be negative.");
    }
 
    if (axisNumber >= controller->AxisCountGet())
    {
      throw std::invalid_argument("Error: " + std::to_string(axisNumber) + " 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
    HelperFunctionsCpp::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.
 
    constexpr double positionToleranceMax = std::numeric_limits<double>::max() / 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
  }
};
#endif