RAPID tasks & program execution

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Every RAPID task of the controller
foreach (RapidTaskItem task in robot.Rws.Rapid.GetTasks())
{
    Console.WriteLine(task.Name);                 // T_ROB1
    Console.WriteLine(task.Type);                 // Normal, Static or SemiStatic
    Console.WriteLine(task.TaskState);            // Linked when the program is ready to run
    Console.WriteLine(task.ExecutionState);       // Started, Stopped, Ready
    Console.WriteLine(task.Active);               // null when the controller did not report it
    Console.WriteLine(task.MotionTask);           // true for the task that drives the robot
}

// Everything the controller knows about one task
RapidTaskInfo info = robot.Rws.Rapid.GetTask("T_ROB1");
Console.WriteLine(info.ExecutionLevel);           // Normal, Trap, User, None
Console.WriteLine(info.ExecutionCycle);           // Forever, Once, OnceDone
Console.WriteLine(info.ExecutionMode);            // Continuous, StepIn, StepOver, ...
Console.WriteLine(info.ProductionEntryPoint);
Console.WriteLine(info.Trust);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Which tasks the operator panel has selected, and which of them an operator may change
foreach (RapidTaskSelectionItem item in robot.Rws.Rapid.GetTaskSelection())
{
    Console.WriteLine(item.Name + " selected=" + item.Selected + " userModify=" + item.UserModify);
}

// Activating or deactivating a task is a write, so it needs the mastership
robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    robot.Rws.Rapid.ActivateTask("T_ROB1");
    robot.Rws.Rapid.DeactivateTask("T_ROB2");

    // Same thing for every task at once
    robot.Rws.Rapid.ActivateTasks();
    robot.Rws.Rapid.DeactivateTasks();
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    // Link the modules of the task into a runnable program
    robot.Rws.Rapid.BuildTask("T_ROB1");
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}

// The controller does not fail the build request, it reports what it refused afterwards
foreach (RapidBuildError error in robot.Rws.Rapid.GetBuildErrors("T_ROB1"))
{
    Console.WriteLine(error.ModuleName + " " + error.Row + "," + error.Column + ": " + error.Error);
}

// The task is runnable when its state is Linked
Console.WriteLine(robot.Rws.Rapid.GetTask("T_ROB1").TaskState);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    // The file has to be on the controller already. Upload it first with robot.Rws.File.
    // On OmniCore the call answers the name of what was loaded, on IRC5 it answers null.
    string loaded = robot.Rws.Rapid.LoadModule("T_ROB1", "$HOME/mymodule.mod", true);
    Console.WriteLine(loaded);

    robot.Rws.Rapid.UnloadModule("T_ROB1", "mymodule");
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// 1. The controller has to be in automatic mode
if (robot.Rws.Panel.GetOperationMode() != OperationMode.Automatic)
    throw new Exception("Turn the key of the controller to automatic mode");

robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    // 2. Motors on
    robot.Rws.Panel.SetControllerState(ControllerState.MotorsOn);

    // 3. Program pointer back to the entry point of every task
    robot.Rws.Rapid.ResetProgramPointer();

    // 4. Start
    robot.Rws.Rapid.Start(RapidRegainMode.Continue,
                          RapidExecutionMode.Continue,
                          RapidExecutionCycle.Forever,
                          RapidStartCondition.None,
                          false,   // do not stop at breakpoints
                          false);  // normal tasks only
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}

// 5. Check that it really started, the call above only means the request was accepted
RapidExecutionInfo execution = robot.Rws.Rapid.GetExecutionState();
Console.WriteLine(execution.State);   // Running or Stopped
Console.WriteLine(execution.Cycle);   // Forever, Once, OnceDone
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    // Only Once and Forever are accepted here
    robot.Rws.Rapid.SetExecutionCycle(RapidExecutionCycle.Once);

    // Start from the production entry point instead of the current program pointer
    robot.Rws.Rapid.StartFromProductionEntry();

    // Leave the routine that is running now and go back to the level below it.
    // This is how a trap or a service routine is abandoned without stopping the program under it.
    robot.Rws.Rapid.AbortExecutionLevel("T_ROB1");
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Stop at the end of the current instruction, normal tasks only
robot.Rws.Rapid.Stop(RapidStopMode.Stop, RapidTaskScope.Normal);

// Let the robot finish the cycle it is in, then stop
robot.Rws.Rapid.Stop(RapidStopMode.Cycle, RapidTaskScope.Normal);

// Stop everything at once, including the static and semi static tasks
robot.Rws.Rapid.Stop(RapidStopMode.QuickStop, RapidTaskScope.AllTasks);

// Wait until the controller confirms the program is stopped
while (robot.Rws.Rapid.GetExecutionState().State != RapidExecutionState.Stopped)
    System.Threading.Thread.Sleep(200);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Manual mode only. Press, then keep sending Held, the controller stops the
// program as soon as it stops hearing from your application.
robot.Rws.Rapid.SetHoldToRun(RapidHoldToRunState.Press);

robot.Rws.Rapid.Start(RapidRegainMode.Continue, RapidExecutionMode.Continue);

for (int i = 0; i < 10; i++)
{
    robot.Rws.Rapid.SetHoldToRun(RapidHoldToRunState.Held);
    System.Threading.Thread.Sleep(1000);
}

robot.Rws.Rapid.SetHoldToRun(RapidHoldToRunState.Release);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// The trace names every instruction the controller runs. No mastership needed,
// the controller takes it by itself for these two calls.
robot.Rws.Rapid.StartSpy("$HOME/trace.log");

Console.WriteLine(robot.Rws.Rapid.GetSpyStatus());   // Logging or NotLogging

System.Threading.Thread.Sleep(5000);

robot.Rws.Rapid.StopSpy();

// Then download the file with the file service
string trace = robot.Rws.File.GetFileAsText("$HOME/trace.log");
Console.WriteLine(trace);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Where the two pointers of the task stand
RapidPointers pointers = robot.Rws.Rapid.GetPointers("T_ROB1");

if (pointers.ProgramPointer.Available)
{
    Console.WriteLine(pointers.ProgramPointer.Module + "/" + pointers.ProgramPointer.Routine);
    Console.WriteLine(pointers.ProgramPointer.BeginRow + "," + pointers.ProgramPointer.BeginColumn);
}

// The motion pointer is behind the program pointer, the controller plans the path
// ahead of the movement. It is not available in a task that has not moved yet.
Console.WriteLine(pointers.MotionPointer.Available);

// The piece of source the program pointer covers. The controller refuses the request
// when the task has no program pointer, reset it or start the program first.
RapidProgramCounterPosition position = robot.Rws.Rapid.GetProgramCounterPosition("T_ROB1");
Console.WriteLine(position.Module + " " + position.StartLine + "," + position.StartColumn);

// Moving the pointer is a write, it needs the RAPID mastership
robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    // To the beginning of a routine. The module name is used by an IRC5 only,
    // an OmniCore looks the routine up in the whole task.
    robot.Rws.Rapid.SetProgramPointerToRoutine("T_ROB1", "MainModule", "main");

    // To a service routine, which has to be entered at user level
    robot.Rws.Rapid.SetProgramPointerToRoutineUrl("T_ROB1", "RAPID/T_ROB1/BASEFUN/LoadIdentify", true);

    // To one position of the source. The routine name is used by an IRC5 only,
    // an OmniCore works it out from the position itself.
    robot.Rws.Rapid.SetProgramPointerToCursor("T_ROB1", "MainModule", "main", 12, 1);

    // One instruction forward or backward, automatic mode only
    robot.Rws.Rapid.SetProgramPointerToNextInstruction("T_ROB1");
    robot.Rws.Rapid.SetProgramPointerToPreviousInstruction("T_ROB1");
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// For the whole controller
RapidPointerSyncState program = robot.Rws.Rapid.GetProgramPointerSyncState();
RapidPointerSyncState motion = robot.Rws.Rapid.GetMotionPointerSyncState();
Console.WriteLine(program + " / " + motion);   // On or Off

// For one task
Console.WriteLine(robot.Rws.Rapid.GetTaskProgramPointerSyncState("T_ROB1"));
Console.WriteLine(robot.Rws.Rapid.GetTaskMotionPointerSyncState("T_ROB1"));

// Two counters that say whether anything changed in the task, cheaper than
// downloading the modules again to find out that nothing moved
RapidStructuralChangeCount counters = robot.Rws.Rapid.GetStructuralChangeCount("T_ROB1");
Console.WriteLine(counters.ChangeCount);
Console.WriteLine(counters.StructuralChangeCount);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Frame 1 is the one holding the program pointer, the number grows towards the entry point
for (int frame = 1; frame <= 5; frame++)
{
    RapidActivationRecord record = robot.Rws.Rapid.GetActivationRecord("T_ROB1", frame);

    Console.WriteLine(record.RoutineUrl);
    Console.WriteLine(record.BeginRow + "," + record.BeginColumn);
    Console.WriteLine(record.ExecutionLevel);
}

// The routines the program pointer may be moved to, service routines included
foreach (RapidServiceRoutineItem routine in robot.Rws.Rapid.GetServiceRoutines("T_ROB1"))
{
    Console.WriteLine(routine.Name + " -> " + routine.Url + " service=" + routine.IsServiceRoutine);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Null when the program is not asking the operator for anything right now
RapidUiInstruction question = robot.Rws.Rapid.GetActiveUiInstruction();

if (question != null)
{
    Console.WriteLine(question.Instruction);   // name of the RAPID instruction waiting
    Console.WriteLine(question.Message);
    Console.WriteLine(question.Event);         // Send, Post or Abort

    // What the program passed in, and what it is waiting for. The names of the
    // parameters depend on the instruction, so read them before writing one.
    foreach (RapidUiInstructionParameter parameter in
             robot.Rws.Rapid.GetUiInstructionParameters(question.StackUrl))
    {
        Console.WriteLine(parameter.Name + " = " + parameter.Value);
    }

    // Answering is a write, so it needs the mastership
    robot.Rws.Mastership.Request(MastershipDomain.Rapid);
    try
    {
        // Write the parameter carrying the answer, then the one marking it as completed
        robot.Rws.Rapid.SetUiInstructionParameter(question.StackUrl, "TPCompleted", "TRUE");
    }
    finally
    {
        robot.Rws.Mastership.Release(MastershipDomain.Rapid);
    }

    Console.WriteLine(robot.Rws.Rapid.GetUiInstructionParameter(question.StackUrl, "TPCompleted"));
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// The signals a loaded program gave another name to. Empty when no program declares any.
foreach (RapidAliasIoItem alias in robot.Rws.Rapid.GetAliasIo())
{
    Console.WriteLine(alias.AliasName + " -> " + alias.SignalName + " (" + alias.Type + ")");
}
robot.Disconnect();
}