RAPID modules & program files

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// The program the task holds, null when it holds none
RapidProgramInfo program = robot.Rws.Rapid.GetProgram("T_ROB1");
if (program != null)
    Console.WriteLine(program.Name + ", entry point " + program.EntryPoint);

robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    // The program file has to be on the controller already.
    // Upload it first with robot.Rws.File.
    robot.Rws.Rapid.LoadProgram("T_ROB1", "$HOME/myprogram.pgf", RapidProgramLoadMode.Replace);

    // Write every module of the task into a directory of the controller
    robot.Rws.Rapid.SaveProgram("T_ROB1", "$HOME/myprograms");

    robot.Rws.Rapid.SetProgramName("T_ROB1", "myprogram");
    robot.Rws.Rapid.SetEntryPoint("T_ROB1", "main");

    robot.Rws.Rapid.UnloadProgram("T_ROB1");
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}

// Loading returns before the controller has finished, so read what it refused
foreach (RapidBuildError error in robot.Rws.Rapid.GetBuildErrors("T_ROB1"))
    Console.WriteLine(error.ModuleName + " " + error.Row + "," + error.Column + ": " + error.Error);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
foreach (RapidModuleItem module in robot.Rws.Rapid.GetModules("T_ROB1"))
{
    Console.WriteLine(module.Name + " " + module.Type);   // ProgramModule or SystemModule

    // The file the module came from and the properties declared on it
    RapidModuleInfo info = robot.Rws.Rapid.GetModule("T_ROB1", module.Name);
    Console.WriteLine(info.FileName);

    foreach (RapidModuleAttribute attribute in info.Attributes)
        Console.WriteLine("   " + attribute);             // SystemModule, NoStepIn, ...

    // How big the source is, in lines and columns
    RapidModuleExtension size = robot.Rws.Rapid.GetModuleExtension("T_ROB1", module.Name);
    Console.WriteLine(size.LineCount + " lines, " + size.MaxColumnCount + " columns");

    // A counter that only moves when the module changes, cheaper than reading it again
    Console.WriteLine(robot.Rws.Rapid.GetModuleChangeCount("T_ROB1", module.Name));
}

// Which of these properties this module accepts
RapidModuleAttribute[] possible = robot.Rws.Rapid.GetPossibleModuleAttributes(
    "T_ROB1", "MainModule", RapidModuleAttribute.NoStepIn, RapidModuleAttribute.ViewOnly);
Console.WriteLine(possible.Length);

// Write one module as a file of the controller, the extension is added by the controller
robot.Rws.Rapid.SaveModule("T_ROB1", "MainModule", "MainModule", "$HOME");
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// The whole source of the module
RapidModuleText source = robot.Rws.Rapid.GetModuleText("T_ROB1", "MainModule");
Console.WriteLine(source.Text);
Console.WriteLine(source.ChangeCount);

// Only a few lines. Rows and columns are counted from 1, and the controller clamps
// the end of the range to what the module really holds.
Console.WriteLine(robot.Rws.Rapid.GetModuleTextRange("T_ROB1", "MainModule", 1, 1, 10, 1));

// Where a piece of text sits, Found is false when it is nowhere
RapidTextPosition found = robot.Rws.Rapid.SearchModuleText("T_ROB1", "MainModule", "MoveJ");
Console.WriteLine(found.Found + " " + found.Row + "," + found.Column);

robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    // Insert one line after a range, leaving the rest of the module alone
    RapidSetTextRangeResult result = robot.Rws.Rapid.SetModuleTextRange(
        "T_ROB1", "MainModule",
        RapidTextReplaceMode.After, RapidTextQueryMode.Try,
        5, 1, 5, 1,
        "    reg1 := 0;\r\n");

    // Rewriting the line that declares the module renames it
    Console.WriteLine(result.ModuleRenamed + " " + result.NewModuleName);

    // Replace the whole source
    robot.Rws.Rapid.SetModuleText("T_ROB1", "MainModule",
        "MODULE MainModule\r\n  PROC main()\r\n  ENDPROC\r\nENDMODULE\r\n");
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// The controller answers at most thirty errors at a time, read the next ones by paging
int start = 0;
RapidBuildError[] errors = robot.Rws.Rapid.GetBuildErrors("T_ROB1", start, 30);

while (errors.Length > 0)
{
    foreach (RapidBuildError error in errors)
    {
        Console.WriteLine(error.ModuleName + " " + error.Row + "," + error.Column);
        Console.WriteLine("   " + error.Error);
    }

    start += errors.Length;
    errors = robot.Rws.Rapid.GetBuildErrors("T_ROB1", start, 30);
}

// An empty answer and a task state of Linked mean the program is runnable
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 controller snaps the breakpoint to the whole instruction holding the
    // position, so the range it answers is normally wider than what was asked for
    RapidBreakpoint placed = robot.Rws.Rapid.SetBreakpoint("T_ROB1", "MainModule", 12, 1);
    Console.WriteLine(placed.StartRow + "," + placed.StartColumn + " -> " +
                      placed.EndRow + "," + placed.EndColumn);
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}

foreach (RapidBreakpoint breakpoint in robot.Rws.Rapid.GetBreakpoints("T_ROB1"))
    Console.WriteLine(breakpoint.ModuleName + " " + breakpoint.StartRow);

// A breakpoint only stops the program when execution was started with stopAtBreakpoint
robot.Rws.Rapid.Start(RapidRegainMode.Continue, RapidExecutionMode.Continue,
                      RapidExecutionCycle.Forever, RapidStartCondition.None, true, false);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// How many motion instructions of this range can be rewritten
RapidModifiablePositions modifiable =
    robot.Rws.Rapid.GetModifiablePositions("T_ROB1", "MainModule", 1, 1, 40, 1);
Console.WriteLine(modifiable.ModifiableLineCount);

// Every one of them, in every task of the system
foreach (RapidModifiablePositionItem item in robot.Rws.Rapid.GetAllModifiablePositions())
    Console.WriteLine(item.TaskName + "/" + item.ModuleName + " line " + item.StartRow);

// Jog the robot where it should go, then write that position into the program
robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    robot.Rws.Rapid.ModifyPosition("T_ROB1", "MainModule", 12, 1, 12, 1, true, true, false);
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// What is declared at this position of the source, null when nothing is
RapidModuleSymbol symbol = robot.Rws.Rapid.GetModuleSymbol("T_ROB1", "MainModule", 12, 5);
if (symbol != null)
    Console.WriteLine(symbol.Name + " " + symbol.SymbolType + " " + symbol.DataType);

// The routine called at this position, and the arguments of that call
RapidRoutineInfo routine = robot.Rws.Rapid.GetRoutine("T_ROB1", "MainModule", 12, 5);
Console.WriteLine(routine.Name + " " + routine.ParameterCount);

foreach (RapidRoutineArgument argument in
         robot.Rws.Rapid.GetRoutineArguments("T_ROB1", "MainModule", 12, 5))
{
    Console.WriteLine(argument.DataType + " at " + argument.StartRow + "," + argument.StartColumn);
}

// A complete instruction ready to be written, instead of a bare keyword
RapidInstructionTemplate template = robot.Rws.Rapid.GetInstructionTemplate("T_ROB1", "MainModule", "MoveJ");
foreach (RapidInstructionTemplateArgument argument in template.Arguments)
    Console.WriteLine(argument.Name + " = " + argument.Value + " (" + argument.DataType + ")");

// Where the parts of an object begin and end, given the whole span of that object
RapidObjectChild children = robot.Rws.Rapid.GetObjectChildren("T_ROB1", "MainModule", 1, 1, 40, 1);
foreach (RapidObjectChildRange range in children.Ranges)
    Console.WriteLine(range.Name + ": " + range.Range);

// Where one of the lists an object holds sits, without reading the module
RapidObjectListExtension list = robot.Rws.Rapid.GetObjectListExtension(
    "RAPID/T_ROB1/MainModule", RapidObjectListType.RoutineDeclarations);
Console.WriteLine(list.List + " first " + list.First + " last " + list.Last);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Categories of the instruction palette, the same ones an editor shows
foreach (RapidPalletHeadItem head in robot.Rws.Rapid.GetPalletHeads("T_ROB1"))
{
    Console.WriteLine(head.Number + ": " + head.Name);

    // Instructions of that category
    foreach (RapidPalletItem item in robot.Rws.Rapid.GetPallet("T_ROB1", head.Number.Value))
        Console.WriteLine("   " + item.Name + " " + item.Instruction);
}

// Types the controller suggests for one argument of an instruction
foreach (RapidPreferredDataTypeItem type in
         robot.Rws.Rapid.GetPreferredDataTypes("T_ROB1", "AliasIO", "FromSignal"))
{
    Console.WriteLine(type.Name + " (" + type.DataType + ")");
}
robot.Disconnect();
}