RAPID tasks & program execution

// Activates one task (synchronous)
void ActivateTask(string task);

// Activates every task of the controller (synchronous)
void ActivateTasks();

// Deactivates one task (synchronous)
void DeactivateTask(string task);

// Deactivates every task of the controller (synchronous)
void DeactivateTasks();

// Gets everything the controller reports about one task (synchronous)
RapidTaskInfo GetTask(string task);

// Gets whether the motion pointer of one task is synchronized with the others (synchronous)
RapidPointerSyncState GetTaskMotionPointerSyncState(string task);

// Gets whether the program pointer of one task is synchronized with the others (synchronous)
RapidPointerSyncState GetTaskProgramPointerSyncState(string task);

// Gets the task selection panel: which tasks are selected, and which of them an operator is allowed to change the selection of (synchronous)
RapidTaskSelectionItem[] GetTaskSelection();

// Gets every RAPID task of the controller and what each of them is doing (synchronous)
RapidTaskItem[] GetTasks();

public class RapidTaskItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidTaskItem" data-throw-if-not-resolved="false"></xref> class
    public RapidTaskItem()
 
    // Whether the task is active, null when the controller did not report it
    public bool? Active { get; set; }
 
    // Whether the task is running, and whether it could be
    public RapidTaskExecutionState ExecutionState { get; set; }
 
    // Whether the task can move a mechanical unit, null when the controller did not report it
    public bool? MotionTask { get; set; }
 
    // Name of the task, for example "T_ROB1"
    public string Name { get; set; }
 
    // How far the controller has got in preparing the program of the task
    public RapidTaskState TaskState { get; set; }
 
    // Returns a string representation of this task
    public override string ToString()
 
    // Kind of task, which decides when the controller runs it
    public RapidTaskType Type { get; set; }
}

public class RapidTaskInfo : RapidTaskItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidTaskInfo" data-throw-if-not-resolved="false"></xref> class
    public RapidTaskInfo()
 
    // Whether the task is bound to a configured task number, null when the controller did not report it
    public bool? BindReference { get; set; }
 
    // Number of cycles the task is set to run.
    // 
    // <p>Only reported over a connection established with version 2, and left to
    // <xref href="UnderAutomation.ABB.Rws.Data.RapidExecutionCycle.Unknown" data-throw-if-not-resolved="false"></xref> otherwise.</p>
    public RapidExecutionCycle ExecutionCycle { get; set; }
 
    // Level at which the code of the task is currently executing
    public RapidExecutionLevel ExecutionLevel { get; set; }
 
    // Stepping mode the task was last started with
    public RapidTaskExecutionMode ExecutionMode { get; set; }
 
    // What kind of code the task is currently running
    public RapidExecutionType ExecutionType { get; set; }
 
    // Routine the program pointer moves to when it is reset, for example "main"
    public string ProductionEntryPoint { get; set; }
 
    // Identifier of the task, null when the controller did not report it
    public int? TaskId { get; set; }
 
    // Name of the task running in the foreground, empty when there is none
    public string TaskInForeground { get; set; }
 
    // What the controller does to the system when this task stops unexpectedly
    public RapidTaskTrustLevel Trust { get; set; }
}

public class RapidTaskSelectionItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidTaskSelectionItem" data-throw-if-not-resolved="false"></xref> class
    public RapidTaskSelectionItem()
 
    // Whether the task can move a mechanical unit, null when the controller did not report it
    public bool? MotionTask { get; set; }
 
    // Name of the task, for example "T_ROB1"
    public string Name { get; set; }
 
    // Whether the task is selected, null when the controller did not report it
    public bool? Selected { get; set; }
 
    // Returns a string representation of this task selection
    public override string ToString()
 
    // Whether an operator is allowed to change the selection of this task, null when the
    // controller did not report it
    public bool? UserModify { get; set; }
}

public enum RapidTaskType {
 
    // A task started and stopped together with the program
    Normal = 1
 
    // A task restarted from its beginning every time the controller starts
    SemiStatic = 3
 
    // A task that keeps its program pointer where it was when the controller was switched off
    Static = 2
 
    // The controller reported a type this library does not know
    Unknown = 0
}

public enum RapidTaskState {
 
    // The task holds no program
    Empty = 1
 
    // The task has been created but its program is not linked yet
    Initiated = 2
 
    // The program of the task is linked and ready to run
    Linked = 3
 
    // A program is loaded into the task but not linked yet
    Loaded = 4
 
    // The task is not initialized
    Uninitialized = 5
 
    // The controller reported a state this library does not know
    Unknown = 0
}

public enum RapidTaskExecutionState {
 
    // The task is ready to be started
    Ready = 1
 
    // The task is running
    Started = 3
 
    // The task was running and has been stopped
    Stopped = 2
 
    // The task is not initialized
    Uninitialized = 4
 
    // The controller reported a state this library does not know
    Unknown = 0
}

public enum RapidTaskExecutionMode {
 
    // The task runs without stepping
    Continuous = 1
 
    // The task steps backwards
    StepBack = 5
 
    // The task steps into the routine calls
    StepIn = 3
 
    // The task steps to the last instruction
    StepLast = 6
 
    // The task steps out of the current routine
    StepOutOf = 4
 
    // The task steps over the routine calls
    StepOver = 2
 
    // The task advances one instruction at a time
    StepWise = 7
 
    // The controller reported a mode this library does not know
    Unknown = 0
}

public enum RapidTaskTrustLevel {
 
    // The system carries on
    None = 1
 
    // The whole system fails
    SystemFailure = 2
 
    // The system halts
    SystemHalt = 3
 
    // The system stops
    SystemStop = 4
 
    // The controller reported a level this library does not know
    Unknown = 0
}

// Links the program of a task, which is what turns the modules it holds into something runnable (synchronous) Read GetBuildErrors() afterwards to find out what the controller refused.
void BuildTask(string task);

// Loads a module file into a task (synchronous)
string LoadModule(string task, string modulePath, bool replace = false);

// Unloads a module from a task (synchronous)
void UnloadModule(string task, string module);

// Abandons the routine the task is currently running and returns to the level below it (synchronous) This is how a trap or a service routine started by hand is left without stopping the program underneath it.
void AbortExecutionLevel(string task);

// Gets whether the controller is executing RAPID code, and how many cycles it is set to run (synchronous)
RapidExecutionInfo GetExecutionState();

// Moves the program pointer of every task back to the entry point of its program (synchronous)
void ResetProgramPointer();

// Sets how many times the program runs before stopping (synchronous)
void SetExecutionCycle(RapidExecutionCycle cycle);

// Drives the hold-to-run control that lets the program run in manual mode (synchronous) Send RapidHoldToRunState.Press to allow execution to start, then RapidHoldToRunState.Held about every two seconds to keep it running; the controller stops the program as soon as it stops hearing from the client. Send RapidHoldToRunState.Release to stop it at once.
void SetHoldToRun(RapidHoldToRunState state);

// Starts executing the RAPID program from where the program pointer stands (synchronous) The controller has to be in automatic mode with the motors on, or in manual mode with the enabling device held. Reset the program pointer first with RapidService.ResetProgramPointer to start from the beginning.
void Start(RapidRegainMode regain = RapidRegainMode.Continue, RapidExecutionMode executionMode = RapidExecutionMode.Continue, RapidExecutionCycle cycle = RapidExecutionCycle.Forever, RapidStartCondition condition = RapidStartCondition.None, bool stopAtBreakpoint = false, bool allTasksBySelection = false);

// Starts executing from the production entry point of the program rather than from where the program pointer stands (synchronous)
void StartFromProductionEntry();

// Starts recording the RAPID execution trace into a file (synchronous) The trace names every instruction the controller runs, which is what it takes to find out why a program took a branch it should not have.
void StartSpy(string logFile);

// Stops the RAPID execution (synchronous)
void Stop(RapidStopMode stopMode = RapidStopMode.Stop, RapidTaskScope scope = RapidTaskScope.Normal);

// Stops recording the RAPID execution trace (synchronous)
void StopSpy();

public class RapidExecutionInfo {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidExecutionInfo" data-throw-if-not-resolved="false"></xref> class
    public RapidExecutionInfo()
 
    // Number of cycles the program is set to run
    public RapidExecutionCycle Cycle { get; set; }
 
    // Whether RAPID code is currently running
    public RapidExecutionState State { get; set; }
 
    // Returns a string representation of this execution state
    public override string ToString()
}

public enum RapidExecutionState {
 
    // RAPID execution is running
    Running = 1
 
    // RAPID execution is stopped
    Stopped = 2
 
    // The controller reported a state this library does not know
    Unknown = 0
}

public enum RapidExecutionCycle {
 
    // The cycle currently configured is left untouched
    AsIs = 2
 
    // The program runs again every time it reaches its end
    Forever = 1
 
    // The program runs once and stops at its end
    Once = 3
 
    // The program was asked to run once and has finished doing so
    OnceDone = 4
 
    // The controller reported a cycle this library does not know
    Unknown = 0
}

public enum RapidExecutionMode {
 
    // Run until something stops it
    Continue = 0
 
    // Step one instruction backwards
    StepBack = 4
 
    // Step into the routine called by the current instruction
    StepIn = 1
 
    // Step to the last instruction
    StepLast = 5
 
    // Step to the next motion instruction
    StepMotion = 6
 
    // Run until the current routine returns
    StepOut = 3
 
    // Run the current instruction whole, without entering the routine it calls
    StepOver = 2
}

public enum RapidRegainMode {
 
    // Drop the path and resume from the current position
    Clear = 2
 
    // Resume from the current position without moving back to the path
    Continue = 0
 
    // Resume by entering the consumption of the already generated path
    EnterConsume = 3
 
    // Move back onto the path before resuming
    Regain = 1
}

public enum RapidStopMode {
 
    // Stop when the current cycle ends
    Cycle = 0
 
    // Stop when the current instruction ends
    Instruction = 1
 
    // Stop as fast as the robot can, leaving the path
    QuickStop = 3
 
    // Stop as soon as the robot can decelerate along its path
    Stop = 2
}

public enum RapidStartCondition {
 
    // Start only when the call chain of the program pointer is still valid
    CallChain = 1
 
    // Start without any additional check
    None = 0
}

public enum RapidTaskScope {
 
    // Apply to every task of the system
    AllTasks = 1
 
    // Apply to the tasks the task selection panel has enabled
    Normal = 0
}

public enum RapidHoldToRunState {
 
    // Confirm that execution may keep running, which has to be repeated about every two seconds
    Held = 1
 
    // Ask for execution to be allowed to start
    Press = 0
 
    // Stop execution immediately
    Release = 2
}

// Gets whether the controller is recording the RAPID execution trace to a file (synchronous)
RapidSpyStatus GetSpyStatus();

public enum RapidSpyStatus {
 
    // The execution trace is being written
    Logging = 1
 
    // No execution trace is being written
    NotLogging = 2
 
    // The controller reported a status this library does not know
    Unknown = 0
}

// Gets whether the motion pointers of every task are synchronized with each other (synchronous)
RapidPointerSyncState GetMotionPointerSyncState();

// Gets where the program pointer and the motion pointer of a task stand (synchronous) The program pointer says which instruction runs next, the motion pointer which one the robot is actually executing; they drift apart because the controller plans the path ahead of the movement.
RapidPointers GetPointers(string task);

// Gets the program loaded into a task (synchronous)
RapidProgramInfo GetProgram(string task);

// Gets which piece of source the program pointer of a task points at (synchronous)
RapidProgramCounterPosition GetProgramCounterPosition(string task);

// Gets whether the program pointers of every task are synchronized with each other (synchronous)
RapidPointerSyncState GetProgramPointerSyncState();

// Gets the two counters a task keeps of what has changed in it (synchronous) Comparing them with what a previous reading gave is cheaper than fetching the modules again to find out that nothing moved.
RapidStructuralChangeCount GetStructuralChangeCount(string task);

// Moves the program pointer of a task to a position of a module (synchronous)
void SetProgramPointerToCursor(string task, string module, string routine, int row, int column);

// Moves the program pointer of a task forward by one instruction (synchronous)
void SetProgramPointerToNextInstruction(string task);

// Moves the program pointer of a task back by one instruction (synchronous)
void SetProgramPointerToPreviousInstruction(string task);

// Moves the program pointer of a task to the beginning of a routine (synchronous)
void SetProgramPointerToRoutine(string task, string module, string routine, bool userLevel = false);

// Moves the program pointer of a task to a routine named by its path (synchronous) This is what the paths GetServiceRoutines() reports are for.
void SetProgramPointerToRoutineUrl(string task, string routineUrl, bool userLevel = false);

public class RapidPointers {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidPointers" data-throw-if-not-resolved="false"></xref> class
    public RapidPointers()
 
    // Instruction the robot is currently moving for
    public RapidPointerPosition MotionPointer { get; set; }
 
    // Instruction the task will execute next
    public RapidPointerPosition ProgramPointer { get; set; }
 
    // Returns a string representation of the two pointers
    public override string ToString()
}

public class RapidPointerPosition {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidPointerPosition" data-throw-if-not-resolved="false"></xref> class
    public RapidPointerPosition()
 
    // Whether the controller reported a position for this pointer at all
    public bool Available { get; set; }
 
    // Column the pointer begins at, null when the controller did not report it
    public int? BeginColumn { get; set; }
 
    // Line the pointer begins at, null when the controller did not report it
    public int? BeginRow { get; set; }
 
    // How many times the pointer has been moved, null when the controller did not report it
    public int? ChangeCount { get; set; }
 
    // Column the pointer ends at, null when the controller did not report it
    public int? EndColumn { get; set; }
 
    // Line the pointer ends at, null when the controller did not report it
    public int? EndRow { get; set; }
 
    // What kind of code the pointer is standing in
    public RapidExecutionType ExecutionType { get; set; }
 
    // Name of the module the pointer stands in
    public string Module { get; set; }
 
    // Name of the routine the pointer stands in
    public string Routine { get; set; }
 
    // Returns a string representation of this pointer position
    public override string ToString()
}

public class RapidProgramCounterPosition {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidProgramCounterPosition" data-throw-if-not-resolved="false"></xref> class
    public RapidProgramCounterPosition()
 
    // Column the pointed instruction ends at, null when the controller did not report it
    public int? EndColumn { get; set; }
 
    // Line the pointed instruction ends at, null when the controller did not report it
    public int? EndLine { get; set; }
 
    // Name of the module the pointer stands in
    public string Module { get; set; }
 
    // Name of the routine the pointer stands in
    public string Routine { get; set; }
 
    // Column the pointed instruction starts at, null when the controller did not report it
    public int? StartColumn { get; set; }
 
    // Line the pointed instruction starts at, null when the controller did not report it
    public int? StartLine { get; set; }
 
    // Returns a string representation of this position
    public override string ToString()
}

public enum RapidPointerSyncState {
 
    // The pointers are not synchronized
    Off = 2
 
    // The pointers are synchronized
    On = 1
 
    // The controller reported a state this library does not know
    Unknown = 0
}

public class RapidStructuralChangeCount {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidStructuralChangeCount" data-throw-if-not-resolved="false"></xref> class
    public RapidStructuralChangeCount()
 
    // Counter the controller increments whenever anything relevant changes in the task
    public int? ChangeCount { get; set; }
 
    // Counter the controller increments when a module is loaded, unloaded or renamed.
    // 
    // <p>A rename counts as an unload followed by a load.</p>
    public int? StructuralChangeCount { get; set; }
 
    // Returns a string representation of these counters
    public override string ToString()
}

public enum RapidExecutionType {
 
    // An event routine is running
    EventRoutine = 6
 
    // An external interrupt is running
    ExternalInterrupt = 4
 
    // An interrupt is running
    Interrupt = 3
 
    // Nothing is running
    None = 1
 
    // The normal program is running
    Normal = 2
 
    // The controller reported a type this library does not know
    Unknown = 0
 
    // A user routine is running
    UserRoutine = 5
}

// Gets one frame of the call stack of a task: which routine is running and where execution stands in it (synchronous)
RapidActivationRecord GetActivationRecord(string task, int stackFrame = 1);

// Gets the routines of a task the program pointer can be moved to (synchronous)
RapidServiceRoutineItem[] GetServiceRoutines(string task, int? start = null, int? limit = null);

public class RapidActivationRecord {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidActivationRecord" data-throw-if-not-resolved="false"></xref> class
    public RapidActivationRecord()
 
    // Column the executing statement starts at, null when the controller did not report it
    public int? BeginColumn { get; set; }
 
    // Line the executing statement starts at, null when the controller did not report it
    public int? BeginRow { get; set; }
 
    // Column the executing statement ends at, null when the controller did not report it
    public int? EndColumn { get; set; }
 
    // Line the executing statement ends at, null when the controller did not report it
    public int? EndRow { get; set; }
 
    // Level at which this frame is executing
    public RapidExecutionLevel ExecutionLevel { get; set; }
 
    // Path of the routine this frame is executing
    public string RoutineUrl { get; set; }
 
    // Path identifying this stack frame, which the UI instruction resources also take
    public string StackUrl { get; set; }
 
    // Returns a string representation of this stack frame
    public override string ToString()
}

public class RapidServiceRoutineItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidServiceRoutineItem" data-throw-if-not-resolved="false"></xref> class
    public RapidServiceRoutineItem()
 
    // Whether this is a service routine rather than an ordinary one, null when the controller
    // did not report it
    public bool? IsServiceRoutine { get; set; }
 
    // Name of the routine, for example "LoadIdentify"
    public string Name { get; set; }
 
    // Returns a string representation of this routine
    public override string ToString()
 
    // Path of the routine, which <code>RapidService.SetProgramPointerToRoutineUrl()</code> takes
    public string Url { get; set; }
}

public enum RapidExecutionLevel {
 
    // Nothing is executing
    None = 1
 
    // The normal user code is executing
    Normal = 2
 
    // A trap routine is executing
    Trap = 3
 
    // The controller reported a level this library does not know
    Unknown = 0
 
    // A user routine is executing
    User = 4
}

// Gets the dialogue a running RAPID program is currently asking an operator for (synchronous) Answering it means writing its parameters with String%2cSystem.String), addressed by the path this returns.
RapidUiInstruction GetActiveUiInstruction();

// Gets the value of one parameter of a pending UI instruction (synchronous)
string GetUiInstructionParameter(string stackUrl, string parameter);

// Gets every parameter of a pending UI instruction: what the program passed in, and what it is waiting for (synchronous)
RapidUiInstructionParameter[] GetUiInstructionParameters(string stackUrl);

// Answers a pending UI instruction by writing one of its parameters (synchronous) An instruction is normally answered by writing the parameter carrying the answer and then the one marking it as completed.
void SetUiInstructionParameter(string stackUrl, string parameter, string value);

public class RapidUiInstruction {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidUiInstruction" data-throw-if-not-resolved="false"></xref> class
    public RapidUiInstruction()
 
    // What the instruction is asking of the client
    public RapidUiInstructionEvent Event { get; set; }
 
    // Level at which the instruction is executing
    public RapidExecutionLevel ExecutionLevel { get; set; }
 
    // Name of the RAPID instruction that opened the dialogue, for example "TPReadNum"
    public string Instruction { get; set; }
 
    // Text the instruction displays
    public string Message { get; set; }
 
    // Path identifying the call, which the parameter methods take
    public string StackUrl { get; set; }
 
    // Returns a string representation of this instruction
    public override string ToString()
}

public class RapidUiInstructionParameter {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidUiInstructionParameter" data-throw-if-not-resolved="false"></xref> class
    public RapidUiInstructionParameter()
 
    // Name of the parameter, for example "TPCompleted"
    public string Name { get; set; }
 
    // Returns a string representation of this parameter
    public override string ToString()
 
    // Value of the parameter, written the way RAPID writes it
    public string Value { get; set; }
}

public enum RapidUiInstructionEvent {
 
    // The instruction has been abandoned and no answer is expected any more
    Abort = 3
 
    // The instruction only displays something and expects no answer
    Post = 2
 
    // The instruction is waiting for an answer
    Send = 1
 
    // The controller reported an event this library does not know
    Unknown = 0
}

// Gets the I/O signals a running RAPID program has given an alias to (synchronous)
RapidAliasIoItem[] GetAliasIo(int? start = null, int? limit = null);

public class RapidAliasIoItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidAliasIoItem" data-throw-if-not-resolved="false"></xref> class
    public RapidAliasIoItem()
 
    // Name the RAPID program refers to the signal by
    public string AliasName { get; set; }
 
    // Name of the I/O signal the alias points at
    public string SignalName { get; set; }
 
    // Returns a string representation of this alias
    public override string ToString()
 
    // Type of the aliased signal
    public IoSignalType Type { get; set; }
}