helpers.h

#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