Interpreter Mode

public abstract class InterpreterModeClientBase : URServiceBase {
 
    // The interpreter mode offers a mechanism to abort limited number of script functions, even if they are
    // called from the main program. Currently only movej and movel can be aborted.
    // Aborting a movement will result in a controlled stop if no blend radius is defined.
    // If a blend radius is defined then a blend with the next movement will be initiated right away if not
    // already in an initial blend, otherwise the command is ignored.
    // Return value should be ignored
    public CommandResponse Abort()
 
    // Clears all interpreted statements, objects, functions, threads, etc. generated in the current
    // interpreter mode.Threads started in current interpreter session will be stopped, and deleted.
    // Variables defined outside of the current interpreter mode will not be affected by a call to thisfunction.
    // Only statements interpreted before the clear_interpreter() function will be cleared.
    // Statements sent after clear_interpreter() will be queued. When cleaning is done, any
    // statements queued are interpreted and responded to. Note that commands such as abort,
    // skipbuffer and state commands are executed as soon as they are received.
    public CommandResponse ClearInterpreter()
 
    // Indicates that the interpreter mode client is connected and ready to send commands
    public bool Connected { get; }
     protected void ConnectInternal(string ip, int port)
 
    // Disconnect interpreter mode socket connection
    public void Disconnect()
 
    // Ends the interpreter mode, and causes the interpreter_mode() function to return. This
    // function can be compiled into the program by sending it to the interpreter socket(30020) as any
    // other statement, or can be called from anywhere else in the program.
    // By default everything interpreted will be cleared when ending, though the state of the robot, the
    // modifications to local variables from the enclosing scope, and the global variables will remain
    // affected by any changes made.The interpreter thread will be idle after this call.
    public CommandResponse EndInterpreter()
 
    // Executes a command on the Interpreter Mode
    public CommandResponse ExecuteCommand(string command)
 
    // IP of the robot to connect to for sending commands
    public string IP { get; }
 
    // Interpreter mode server port
    public int Port { get; set; }
 
    // The interpreter mode furthermore supports the opportunity to skip already sent but not executed
    // statements.The interpreter thread will then(after finishing the currently executing statement) skip
    // all received but not executed statements.
    // After the skip, the interpreter thread will idle until new statements are received.skipbuffer will
    // only skip already received statements, new statements can therefore be send right away.
    // Return value should be ignored
    public CommandResponse SkipBuffer()
 
    // Replies with the id for the latest statement to be cleared from the interpreter mode. This clear can happen when ending interpreter mode, or by calls to clear_interpreter()
    public CommandResponse StateLastCleared()
 
    // Replies with the largest id of a statement that has started being executed.
    public CommandResponse StateLastExecuted()
 
    // Replies with the latest interpreted id, i.e. the highest number of interpreted statement so far.
    public CommandResponse StateLastInterpreted()
 
    // Replies with the number of non executed statements, i.e. the number of statements that would have be skipped if skipbuffer was called instead.
    public CommandResponse StateLastUnexecuted()
}

public class CommandResponse {
 
    // Answer from the interpreter mode
    public string Body { get; }
 
    // Command sent to the interpreter mode
    public string Command { get; }
 
    // Command unique identifier
    public int Id { get; }
 
    // Raw line sent from the controller
    public string RawAnswer { get; }
 
    // Response type to check if command succeed
    public CommandResponseStatus Status { get; }
     public override string ToString()
}

public enum CommandResponseStatus {
 
    // The command compilation succeed and Interpreter mode will execute the statement
    Ack = 0
 
    // Program is not running or the statement results in a compilation or linker error
    Discard = 1
 
    // Something went wrong when receiving response
    Error = -1
 
    // Answer from a state command
    State = 2
}

public abstract class InterpreterModeClientParametersBase {
 
    // Default Interpreter Mode server TCP port
    public const int DEFAULT_PORT = 30020
 
    // Interpreter Mode client TCP port. Default : 30020
    public int Port { get; set; }
}

public class InterpreterModeConnectParameters : InterpreterModeClientParametersBase {
 
    // Enable Interpreter Mode client communication
    // Default value is false
    public bool Enable { get; set; }
}