config.h

#ifndef CONFIG_H
#define CONFIG_H
 
// 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 <sstream>
#include <source_location>
 
#include "rsi.h" // Import our RapidCode Library.
 
#include "helpers.h"
 
using namespace RSI::RapidCode; // Import our RapidCode namespace

namespace Config
{
  // Motion Controller Creation Parameters
  inline constexpr char RMP_PATH[] = RMP_INSTALL_PATH; 
  inline constexpr char NIC_PRIMARY[] = "";            
  inline constexpr char NODE_NAME[] = "";              
  inline constexpr int CPU_AFFINITY = 0;               
 
  // If you want to use hardware, then follow the instructions in the README before setting this to true.
  inline constexpr bool USE_HARDWARE = false; 

  void ConfigureHardwareAxes(MotionController *controller)
  {
    // If you have configured your axes using rsiconfig, RapidSetup, or RapidSetupX then you can comment out this error and return.
    // IMPLEMENTATION REQUIRED: Configure the axes for hardware
    std::ostringstream message;
    message << "You must implement the " << __func__ << " function (found in " << __FILE__ << " line " << __LINE__ << ") to use hardware.";
    throw std::runtime_error(message.str().c_str());
 
    // Simple Axis Configuration Example:
    // (Look at the Axis: Configuration section in the RapidCode API Reference for more advanced configurations)
    
    // const int USER_UNITS = 1048576; // example for 20-bit encoder, 2^20 = 1048576
    // Axis *axis = controller->AxisGet(0);
    // Helpers::CheckErrors(axis);
    // axis->UserUnitsSet(USER_UNITS);
    // axis->PositionSet(0);
    // axis->ErrorLimitTriggerValueSet(0.1 * USER_UNITS);
    // axis->ErrorLimitActionSet(RSIAction::RSIActionABORT);
    // axis->Abort();
    // axis->ClearFaults();
  }

  #if _WIN32
  MotionController::CreationParameters GetCreationParameters()
  {
    // Create a controller with using defined parameters
    MotionController::CreationParameters params;
    strncpy(params.RmpPath, RMP_PATH, params.PathLengthMaximum);
    strncpy(params.NicPrimary, NIC_PRIMARY, params.PathLengthMaximum);
    strncpy(params.NodeName, NODE_NAME, params.PathLengthMaximum);
    return params;
  }
  #elif __linux__
  MotionController::CreationParameters GetCreationParameters()
  {
    MotionController::CreationParameters params;
    strncpy(params.RmpPath, RMP_PATH, params.PathLengthMaximum);
    strncpy(params.NicPrimary, NIC_PRIMARY, params.PathLengthMaximum);
    params.CpuAffinity = CPU_AFFINITY;
    return params;
  }
  #endif

  void ConfigurePhantomAxis(MotionController *controller, int axisIndex)
  {
    // Check that the axis has been initialized correctly
    Axis* axis = controller->AxisGet(axisIndex);
    Helpers::CheckErrors(axis);
 
    // 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->AmpFaultActionSet(RSIAction::RSIActionNONE);         // Set Amp Fault Action.
    axis->AmpFaultTriggerStateSet(1);                          // Set Amp Fault Trigger State.
    axis->HardwareNegLimitActionSet(RSIAction::RSIActionNONE); // Set Hardware Negative Limit Action.
    axis->HardwarePosLimitActionSet(RSIAction::RSIActionNONE); // Set Hardware Positive Limit Action.
    axis->SoftwareNegLimitActionSet(RSIAction::RSIActionNONE); // Set Software Negative Limit Action.
    axis->SoftwarePosLimitActionSet(RSIAction::RSIActionNONE); // Set Software Positive Limit Action.
    axis->HomeActionSet(RSIAction::RSIActionNONE);             // Set Home Action.
 
    const 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
  }
 
  static int initialAxisCount = -1; 
  static int initialMotionCount = -1; 

  void SetupController(MotionController *controller, int numAxes = 0)
  {
    // Start or shutdown the network depending on the configuration
    if (USE_HARDWARE)
    {
      Helpers::NetworkStart(controller);
    }
    else if (controller->NetworkStateGet() != RSINetworkState::RSINetworkStateUNINITIALIZED &&
      controller->NetworkStateGet() != RSINetworkState::RSINetworkStateSHUTDOWN)
    {
      std::ostringstream message;    
      message << "The Sample Apps are configured to use Phantom Axes, but the network is not in the UNINITIALIZED or SHUTDOWN state.\n"
              << "If you intended to run with hardware, then follow the steps in README.md and /src/config.h\n"
              << "Otherwise, shutdown the network before running the sample apps with phantom axes.";
 
      throw std::runtime_error(message.str().c_str());
    }
 
    // Check if we are using hardware or phantom axes
    if (USE_HARDWARE)
    {
      // Let the user defined function configure the axes
      ConfigureHardwareAxes(controller);
      
      // Check that there are enough axes configured
      int axisCount = controller->AxisCountGet();
      if (axisCount < numAxes)
      {
        std::ostringstream message;
        message << "Error! Not enough axes configured. Expected " << numAxes << " axes but only found " << axisCount << " axes."
                << "Please configure the axes in the Config::ConfigureHardwareAxes function.";
        throw std::runtime_error(message.str().c_str());
      }
    }
    else
    {
      // Record the initial object counts to restore later
      initialAxisCount = controller->AxisCountGet();
      initialMotionCount = controller->MotionCountGet();
 
      // Add phantom axes for the sample app if needed
      if (numAxes > initialAxisCount)
      {
        controller->AxisCountSet(numAxes);
      }
      
      for (int i = 0; i < numAxes; i++)
      {
        ConfigurePhantomAxis(controller, i);
      }
    }
  }

  void Cleanup(MotionController* controller)
  {
    // Restore the object counts to the original values
    if (initialAxisCount != -1) { controller->AxisCountSet(initialAxisCount); }
    if (initialMotionCount != -1) { controller->MotionCountSet(initialMotionCount); }
 
    // Reset the object counts
    initialAxisCount = -1;
    initialMotionCount = -1;
  }
};
 
#endif // CONFIG_H