Helper Functions

This class includes the source code of all our SampleAppsCPP helper functions.

Helper functions were created to reduce code. Please note that if you would like to use this classes on your personal project you will have to replicate this class.

Precondition

This sample code presumes that the user has set the tuning paramters(PID, PIV, etc.) prior to running this program so that the motor can rotate in a stable manner.

Warning

This is a sample program to assist in the integration of the RMP motion controller with your application. It may not contain all of the logic and safety features that your application requires.

 
#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