axis-homing-ds402-drive.cs

/*  This sample application demonstrates drive-based homing with a DS402-compliant drive using the RapidCode .NET API.
    Drive-based homing avoids network latencies since the drive executes the homing routine.
    Many drives follow the DS402 standard, making this a widely applicable homing method.
    This sample configures SDO parameters, manages control word states, and monitors status word for completion.
*/
 
using RSI.RapidCode; // RSI.RapidCode.dotNET;
 
Console.WriteLine("📜 Axis Homing: DS402 Drive");
 
// set sample config params
const int offsetIdx = 0x607C;
const int offsetSub = 0x0;
const int offsetSize = 4;
const int offsetVal = 0;
 
const int methodIdx = 0x6098;
const int methodSub = 0x0;
const int methodSize = 1;
const int methodVal = 24;
 
const int targetSpeedIdx = 0x6099;
const int targetSpeedSub = 0x1;
const int targetSpeedSize = 4;
const int targetSpeedVal = 2;
 
const int originSpeedIdx = 0x6099;
const int originSpeedSub = 0x2;
const int originSpeedSize = 4;
const int originSpeedVal = 10;
 
const int accelIdx = 0x609A;
const int accelSub = 0x0;
const int accelSize = 4;
const int accelVal = 100;
 
const int CTRL_WORD_PREP_HOMING = 15;
const int CTRL_WORD_START_HOMING = 31;
const int DELAY_MS = 20;
 
const int STATUS_TARGET_REACHED = 0x400;    // bit 10: target reached (homing complete)
const int STATUS_HOMING_ATTAINED = 0x1000;  // bit 12: homing attained (successful)
const int STATUS_HOMING_ERROR = 0x2000;     // bit 13: homing error
 
// get rmp controller
MotionController controller = MotionController.Get();
 
try
{
    Helpers.CheckErrors(controller);
 
    // check is network is started
    if (controller.NetworkStateGet() != RSINetworkState.RSINetworkStateOPERATIONAL)
    {
        Console.WriteLine("Network not started. Please start it before running this app.");
        return;
    }
    
    // get axis
    Axis axis = controller.AxisGet(Constants.AXIS_0_INDEX);
    Helpers.CheckErrors(axis);
 
 
    // 1. configure homing parameters via SDOs writes
    axis.NetworkNode.ServiceChannelWrite(offsetIdx, offsetSub, offsetSize, offsetVal);                      // home offset
    axis.NetworkNode.ServiceChannelWrite(methodIdx, methodSub, methodSize, methodVal);                      // home method (home type)
    axis.NetworkNode.ServiceChannelWrite(targetSpeedIdx, targetSpeedSub, targetSpeedSize, targetSpeedVal);  // speed during search for switch
    axis.NetworkNode.ServiceChannelWrite(originSpeedIdx, originSpeedSub, originSpeedSize, originSpeedVal);  // speed during search for zero
    axis.NetworkNode.ServiceChannelWrite(accelIdx, accelSub, accelSize, accelVal);                          // home acceleration
 
    // 2. configure control word for homing
    int axisCtrlWordIdx = (int)axis.NetworkIndexGet(RSINetworkIndexType.NetworkIndexTypeCONTROL_WORD_INDEX);
 
    axis.rsiControl.NetworkOutputOverrideValueSet(axisCtrlWordIdx, CTRL_WORD_PREP_HOMING);   // control word should be 15 before switching to homing mode
    axis.rsiControl.NetworkOutputOverrideSet(axisCtrlWordIdx, true);                         // override control word
    controller.SampleWait(DELAY_MS);                                                         // delay to give transitions time
 
    // 3. configure operation mode to homing
    axis.OperationModeSet(RSIOperationMode.RSIOperationModeHOMING_MODE);
    controller.SampleWait(DELAY_MS);
 
    // 4. home
    axis.rsiControl.NetworkOutputOverrideValueSet(axisCtrlWordIdx, CTRL_WORD_START_HOMING);  // start homing
    controller.SampleWait(DELAY_MS);
 
    bool cancelHome = false;
    UInt16 statusWord = axis.NetworkNode.StatusWordGet(Constants.AXIS_0_INDEX);
 
    while ((!cancelHome) && ((statusWord & STATUS_TARGET_REACHED) == 0))  // wait until target reached or cancel
    {
        // A timeout that sets cancelHome would be a good idea for this while loop
        statusWord = axis.NetworkNode.StatusWordGet(Constants.AXIS_0_INDEX);  // update status word
        // A short sleep or wait is appropriate so you aren't spamming this call
    }
 
    // evaluate homing result
    if ((statusWord & STATUS_HOMING_ATTAINED) == STATUS_HOMING_ATTAINED)
        Console.WriteLine("Axis homed successfully");
    else if ((statusWord & STATUS_HOMING_ERROR) == STATUS_HOMING_ERROR)
        Console.WriteLine("Error occurred during homing");
 
    // clean up
    axis.AmpEnableSet(false);
    axis.ClearFaults();
    axis.rsiControl.NetworkOutputOverrideSet(axisCtrlWordIdx, false);
 
    // restore mode of operation to your desired control mode (typically CSP mode)
    axis.OperationModeSet(RSIOperationMode.RSIOperationModeCYCLIC_SYNCHRONOUS_POSITION_MODE);
}
// handle errors as needed
finally
{
    controller.Delete();  // dispose
}