_helpers.cs

using RSI.RapidCode; // RSI.RapidCode.dotNET;

public static class Helpers
{
    public static void CheckErrors(RapidCodeObject rsiObject)
    {
        var hasErrors = false;
        var errorStrBuilder = new System.Text.StringBuilder();
 
        while (rsiObject.ErrorLogCountGet() > 0)
        {
            // get error
            RsiError rsiError = rsiObject.ErrorLogGet();
 
            // get message
            var errorMsg = rsiError.isWarning ? $"WARNING: {rsiError.Message}" : $"ERROR: {rsiError.Message}";
            errorStrBuilder.AppendLine(errorMsg);
 
            // set flag
            hasErrors = !rsiError.isWarning;
        }
 
        if (hasErrors)
            throw new Exception(errorStrBuilder.ToString());
    }


    public static void NetworkStart(MotionController controller)
    {
        // check if network is started already
        if (controller.NetworkStateGet() != RSINetworkState.RSINetworkStateOPERATIONAL)
        {
            Console.WriteLine("Starting Network..");
 
            // if not started, initialize the network
            controller.NetworkStart();
        }
 
        // check if network is started again
        if (controller.NetworkStateGet() != RSINetworkState.RSINetworkStateOPERATIONAL)
        {
            // read network log messages
            int messagesToRead = controller.NetworkLogMessageCountGet();
 
            // print all the messages to help figure out the problem
            for (int i = 0; i < messagesToRead; i++)
                Console.WriteLine(controller.NetworkLogMessageGet(i));
 
            throw new SystemException("Expected OPERATIONAL state but the network did not get there.");
        }
        else
        {
            Console.WriteLine("Network Started");
        }
    }


    public static void NetworkShutdown(MotionController controller)
    {
        // check if the network is already shutdown
        if (controller.NetworkStateGet() == RSINetworkState.RSINetworkStateUNINITIALIZED ||
            controller.NetworkStateGet() == RSINetworkState.RSINetworkStateSHUTDOWN)
            return;
 
        // shutdown the network
        Console.WriteLine("Shutting down the network..");
        controller.NetworkShutdown();
 
        // check if the network is shutdown
        var networkState = controller.NetworkStateGet();
        if (networkState != RSINetworkState.RSINetworkStateUNINITIALIZED &&
            networkState != RSINetworkState.RSINetworkStateSHUTDOWN)
        {
            // some kind of error shutting down the network, read the network log messages
            int messagesToRead = controller.NetworkLogMessageCountGet();
 
            // print all the messages to help figure out the problem
            for (int i = 0; i < messagesToRead; i++)
                Console.WriteLine(controller.NetworkLogMessageGet(i));
 
            throw new SystemException("Expected SHUTDOWN state but the network did not get there.");
        }
        else
        {
            Console.WriteLine("Network Shutdown");
        }
    }


    public static void ControllerSetup(MotionController controller)
    {
        NetworkShutdown(controller);
 
        // reset the controller to ensure it is in a known state
        controller.Reset();
 
        NetworkStart(controller);
    }


    public static void PhantomAxisReset(Axis phantomAxis)
    {
        if (phantomAxis.MotorTypeGet() != RSIMotorType.RSIMotorTypePHANTOM)
        {
            throw new Exception(@$"Axis {phantomAxis.NumberGet()} is not configured as a phantom axis. 
                                   Please ensure the axis is set to phantom before calling PhantomAxisConfigure.");
        }
 
        // abort any motion
        AbortMotionObject(phantomAxis);
 
        // disable all limits (not used for phantom axes)
        phantomAxis.ErrorLimitActionSet(RSIAction.RSIActionNONE);
        phantomAxis.HardwareNegLimitActionSet(RSIAction.RSIActionNONE);
        phantomAxis.HardwarePosLimitActionSet(RSIAction.RSIActionNONE);
        phantomAxis.HomeActionSet(RSIAction.RSIActionNONE);
        phantomAxis.SoftwareNegLimitActionSet(RSIAction.RSIActionNONE);
        phantomAxis.SoftwarePosLimitActionSet(RSIAction.RSIActionNONE);
 
        // set position tolerances to max value for immediate MotionDone
        double POSITION_TOLERANCE_MAX = Double.MaxValue / 10.0;
        phantomAxis.PositionToleranceCoarseSet(POSITION_TOLERANCE_MAX);
        phantomAxis.PositionToleranceFineSet(POSITION_TOLERANCE_MAX);
 
        // set sample apps default motion parameters
        phantomAxis.UserUnitsSet(1);
        phantomAxis.DefaultVelocitySet(100);
        phantomAxis.DefaultAccelerationSet(1000);
        phantomAxis.DefaultDecelerationSet(1000);
        phantomAxis.DefaultJerkPercentSet(0);
        phantomAxis.PositionSet(0);
    }
 

    /// @internal @[AbortMotionObject]
    public static void AbortMotionObject(RapidCodeMotion motionObject)
    {
        motionObject.EStopAbort();
        motionObject.MotionDoneWait();
        motionObject.ClearFaults();
 
        // check for idle state
        if (motionObject.StateGet() != RSIState.RSIStateIDLE)
        {
            RSISource source = motionObject.SourceGet(); // get state source enum 
            string errorMsg = @$"Axis or MultiAxis {motionObject.NumberGet()} failed to enter IDLE state after aborting. 
                                 The source of the axis error is: {motionObject.SourceNameGet(source)}";
            throw new Exception(errorMsg);
        }
    }
 
    /*
        @brief     Ensures relationship between USE_HARDWARE constant and network status and throws if mismatch found.
        @param     controller Pointer to the MotionController to check.
        @exception Exception Thrown if mismatch found between USE_HARDWARE constant and network status, or user cancels on warning.
        @par       Code Snippet
        @snippet   _helpers.cs VerifyHardwareUsage
    */
    public static void VerifyHardwareUsage(MotionController controller)
    {
        const bool USE_HARDWARE = Constants.USE_HARDWARE; // User must set this in _constants.cs
 
        bool networkIsOperational = controller.NetworkStateGet() == RSINetworkState.RSINetworkStateOPERATIONAL;
 
        if (USE_HARDWARE && !networkIsOperational)
        {
            throw new Exception("USE_HARDWARE is set to true, but the network is not operational. " +
                "Please properly configure your hardware or run _setup.cs.");
        }
        else if (!USE_HARDWARE && networkIsOperational)
        {
            throw new Exception("USE_HARDWARE is set to false, but the network is operational. " +
                "Please ensure you are not connected to real hardware, or set USE_HARDWARE in _constants.cs to true.");
        }
        else if (!USE_HARDWARE && !networkIsOperational)
        {
            Console.WriteLine("Running with phantom axes as expected.");
        }
        else
        {
            // State running with hardware and require 'y' input from user to continue or any other key to abort
            Console.WriteLine("Caution: You are currently running with hardware. " +
                "Do not continue unless you have configured your axes through _setup.cs or another tool!");
            Console.Write("Press 'y' to continue: ");
            var input = Console.ReadKey();
            Console.WriteLine(); // Move to next line after key press
            
            if (input.KeyChar != 'y' && input.KeyChar != 'Y')
            {
                throw new Exception("User chose not to continue with hardware operation.");
            }
        }
    }
    
    /*
        @brief     Verifies that the AXIS_COUNT constant matches the controller's axis count, then validates minimum axis and MultiAxis requirements. Outputs comparison information to console.
        @param     controller The MotionController object to verify.
        @param     minRequiredSampleAxisCount Minimum number of axes required by the sample application (default: 1).
        @param     minRequiredSampleMultiAxisCount Minimum number of MultiAxis objects required by the sample application (default: 0).
        @exception Exception Thrown if AXIS_COUNT doesn't match controller axis count, if minimum axis count is not met, or if minimum MultiAxis count (calculated as MotionCount minus AxisCount) is not met.
        @par       Code Snippet
        @snippet   _helpers.cs VerifyAxisCount
    */
    public static void VerifyAxisCount(MotionController controller, int minRequiredSampleAxisCount = 1, int minRequiredSampleMultiAxisCount = 0)
    {
        int controllerAxisCount = controller.AxisCountGet();
        int AXIS_COUNT = Constants.AXIS_COUNT;
 
        // Verify AXIS_COUNT matches controller AxisCountGet()
        if (controllerAxisCount != AXIS_COUNT)
        {
            // Axis count mismatch. Throw exception to stop execution
            throw new Exception($"Controller axis count ({controllerAxisCount}) does not match intended AXIS_COUNT ({AXIS_COUNT}). " +
                "Please ensure AXIS_COUNT in _constants.cs matches your number of hardware axes, then run _setup.cs or another tool " +
                "to configure your hardware.");
        }
 
        // Verify minimum axis count
        // Check against AXIS_COUNT here because if we get here we know controllerAxisCount == AXIS_COUNT
        if (AXIS_COUNT < minRequiredSampleAxisCount)
        {
            throw new Exception($"This sample requires at least {minRequiredSampleAxisCount} " +
                $"{(minRequiredSampleAxisCount == 1 ? "axis" : "axes")}, but AXIS_COUNT is only {AXIS_COUNT}. " +
                $"Update your AXIS_COUNT in _constants.cs to meet the minimum requirement.");
        }
 
        // Verify minimum MultiAxis count
        if (controller.MotionCountGet() - controllerAxisCount < minRequiredSampleMultiAxisCount)
        {
            throw new Exception($"This sample requires at least {minRequiredSampleMultiAxisCount} " +
                $"MultiAxis object{(minRequiredSampleMultiAxisCount == 1 ? "" : "s")}. " +
                "Please add more motion supervisors.");
        }
    }

}