gcode-motion.cs

/*  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.";
    }
}