LoadFile()

void LoadFile ( const char *const file )

pure virtual

Parameters

file	The full path of the file to load. The contents of the file are passed to Load().

This method parses and processes the Gcode program. The program can be run by calling the Run() method.

Exceptions

RsiError

if the program was not parsed or processed successfully, one exception is thrown. Additional RsiError are logged, use a HelperFunctions::CheckErrors() on the Gcode object to get details for each Gcode line number that failed.

Sample Code:

/*  This sample demonstrates how to set up and run G-Code motion with a Robot object.
    Shows how to create a kinematic model, load G-Code programs, and execute them.
    Includes callback handling for M-codes and monitoring execution progress.
*/
 
using RSI.RapidCode; // RSI.RapidCode.dotNET;
using System.Threading;
 
Console.WriteLine("📜 Motion: G-Code");
 
// get rmp objects
MotionController controller = MotionController.Get();
 
try
{
    Helpers.CheckErrors(controller);

    // sample G-Code program
    string gcodeProgram = @"G91;                           Sets the programming mode to RELATIVE
                            G64;                           Turns off exact stop mode (Default)
                            G1 X1.0 Y0.0 Z0.0 A1.0 F60.0;  Move on USERUNIT in positive x direction at 60in/min. Moves Free axis A to position 1.0.
                            G3 X1 Y1 I0 J1;                Counter clockwise arc with a center point of 0,1,0 and end point of 1,1,0 relative to the current position
                            M80;                           Show how to use an M-code with GcodeCallback!";
 
    // set robot axis labels
    const string xLabel = "X-Axis";
    const string yLabel = "Y-Axis";
    const string zLabel = "Z-Axis";
    const string aLabel = "A-Axis";
 
    // get the 4 axis needed for XYZA robot
    Axis xAxis = controller.AxisGet(Constants.AXIS_0_INDEX);
    Helpers.CheckErrors(xAxis);
    Axis yAxis = controller.AxisGet(Constants.AXIS_1_INDEX);
    Helpers.CheckErrors(yAxis);
    Axis zAxis = controller.AxisGet(Constants.AXIS_2_INDEX);
    Helpers.CheckErrors(zAxis);
    Axis aAxis = controller.AxisGet(Constants.AXIS_3_INDEX);
    Helpers.CheckErrors(aAxis);
 
    // configure phantom axes
    Helpers.PhantomAxisReset(xAxis);
    Helpers.PhantomAxisReset(yAxis);
    Helpers.PhantomAxisReset(zAxis);
    Helpers.PhantomAxisReset(aAxis);
 
    // set axis labels
    xAxis.UserLabelSet(xLabel);
    yAxis.UserLabelSet(yLabel);
    zAxis.UserLabelSet(zLabel);
    aAxis.UserLabelSet(aLabel);
 
    // create multi-axis object for joints
    MultiAxis jointsMultiAxis = controller.MultiAxisGet(0);
    Axis[] axes = [xAxis, yAxis, zAxis, aAxis];
    jointsMultiAxis.AxesAdd(axes, axes.Length);
    jointsMultiAxis.ClearFaults();
    jointsMultiAxis.AmpEnableSet(true);
 
    // create kinematic model
    const string modelName = "RSI_XYZA";
    const double scaling = 1.0;
    const double offset = 0.0;
 
    LinearModelBuilder builder = new(modelName);
    builder.JointAdd(new LinearJointMapping(0, CartesianAxis.X) { ExpectedLabel = xLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(1, CartesianAxis.Y) { ExpectedLabel = yLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(2, CartesianAxis.Z) { ExpectedLabel = zLabel, Scaling = scaling, Offset = offset });
    builder.FreeAxisAdd(new ModelAxisMapping(3) { ExpectedLabel = aLabel, Scaling = scaling, Offset = offset });
 
    // set free axis accel & decel before creating the robot object
    aAxis.DefaultAccelerationSet(1000);
    aAxis.DefaultDecelerationSet(1000);
 
    // create Robot object
    Robot robot = Robot.RobotCreate(controller, jointsMultiAxis, builder, MotionController.AxisFrameBufferSizeDefault);
    Helpers.CheckErrors(robot);
 
    // set robot acceleration
    robot.Gcode.AccelerationRateSet(1000); 
 
    // the free axis index refers to the index in the RobotPosition freeAxes array
    robot.Gcode.FreeAxisLetterSet(gcodeLetter: 'A', freeAxisIndex: 0);
 
    // register callback for M-code commands (note: callback class would need to be defined separately)
    SampleGcodeCallback callback = new();
    robot.Gcode.CallbackRegister(callback);
 
    try
    {
        // load and prepare G-Code for execution
        robot.Gcode.Load(gcodeProgram);
    }
    catch (Exception e)
    {
        Console.WriteLine($"Error loading G-Code: {e.Message}");
        Helpers.CheckErrors(robot.Gcode);  // get additional G-Code error details
        throw;
    }
 
    // print motion details
    Console.WriteLine($"G-Code Line Count: {robot.Gcode.LineCountGet()}");
    Console.WriteLine($"G-Code Error Log Count: {robot.Gcode.ErrorLogCountGet()}");
    Console.WriteLine($"G-code estimated run time: {robot.Gcode.DurationGet()} seconds");
 
    // start motion
    robot.Gcode.Run();
 
    // monitor execution
    Int64 activeLineNumber = 0;
    do
    {
        Thread.Sleep(200);
        if (activeLineNumber != robot.Gcode.ExecutingLineNumberGet())  // only write if on new line
        {
            activeLineNumber = robot.Gcode.ExecutingLineNumberGet();
            Console.WriteLine($"G-Code Line Number: {activeLineNumber}");
        }
    } while (robot.Gcode.IsRunning());
 
    Helpers.CheckErrors(robot.Gcode);  // check for motion errors
 
    // cleanup
    Robot.RobotDelete(controller, robot);
 
    Console.WriteLine("✅ G-Code motion completed successfully");
}
// handle errors as needed
finally
{
    controller.Delete();  // dispose
}
 
public class SampleGcodeCallback : GcodeCallback
{
    public override void Execute(GcodeCallbackData data)
    {
        Console.WriteLine("G-Code Callback executed: " + data.LineNumber + " " + data.LineText);
    
        // if you want to notify the Gcode object that there's an error processing, set its error details:
        // data.UserError.number = RSIErrorMessage.RSI_ERROR_MESSAGE_DYNAMIC;
        // data.UserError.text = "This is an error from the callback.";
    }
}

See also

Run, PlannedPositionsGet