helpers.h

Note

See ⚙️ Helpers 📜 for a detailed explanation of this sample code.

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. We recommend that you wire an external hardware emergency stop (e-stop) button for safety when using our code sample apps. Doing so will help ensure the safety of you and those around you and will prevent potential injury or damage.

The sample apps assume that the system (network, axes, I/O) are configured prior to running the code featured in the sample app. See the Configuration page for more information.

#ifndef HELPERS
#define HELPERS
 
// These macros are defined as part of the build process in CMake. To avoid
// build errors, we default them to empty strings if they are not defined.
#ifndef RMP_INSTALL_PATH
#define RMP_INSTALL_PATH ""
#endif
 
#include "rsi.h" // Import our RapidCode Library.
 
#include <iostream>
#include <string>
#include <sstream>
#include <source_location>
 
using namespace RSI::RapidCode; // Import our RapidCode namespace

namespace Helpers
{
  const char* NetworkStartErrorName(RSINetworkStartError error)
  {
    switch (error)
    {
    case RSINetworkStartError::RSINetworkStartErrorNETWORK_START_OK:
      return "RSINetworkStartErrorNETWORK_START_OK";
    case RSINetworkStartError::RSINetworkStartErrorNIC_PASSED:
      return "RSINetworkStartErrorNIC_PASSED";
    case RSINetworkStartError::RSINetworkStartErrorDEVICES_CONNECTED_POWERED:
      return "RSINetworkStartErrorDEVICES_CONNECTED_POWERED";
    case RSINetworkStartError::RSINetworkStartErrorDISCOVERED_ZERO_NODES:
      return "RSINetworkStartErrorDISCOVERED_ZERO_NODES";
    case RSINetworkStartError::RSINetworkStartErrorGENERAL_DISCOVERY_FAILURE:
      return "RSINetworkStartErrorGENERAL_DISCOVERY_FAILURE";
    case RSINetworkStartError::RSINetworkStartErrorNETWORK_INIT_FAILURE:
      return "RSINetworkStartErrorNETWORK_INIT_FAILURE";
    case RSINetworkStartError::RSINetworkStartErrorINCORRECT_ENI_FORMAT:
      return "RSINetworkStartErrorINCORRECT_ENI_FORMAT";
    case RSINetworkStartError::RSINetworkStartErrorSLAVE_COMM_FAILED:
      return "RSINetworkStartErrorSLAVE_COMM_FAILED";
    case RSINetworkStartError::RSINetworkStartErrorMEMORY_CONFIG:
      return "RSINetworkStartErrorMEMORY_CONFIG";
    case RSINetworkStartError::RSINetworkStartErrorETHERCAT_MASTER_STARTUP_ERROR:
      return "RSINetworkStartErrorETHERCAT_MASTER_STARTUP_ERROR";
    case RSINetworkStartError::RSINetworkStartErrorINTERNAL_RMP_ERROR:
      return "RSINetworkStartErrorINTERNAL_RMP_ERROR";
    case RSINetworkStartError::RSINetworkStartErrorINTIME_OPEN_ERROR:
      return "RSINetworkStartErrorINTIME_OPEN_ERROR";
    case RSINetworkStartError::RSINetworkStartErrorFAILED_TO_READ_PRODUCT_CODE:
      return "RSINetworkStartErrorFAILED_TO_READ_PRODUCT_CODE";
    case RSINetworkStartError::RSINetworkStartErrorFAILED_TO_READ_VENDOR_ID:
      return "RSINetworkStartErrorFAILED_TO_READ_VENDOR_ID";
    case RSINetworkStartError::RSINetworkStartErrorFAILED_TO_READ_REVISION:
      return "RSINetworkStartErrorFAILED_TO_READ_REVISION";
    case RSINetworkStartError::RSINetworkStartErrorFAILED_TO_READ_SERIAL_NO:
      return "RSINetworkStartErrorFAILED_TO_READ_SERIAL_NO";
    case RSINetworkStartError::RSINetworkStartErrorFAILED_TO_READ_STATION_ALIAS:
      return "RSINetworkStartErrorFAILED_TO_READ_STATION_ALIAS";
    case RSINetworkStartError::RSINetworkStartErrorTHREAD_SCHEDULING_OR_PRIORITY:
      return "RSINetworkStartErrorTHREAD_SCHEDULING_OR_PRIORITY";
    case RSINetworkStartError::RSINetworkStartErrorETHERCAT_SAFETY_NOT_LICENSED:
      return "RSINetworkStartErrorETHERCAT_SAFETY_NOT_LICENSED";
    case RSINetworkStartError::RSINetworkStartErrorETHERCAT_SAFETY_MAIN_DEVICE_NOT_DETECTED:
      return "RSINetworkStartErrorETHERCAT_SAFETY_MAIN_DEVICE_NOT_DETECTED";
    case RSINetworkStartError::RSINetworkStartErrorUNSUPPORTED_NODE_DETECTED:
      return "RSINetworkStartErrorUNSUPPORTED_NODE_DETECTED";
    case RSINetworkStartError::RSINetworkStartErrorENI_SAMPLE_RATE_MISMATCH:
      return "RSINetworkStartErrorENI_SAMPLE_RATE_MISMATCH";
    case RSINetworkStartError::RSINetworkStartErrorCPU_AFFINITY:
      return "RSINetworkStartErrorCPU_AFFINITY";
    default:
      return "RSINetworkStartErrorUNKNOWN";
    }
  }

  void CheckErrors(RapidCodeObject *rsiObject, const std::source_location &location = std::source_location::current())
  {
    bool hasErrors = false;
    std::string errorStrings("");
    while (rsiObject->ErrorLogCountGet() > 0)
    {
      const RsiError *err = rsiObject->ErrorLogGet();
 
      errorStrings += err->what();
      errorStrings += "\n";
 
      if (!err->isWarning)
      {
        hasErrors = true;
      }
    }
 
    if (hasErrors)
    {
      std::ostringstream message;
      message << "Error! In "
              << location.file_name() << '('
              << location.line() << ':'
              << location.column() << ") `"
              << location.function_name() << "`:\n"
              << errorStrings;
 
      throw std::runtime_error(message.str().c_str());
    }
  }

  void NetworkStart(MotionController *controller)
  {
    // Initialize the Network
    if (controller->NetworkStateGet() != RSINetworkState::RSINetworkStateOPERATIONAL) // Check if network is started already.
    {
      std::cout << "Starting Network.." << std::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.
    {
      RSINetworkStartError startError = controller->LastNetworkStartErrorGet();
      std::cout << "Network start error: " << NetworkStartErrorName(startError)
                << " (" << static_cast<int>(startError) << ")" << std::endl;
 
      int messagesToRead = controller->NetworkLogMessageCountGet(); // Some kind of error starting the network, read the network log messages
 
      for (int i = 0; i < messagesToRead; i++)
      {
        std::cout << controller->NetworkLogMessageGet(i) << std::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.
    {
      std::cout << "Network Started" << std::endl << std::endl;
    }
  }

  void NetworkShutdown(MotionController *controller)
  {
    // Check if the network is already shutdown
    if (controller->NetworkStateGet() == RSINetworkState::RSINetworkStateUNINITIALIZED ||
        controller->NetworkStateGet() == RSINetworkState::RSINetworkStateSHUTDOWN)
    {
      return;
    }
 
    // Shutdown the network
    std::cout << "Shutting down the network.." << std::endl;
    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++)
      {
        std::cout << controller->NetworkLogMessageGet(i) << std::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.
    {
      std::cout << "Network Shutdown" << std::endl << std::endl;
    }
  }

  void PrintHeader(std::string sampleAppName)
  {
    std::cout << "----------------------------------------------------------------------------------------------------\n";
    std::cout << "Running " << sampleAppName << " Sample App\n";
    std::cout << "----------------------------------------------------------------------------------------------------\n" << std::endl;
  }

  void PrintFooter(std::string sampleAppName, int exitCode)
  {
    std::cout << "\n----------------------------------------------------------------------------------------------------\n";
    if (exitCode == 0)
    {
      std::cout << sampleAppName << " Sample App Completed Successfully\n";
    }
    else
    {
      std::cout << sampleAppName << " Sample App Failed with Exit Code: " << exitCode << "\n";
    }
    std::cout << "----------------------------------------------------------------------------------------------------\n" << std::endl;
  }
} // namespace Helpers
 
#endif // HELPERS