Controller: identity, clock & backup

// Gets the value of a controller environment variable (synchronous)
string GetEnvironmentVariable(string name);

// Gets the identity of the controller: name, id, type, MAC address and level (synchronous)
ControllerIdentity GetIdentity();

// Gets an overview of the controller resources (synchronous) Contains the current system time, the controller identity and the list of available sub resources.
ControllerInfo GetInfo();

// Sets the identity of the controller (synchronous) Available only on a real controller.
void SetIdentity(string name, string id = null);

public class ControllerInfo {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.ControllerInfo" data-throw-if-not-resolved="false"></xref> class
    public ControllerInfo()
 
    // Indicates whether the controller runs at system level or in bootserver mode
    public ControllerLevel Level { get; set; }
 
    // Name of the controller
    public string Name { get; set; }
 
    // Names of the sub resources exposed by the controller ("clock", "identity", "network", ...)
    public string[] Resources { get; set; }
 
    // Current system time of the controller (UTC), if available
    public DateTime? SystemTime { get; set; }
 
    // Returns a string representation of this controller information
    public override string ToString()
 
    // Indicates whether the controller is a real or a virtual controller
    public ControllerType Type { get; set; }
}

public class ControllerIdentity {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.ControllerIdentity" data-throw-if-not-resolved="false"></xref> class
    public ControllerIdentity()
 
    // Controller id, available only for a real controller
    public string Id { get; set; }
 
    // Indicates whether the controller runs at system level or in bootserver mode
    public ControllerLevel Level { get; set; }
 
    // MAC address of the controller, available only for a real controller
    public string MacAddress { get; set; }
 
    // Name of the controller
    public string Name { get; set; }
 
    // Returns a string representation of this controller identity
    public override string ToString()
 
    // Indicates whether the controller is a real or a virtual controller
    public ControllerType Type { get; set; }
}

public enum ControllerType {
 
    // Physical robot controller (RC)
    RealController = 1
 
    // The controller type could not be determined
    Unknown = 0
 
    // Virtual controller (VC), for example running in RobotStudio
    VirtualController = 2
}

public enum ControllerLevel {
 
    // The controller runs the boot application (bootserver mode)
    BootLevel = 2
 
    // A system is loaded and running (system level)
    SystemLevel = 1
 
    // The controller level could not be determined
    Unknown = 0
}

// Gets the current system time of the controller (synchronous) The time returned by the controller is always UTC.
DateTime GetClock();

// Gets the time server used by the controller to synchronize its clock (synchronous) Available only on a real controller.
TimeServerInfo GetTimeServer(string serverIp = null);

// Gets the time zone used by the controller (synchronous)
string GetTimeZone();

// Sets the system time of the controller (synchronous) The controller clock is always UTC, pass a UTC date and time. Instead of setting the time explicitly, a time server can be configured with SetTimeServer(System.String).
void SetClock(DateTime dateTime);

// Sets the time server used by the controller to synchronize its clock (synchronous) Available only on a real controller.
void SetTimeServer(string timeServer);

// Sets the time zone used by the controller (synchronous) Available only on a real controller.
void SetTimeZone(string timeZone);

public class TimeServerInfo {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.TimeServerInfo" data-throw-if-not-resolved="false"></xref> class
    public TimeServerInfo()
 
    // Address of the time server
    public string Address { get; set; }
 
    // Time reported by the time server (UTC), if available.
    // 
    // <p>Only available when connected with version 2.</p>
    public DateTime? Time { get; set; }
 
    // Returns a string representation of this time server
    public override string ToString()
}

// Gets the IP configuration of all network interfaces of the controller (synchronous) Not applicable to a virtual controller.
NetworkInterfaceItem[] GetNetworkInterfaces();

// Sets the IP configuration of the LAN adapter of the controller (synchronous) The controller must be restarted for the change to take effect. Requires the UAS grant UAS_CONTROLLER_PROPERTIES_WRITE. Not supported by a virtual controller.
void SetNetworkConfiguration(NetworkConfigurationMethod method, string address = null, string mask = null, string gateway = null);

public class NetworkInterfaceItem {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.NetworkInterfaceItem" data-throw-if-not-resolved="false"></xref> class
    public NetworkInterfaceItem()
 
    // IP address of the interface
    public string Address { get; set; }
 
    // DHCP status of the interface, if reported by the controller
    public bool? DhcpEnabled { get; set; }
 
    // Default gateway of the interface, if applicable
    public string Gateway { get; set; }
 
    // Logical name of the interface, for example "WAN", "LAN1" or "SERVICE"
    public string LogicalName { get; set; }
 
    // Subnet mask of the interface
    public string Mask { get; set; }
 
    // Network the interface belongs to ("Public", "Private", "Ability", "Drive").
    // 
    // <p>Only available when connected with version 2.</p>
    public string Network { get; set; }
 
    // Physical port of the interface, for example "X6" or "X23"
    public string Port { get; set; }
 
    // Primary DNS server of the interface.
    // 
    // <p>Only available when connected with version 2.</p>
    public string PrimaryDns { get; set; }
 
    // Secondary DNS server of the interface.
    // 
    // <p>Only available when connected with version 2.</p>
    public string SecondaryDns { get; set; }
 
    // Returns a string representation of this network interface
    public override string ToString()
}

public enum NetworkConfigurationMethod {
 
    // IP address obtained from a DHCP server
    Dhcp = 1
 
    // Fixed IP address, the address, mask and gateway have to be provided
    FixIp = 0
 
    // No IP address configured on the adapter
    NoIp = 2
}

// Gets the names of the systems installed on the controller (synchronous)
string[] GetInstalledSystems();

// Verifies whether an option is present on the controller (synchronous) The option name is case sensitive, for example "SAFEMOVEPRO".
bool HasOption(string option);

// Checks whether a RobotWare version is compatible with the controller hardware (synchronous) Supported only on a real controller.
bool IsRobotWareVersionCompatible(string robotWareVersion);

// Sets the language of the controller (synchronous)
void SetLanguage(string language);

// Restarts or shuts down the controller (synchronous)
void Restart(ControllerRestartMode mode, bool useImplicitMastership = true);

public enum ControllerRestartMode {
 
    // The controller will be restarted. The last automatically saved system state will be loaded.
    // Should be used to recover from a system crash.
    BStart = 5
 
    // The controller will be restarted. The current system parameter settings and RAPID programs will be discarded,
    // and the original system installation settings will be used.
    IStart = 3
 
    // The controller will be restarted. The current RAPID programs and data will be discarded, but not the system parameter settings.
    PStart = 4
 
    // The controller will be restarted. The state is saved and any changed system parameter settings will be activated after the restart.
    Restart = 0
 
    // The main computer will be shut down. Should be used if the controller UPS is broken.
    Shutdown = 1
 
    // The controller will be restarted and the Boot Application will be started. The current system is saved and deactivated
    // (the controller is non-functional, for advanced maintenance only).
    XStart = 2
}

// Checks a backup for mismatches and other problems before restoring it (synchronous)
CheckRestoreResult CheckRestore(string backupPath, BackupRestoreIgnore ignore = BackupRestoreIgnore.None, bool includeControllerSettings = true, bool includeSafetySettings = true, BackupRestoreInclude include = BackupRestoreInclude.All);

// Creates a backup of the current system on the controller file system (synchronous) The backup is created asynchronously by the controller: this method returns as soon as the request is accepted. Poll ControllerService.GetBackupState to know when the backup is finished. Requires the UAS grant UAS_BACKUP. Creating a backup may affect RAPID execution and can cause system stops.
void CreateBackup(string backupPath, bool archive = false);

// Gets information about a backup stored on the controller file system (synchronous)
BackupSystemInfo GetBackupInfo(string backupPath);

// Gets the names of the backup sub resources exposed by the controller (synchronous)
string[] GetBackupResources();

// Gets the state of the backup operation of the controller (synchronous) Used to follow a backup started with String%2cSystem.Boolean).
BackupState GetBackupState();

// Restores a backup stored on the controller file system (synchronous) When the backup can be restored, the controller restarts. Requires the UAS grant to restore a backup. Use Data.BackupRestoreInclude) first to detect mismatches.
void RestoreBackup(string backupPath, BackupRestoreIgnore ignore = BackupRestoreIgnore.None, bool deleteDirectory = true, bool includeControllerSettings = true, bool includeSafetySettings = true, BackupRestoreInclude include = BackupRestoreInclude.All);

public class BackupSystemInfo {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.BackupSystemInfo" data-throw-if-not-resolved="false"></xref> class
    public BackupSystemInfo()
 
    // Number of options installed on the backed up system
    public int OptionCount { get; }
 
    // Options installed on the backed up system
    public string[] Options { get; set; }
 
    // RobotControl version of the backed up system.
    // 
    // <p>Only available when connected with version 2.</p>
    public string RobotControlVersion { get; set; }
 
    // RobotOS version of the backed up system.
    // 
    // <p>Only available when connected with version 2.</p>
    public string RobotOsVersion { get; set; }
 
    // RobotWare version of the backed up system.
    // 
    // <p>Only available when connected with version 1.</p>
    public string RobotWareVersion { get; set; }
 
    // Name of the backed up system
    public string SystemName { get; set; }
 
    // Returns a string representation of this backup information
    public override string ToString()
}

public enum BackupState {
 
    // A backup operation is running
    BackupInProgress = 3
 
    // The backup operation finished successfully
    BackupReady = 4
 
    // The backup operation failed
    ErrorDuringBackup = 5
 
    // A backup operation has been initialized
    InitState = 2
 
    // The backup state is invalid
    Invalid = 6
 
    // No backup operation
    None = 1
 
    // The backup state could not be determined
    Unknown = 0
}

public class CheckRestoreResult {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.CheckRestoreResult" data-throw-if-not-resolved="false"></xref> class
    public CheckRestoreResult()
 
    // Indicates whether the backup can be restored
    public bool IsAccepted { get; }
 
    // File missing or corrupted in the backup, if reported by the controller
    public string Path { get; set; }
 
    // Status of the check
    public CheckRestoreStatus Status { get; set; }
 
    // Returns a string representation of this check result
    public override string ToString()
}

public enum CheckRestoreStatus {
 
    // The backup is accepted and can be restored
    Accepted = 1
 
    // Error in the configuration data of the backup
    ConfigurationDataIncorrect = 5
 
    // The backup directory is not complete
    DirectoryNotComplete = 4
 
    // The backup was not created from the current system, there might be differences in active options and selected languages
    RestoreMismatchSystemId = 2
 
    // The current system and the backed up system may be generated from different key ids, possibly with different robot types
    RestoreMismatchTemplateId = 3
 
    // The status could not be determined
    Unknown = 0
}

public enum BackupRestoreIgnore {
 
    // All mismatches are ignored
    All = 1
 
    // No mismatch is ignored
    None = 0
 
    // A mismatch between the system id of the backup and the system id of the current system is ignored
    SystemId = 2
 
    // A mismatch between the template id of the backup and the template id of the current system is ignored
    TemplateId = 3
}

public enum BackupRestoreInclude {
 
    // Restore configuration files and RAPID modules
    All = 0
 
    // Restore configuration files only
    Cfg = 1
 
    // Restore RAPID modules only
    Modules = 2
}

// Gets the cyclic brake check status of a mechanical unit (synchronous)
CyclicBrakeCheckStatus GetCyclicBrakeCheckStatus(int driveNumber);

// Gets the safety supervision configuration of the controller (synchronous)
SafetyConfiguration GetSafetyConfiguration();

// Checks whether a new safety configuration is allowed to be loaded (synchronous) The user must have the safety services privileges.
SafetyLoadOperationStatus GetSafetyLoadOperationStatus();

// Gets the safety mode of the controller (synchronous)
SafetyModeStatus GetSafetyMode();

// Gets the names of the safety sub resources exposed by the controller (synchronous)
string[] GetSafetyResources();

// Gets the safety violation details reported by the safety controller (synchronous) The user must have the safety services privileges.
SafetyViolationInfo GetSafetyViolationInfo();

// Removes the validation information from the safety configuration file (synchronous) Requires the UAS grant UAS_SAFETY_SERVICES.
void InvalidateSafetyConfiguration();

// Loads a safety configuration file into the controller (synchronous) The configuration file must already exist on the controller file system. Use ControllerService.GetSafetyLoadOperationStatus to check whether loading is currently allowed.
void LoadSafetyConfiguration(string filePath);

// Sets the safety mode of the controller (synchronous) The controller must be in manual mode.
void SetSafetyMode(SafetyMode mode);

public class SafetyModeStatus {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.SafetyModeStatus" data-throw-if-not-resolved="false"></xref> class
    public SafetyModeStatus()
 
    // Current safety mode
    public SafetyMode Mode { get; set; }
 
    // Returns a string representation of this safety mode status
    public override string ToString()
 
    // User data associated with the safety mode, if reported by the controller
    public int? UserData { get; set; }
}

public enum SafetyMode {
 
    // The safety configuration is active and supervised
    Active = 1
 
    // Commissioning mode, used while configuring the safety controller
    Commissioning = 2
 
    // The safety controller reports a mode error
    ModeError = 4
 
    // Service mode
    Service = 3
 
    // The safety mode could not be determined
    Unknown = 0
}

public class SafetyConfiguration {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.SafetyConfiguration" data-throw-if-not-resolved="false"></xref> class
    public SafetyConfiguration()
 
    // Checksum of the configuration, as base64 encoded data
    public string Checksum { get; set; }
 
    // Status of the configuration, for example "SCORCH_CONFIG_LOADED".
    // 
    // <p>Only available when connected with version 2.</p>
    public string ConfigurationStatus { get; set; }
 
    // Author of the configuration
    public string CreatedBy { get; set; }
 
    // Creation date of the configuration, if available
    public DateTime? CreationDate { get; set; }
 
    // Configuration file major version
    public int? FileMajorVersion { get; set; }
 
    // Configuration file minor version
    public int? FileMinorVersion { get; set; }
 
    // Configuration file revision
    public int? FileRevision { get; set; }
 
    // Name of the configuration
    public string Name { get; set; }
 
    // Safety software major version
    public int? SoftwareMajorVersion { get; set; }
 
    // Safety software minor version
    public int? SoftwareMinorVersion { get; set; }
 
    // Safety software revision
    public int? SoftwareRevision { get; set; }
 
    // Returns a string representation of this safety configuration
    public override string ToString()
}

public enum SafetyLoadOperationStatus {
 
    // The current safety configuration is locked (SCORCH_ERR_CURRENT_CONFIG_LOCKED)
    CurrentConfigurationLocked = 5
 
    // The controller is not in manual mode (SCORCH_ERR_NOT_IN_MANUAL_MODE)
    NotInManualMode = 3
 
    // The motors are not switched off (SCORCH_ERR_NOT_IN_MOTORS_OFF)
    NotInMotorsOff = 4
 
    // Loading a new safety configuration is allowed
    Ok = 1
 
    // The safety option is not present on the controller (SCORCH_ERR_OPTION_NOT_PRESENT)
    OptionNotPresent = 2
 
    // The status could not be determined
    Unknown = 0
 
    // The user does not have the required grant (SCORCH_ERR_USER_GRANT_IS_MISSING)
    UserGrantMissing = 6
}

public class SafetyViolationInfo {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.SafetyViolationInfo" data-throw-if-not-resolved="false"></xref> class
    public SafetyViolationInfo()
 
    // Axis range supervision active status
    public int? AxisRangeActiveStatus { get; set; }
 
    // Axis range violation status
    public int? AxisRangeViolationStatus { get; set; }
 
    // Index of the drive module involved in the violation
    public int? DriveModuleIndex { get; set; }
 
    // Instance id of the last violation
    public int? LastViolationInstanceId { get; set; }
 
    // Returns a string representation of this safety violation information
    public override string ToString()
 
    // Id of the tool involved in the violation
    public int? ToolId { get; set; }
 
    // Tool position supervision active status
    public int? ToolPositionActiveStatus { get; set; }
 
    // Tool position violation status
    public int? ToolPositionViolationStatus { get; set; }
 
    // Tool speed supervision active status
    public int? ToolSpeedActiveStatus { get; set; }
 
    // Tool speed violation status
    public int? ToolSpeedViolationStatus { get; set; }
 
    // Indicates whether the robot is unsynchronized
    public int? Unsynchronized { get; set; }
 
    // Upper arm violation status
    public int? UpperArmViolationStatus { get; set; }
 
    // Violating safety supervision value
    public int? ViolatingSsv { get; set; }
 
    // Number of violations
    public int? ViolationNumber { get; set; }
 
    // Type of the current violation
    public SafetyViolationType ViolationType { get; set; }
}

public enum SafetyViolationType {
 
    // Emergency stop triggered (empstop)
    EmergencyStop = 12
 
    // The safety controller reports an invalid violation
    Invalid = 14
 
    // No violation
    None = 1
 
    // Operational Safety Range (osr)
    OperationalSafetyRange = 7
 
    // Internal error (other)
    Other = 13
 
    // Reduced Axis Speed in manual mode (red_axis_speed)
    ReducedAxisSpeed = 10
 
    // Reduced Tool Speed in manual mode (red_tool_speed)
    ReducedToolSpeed = 9
 
    // Safe Axis Range (sar)
    SafeAxisRange = 3
 
    // Safe Axis Speed (sas)
    SafeAxisSpeed = 5
 
    // Safe Standstill (sst)
    SafeStandstill = 8
 
    // Safe Tool Speed (sts)
    SafeToolSpeed = 4
 
    // Safe Tool Zone (stz)
    SafeToolZone = 2
 
    // Tool Orientation Monitoring (tom)
    ToolOrientationMonitoring = 6
 
    // The violation type could not be determined
    Unknown = 0
 
    // Reduced Axis Speed due to unsynchronized robot (unsync_speed_lim)
    UnsynchronizedSpeedLimit = 11
}

public class CyclicBrakeCheckStatus {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.CyclicBrakeCheckStatus" data-throw-if-not-resolved="false"></xref> class
    public CyclicBrakeCheckStatus()
 
    // Drive number of the mechanical unit this status belongs to
    public int DriveNumber { get; set; }
 
    // Result of the last brake check
    public CyclicBrakeCheckTestStatus LastBrakeCheckStatus { get; set; }
 
    // Remaining time before the next brake check is required, if reported by the controller
    public long? NextBrakeCheckTime { get; set; }
 
    // Current cyclic brake check state
    public CyclicBrakeCheckState Status { get; set; }
 
    // Returns a string representation of this cyclic brake check status
    public override string ToString()
}

public enum CyclicBrakeCheckState {
 
    // No brake check is needed (CBC_STATUS_OK)
    Ok = 1
 
    // A brake check will soon be required (CBC_STATUS_PREWARNING)
    PreWarning = 2
 
    // A brake check is required (CBC_STATUS_REQUIRE_CBC)
    Required = 3
 
    // The state could not be determined
    Unknown = 0
}

public enum CyclicBrakeCheckTestStatus {
 
    // The last brake check failed (CBC_TEST_ERROR)
    Error = 3
 
    // The last brake check succeeded (CBC_TEST_OK)
    Ok = 1
 
    // No brake check has been performed yet (CBC_TEST_UNDEFINED)
    Undefined = 4
 
    // The test status could not be determined
    Unknown = 0
 
    // The last brake check ended with a warning (CBC_TEST_WARNING)
    Warning = 2
}

// Gets the current value of the virtual time, in milliseconds (synchronous) The virtual time is zeroed when the virtual controller starts. Supported only on a virtual controller.
long GetVirtualTime();

// Gets the names of the virtual time sub resources exposed by the controller (synchronous) Supported only on a virtual controller.
string[] GetVirtualTimeResources();

// Gets the time slice of the virtual controller, in milliseconds (synchronous) Supported only on a virtual controller.
int GetVirtualTimeSlice();

// Gets the speed of the virtual time, in percent relative to real time (synchronous) -1 means full speed. Supported only on a virtual controller.
int GetVirtualTimeSpeed();

// Gets the state of the virtual time server (synchronous) Supported only on a virtual controller.
VirtualTimeState GetVirtualTimeState();

// Executes the virtual time according to the current state of the virtual time server (synchronous) Supported only on a virtual controller.
void RunVirtualTime();

// Sets the time slice of the virtual controller, in milliseconds (synchronous) The minimum value is 10 ms, lower values are replaced by the controller with the default value of 10 ms. Supported only on a virtual controller.
void SetVirtualTimeSlice(int milliseconds);

// Sets the speed of the virtual time, in percent relative to real time (synchronous) 100 makes the virtual time run approximately at real time speed, -1 runs it as fast as possible. Supported only on a virtual controller.
void SetVirtualTimeSpeed(int speed);

// Sets the state of the virtual time server (synchronous) Supported only on a virtual controller.
void SetVirtualTimeState(VirtualTimeState state);

public enum VirtualTimeState {
 
    // Virtual time runs freely (VTFREERUN)
    FreeRun = 2
 
    // Virtual time runs until the next event (VTNEXTEVENT)
    NextEvent = 4
 
    // Virtual time runs one time slice at a time (VTRUNSLICE)
    RunSlice = 3
 
    // Virtual time is stopped (VTSTOP)
    Stop = 1
 
    // The state could not be determined
    Unknown = 0
}