Motion: G-Code

Learn how to work with G-Code motion in C#.

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.

In this page:

• 📜 Motion: G-Code
• 📜 Motion: G-Code Units

📜 Motion: G-Code

Learn how to set up and run G-Code 📖 motion with a Robot object. Shows how to create kinematic models, load G-Code programs, register callbacks for M-codes, and monitor execution progress during motion.

/*  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.ConfigurePhantomAxis(xAxis);
    Helpers.ConfigurePhantomAxis(yAxis);
    Helpers.ConfigurePhantomAxis(zAxis);
    Helpers.ConfigurePhantomAxis(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.";
    }
}

📜 Motion: G-Code Units

Learn how changing linear units affects G-Code 📖 velocity and acceleration setters. Shows how to work with different unit systems and understand the impact on motion parameters.

/*  This sample demonstrates how changing linear units affects G-Code velocity and acceleration setters.
    Shows how to work with different unit systems in G-Code and understand the impact on motion parameters.
*/
 
using RSI.RapidCode; // RSI.RapidCode.dotNET;
 
Console.WriteLine("📜 Motion: G-Code Units");
 
// get rmp objects
MotionController controller = MotionController.Get();
 
try
{
    Helpers.CheckErrors(controller);
 
    // set robot axis labels
    const string xLabel = "X-Axis";
    const string yLabel = "Y-Axis";
    const string zLabel = "Z-Axis";
    const string aLabel = "A-Axis";
    const string bLabel = "B-Axis";
    const string cLabel = "C-Axis";
 
    // get the 6 axis needed for XYZABC 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);
    Axis bAxis = controller.AxisGet(Constants.AXIS_4_INDEX);
    Helpers.CheckErrors(bAxis);
    Axis cAxis = controller.AxisGet(Constants.AXIS_5_INDEX);
    Helpers.CheckErrors(cAxis);
 
    // configure phantom axes
    Helpers.ConfigurePhantomAxis(xAxis);
    Helpers.ConfigurePhantomAxis(yAxis);
    Helpers.ConfigurePhantomAxis(zAxis);
    Helpers.ConfigurePhantomAxis(aAxis);
    Helpers.ConfigurePhantomAxis(bAxis);
    Helpers.ConfigurePhantomAxis(cAxis);
 
    // set axis labels
    xAxis.UserLabelSet(xLabel);
    yAxis.UserLabelSet(yLabel);
    zAxis.UserLabelSet(zLabel);
    aAxis.UserLabelSet(aLabel);
    bAxis.UserLabelSet(bLabel);
    cAxis.UserLabelSet(cLabel);
 
    // create multi-axis object for joints
    MultiAxis jointsMultiAxis = controller.MultiAxisGet(0);
    Axis[] axes = [xAxis, yAxis, zAxis, aAxis, bAxis, cAxis];
    jointsMultiAxis.AxesAdd(axes, axes.Length);
    jointsMultiAxis.ClearFaults();
 
    // create kinematic model with centimeters
    const LinearUnits units = LinearUnits.Centimeters;
    const string modelName = "RSI_XYZABC_Centimeters";
    const double scaling = 1.0;
    const double offset = 0.0;
    
    // build model
    LinearModelBuilder builder = new(modelName);
    builder.UnitsSet(units);
    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.JointAdd(new LinearJointMapping(3, CartesianAxis.Roll)  { ExpectedLabel = aLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(4, CartesianAxis.Pitch) { ExpectedLabel = bLabel, Scaling = scaling, Offset = offset });
    builder.JointAdd(new LinearJointMapping(5, CartesianAxis.Yaw)   { ExpectedLabel = cLabel, Scaling = scaling, Offset = offset });
 
    // create Robot object
    Robot robot = Robot.RobotCreate(controller, jointsMultiAxis, builder, MotionController.AxisFrameBufferSizeDefault);
    Helpers.CheckErrors(robot);
 
    // note: to use the above kinematic model you must have a gantry (linear 1:1 kinematics) 
    // and each linear axis must have its user units scaled to millimeters
 
    // this will return none - a gcode unit hasn't been established so it will use path units
    // if path units are not set it will use user units
    Console.WriteLine($"Initial G-Code units: {robot.Gcode.UnitsGet()}");
 
    robot.Gcode.AccelerationRateSet(10);  // sets G-Code acceleration to 10 Centimeters per MINUTE squared
    robot.Gcode.FeedRateSet(10);          // sets G-Code velocity to 10 Centimeters per MINUTE
 
    Console.WriteLine($"Acceleration rate (cm/min²): {robot.Gcode.AccelerationRateGet()}");
    Console.WriteLine($"Feed rate (cm/min): {robot.Gcode.FeedRateGet()}");
 
    robot.Gcode.UnitsSet(LinearUnits.Inches);  // this is the same as executing G-Code line G20
    Console.WriteLine($"G-Code units after setting to inches: {robot.Gcode.UnitsGet()}");
 
    robot.Gcode.AccelerationRateSet(10);  // sets G-Code acceleration to 10 Inches per MINUTE squared
    robot.Gcode.FeedRateSet(10);          // sets G-Code velocity to 10 Inches per MINUTE
 
    Console.WriteLine($"Acceleration rate (in/min²): {robot.Gcode.AccelerationRateGet()}");
    Console.WriteLine($"Feed rate (in/min): {robot.Gcode.FeedRateGet()}");
 
    // cleanup
    Robot.RobotDelete(controller, robot);
}
// handle errors as needed
finally
{
    controller.Delete();  // dispose
}