Controller: identity, clock & backup

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Overview of the controller: system time, name, type and level
ControllerInfo info = robot.Rws.Controller.GetInfo();
Console.WriteLine($"{info.Name} ({info.Type}), level {info.Level}");
Console.WriteLine($"Controller time (UTC) : {info.SystemTime}");

// Identity of the controller, with its id and its MAC address
ControllerIdentity identity = robot.Rws.Controller.GetIdentity();
Console.WriteLine($"Id : {identity.Id}");
Console.WriteLine($"MAC address : {identity.MacAddress}");

// Type tells a real controller from a RobotStudio virtual controller
bool isVirtual = identity.Type == ControllerType.VirtualController;
Console.WriteLine($"Virtual controller : {isVirtual}");


// Rename the controller. Only a real controller accepts it.
robot.Rws.Controller.SetIdentity("CELL_01");
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// The controller clock is always UTC
DateTime clock = robot.Rws.Controller.GetClock();
Console.WriteLine($"Controller time (UTC) : {clock}");

// Set the clock from the PC time
robot.Rws.Controller.SetClock(DateTime.UtcNow);

// Time zone, named as in the tz database
Console.WriteLine($"Time zone : {robot.Rws.Controller.GetTimeZone()}");
robot.Rws.Controller.SetTimeZone("Europe/Stockholm");


// Time server the controller synchronizes its clock with
robot.Rws.Controller.SetTimeServer("132.163.4.101");

TimeServerInfo timeServer = robot.Rws.Controller.GetTimeServer();

// null when no time server is configured
if (timeServer != null)
{
    Console.WriteLine($"{timeServer.Address} answers {timeServer.Time}");
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// IP configuration of every network interface of the controller
NetworkInterfaceItem[] interfaces = robot.Rws.Controller.GetNetworkInterfaces();

foreach (NetworkInterfaceItem item in interfaces)
{
    Console.WriteLine($"{item.Port} {item.LogicalName} : {item.Address} / {item.Mask}");
    Console.WriteLine($"   gateway {item.Gateway}, DHCP {item.DhcpEnabled}");
}


// Fixed address on the LAN adapter
robot.Rws.Controller.SetNetworkConfiguration(NetworkConfigurationMethod.FixIp,
                                             "192.168.0.10",
                                             "255.255.255.0",
                                             "192.168.0.254");

// Or let a DHCP server give the address
robot.Rws.Controller.SetNetworkConfiguration(NetworkConfigurationMethod.Dhcp);

// The new configuration is used after the next restart
robot.Rws.Controller.Restart(ControllerRestartMode.Restart);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Is an option installed? The name is case sensitive.
bool hasSafeMove = robot.Rws.Controller.HasOption("SAFEMOVEPRO");
Console.WriteLine($"SafeMove Pro : {hasSafeMove}");

// Systems installed on the controller
string[] systems = robot.Rws.Controller.GetInstalledSystems();
Console.WriteLine($"Installed systems : {string.Join(", ", systems)}");


// Value of a controller environment variable
string temp = robot.Rws.Controller.GetEnvironmentVariable("$TEMP");
Console.WriteLine($"$TEMP is {temp}");

// Would this RobotWare version run on this hardware?
bool compatible = robot.Rws.Controller.IsRobotWareVersionCompatible("6.03.0101");
Console.WriteLine($"Compatible : {compatible}");
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Warm restart of the controller
robot.Rws.Controller.Restart(ControllerRestartMode.Restart);

// The controller closes the connection while it reboots
robot.Disconnect();


// Try to reconnect until the controller answers again
while (true)
{
    try
    {
        robot.Connect("192.168.0.1");
        break;
    }
    catch (Exception)
    {
        Thread.Sleep(5000);
    }
}

Console.WriteLine(robot.Rws.Panel.GetControllerState());
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// The controller creates the backup in the background, this call returns immediately
robot.Rws.Controller.CreateBackup("$temp/mybackup");

// Poll the state until the controller is done
BackupState state = robot.Rws.Controller.GetBackupState();

while (state == BackupState.BackupInProgress)
{
    Thread.Sleep(1000);
    state = robot.Rws.Controller.GetBackupState();
}

if (state != BackupState.BackupReady)
{
    Console.WriteLine($"The backup failed : {state}");
    return;
}


// What the backup contains
BackupSystemInfo backup = robot.Rws.Controller.GetBackupInfo("$temp/mybackup");
Console.WriteLine($"{backup.SystemName}, RobotWare {backup.RobotWareVersion}");
Console.WriteLine($"{backup.OptionCount} option(s) : {string.Join(", ", backup.Options)}");
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Check the backup before restoring it
CheckRestoreResult check = robot.Rws.Controller.CheckRestore("$temp/mybackup");

if (!check.IsAccepted)
{
    Console.WriteLine($"The backup cannot be restored : {check.Status} {check.Path}");
    return;
}


// The controller restarts as soon as the restore is accepted
robot.Rws.Controller.RestoreBackup("$temp/mybackup");

// A backup taken on another controller has a different system id.
// Ignore the mismatch to restore it anyway, and keep the backup folder.
robot.Rws.Controller.RestoreBackup("$temp/mybackup",
                                   BackupRestoreIgnore.SystemId,
                                   false);

// Restore only the RAPID modules, not the configuration
robot.Rws.Controller.RestoreBackup("$temp/mybackup",
                                   BackupRestoreIgnore.All,
                                   true,
                                   true,
                                   true,
                                   BackupRestoreInclude.Modules);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Current safety mode of the controller
SafetyModeStatus mode = robot.Rws.Controller.GetSafetyMode();
Console.WriteLine($"Safety mode : {mode.Mode}, user data {mode.UserData}");

// Versions and checksum of the loaded safety configuration
SafetyConfiguration configuration = robot.Rws.Controller.GetSafetyConfiguration();
Console.WriteLine($"{configuration.Name} created on {configuration.CreationDate} by {configuration.CreatedBy}");
Console.WriteLine($"Checksum : {configuration.Checksum}");


// What the safety controller reports about the last violation
SafetyViolationInfo violation = robot.Rws.Controller.GetSafetyViolationInfo();
Console.WriteLine($"{violation.ViolationNumber} violation(s), type {violation.ViolationType}");

// Cyclic brake check of the drive number 1
CyclicBrakeCheckStatus brakeCheck = robot.Rws.Controller.GetCyclicBrakeCheckStatus(1);
Console.WriteLine($"Brake check : {brakeCheck.Status}, last result {brakeCheck.LastBrakeCheckStatus}");
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// A safety configuration can only be loaded in some controller states
SafetyLoadOperationStatus status = robot.Rws.Controller.GetSafetyLoadOperationStatus();

if (status == SafetyLoadOperationStatus.Ok)
{
    // The file is already on the controller file system
    robot.Rws.Controller.LoadSafetyConfiguration("$home/safety.xml");
}
else
{
    Console.WriteLine($"A safety configuration cannot be loaded now : {status}");
}


// The controller must be in manual mode to change the safety mode
robot.Rws.Controller.SetSafetyMode(SafetyMode.Commissioning);

// Removes the validation information of the current safety configuration
robot.Rws.Controller.InvalidateSafetyConfiguration();
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("127.0.0.1");
// Milliseconds elapsed since the virtual controller started
long virtualTime = robot.Rws.Controller.GetVirtualTime();
Console.WriteLine($"Virtual time : {virtualTime} ms");

// 100 is about real time, -1 runs the simulation as fast as possible
robot.Rws.Controller.SetVirtualTimeSpeed(100);
Console.WriteLine($"Speed : {robot.Rws.Controller.GetVirtualTimeSpeed()} %");

// Duration of one step, 10 ms minimum
robot.Rws.Controller.SetVirtualTimeSlice(50);
Console.WriteLine($"Time slice : {robot.Rws.Controller.GetVirtualTimeSlice()} ms");


// Run the virtual time one step at a time
robot.Rws.Controller.SetVirtualTimeState(VirtualTimeState.RunSlice);
robot.Rws.Controller.RunVirtualTime();

VirtualTimeState state = robot.Rws.Controller.GetVirtualTimeState();
Console.WriteLine($"State : {state}");

// Let the simulation run freely again
robot.Rws.Controller.SetVirtualTimeState(VirtualTimeState.FreeRun);
robot.Disconnect();
}