`robot.Rws.System` describes the system installed on the controller: its name and software version, the options and the products it was built with, the type of robot it drives, its license, and the energy it consumes. Everything here is read only, except the reset of the energy counter.

Do not confuse this service with [Controller](/abb/documentation/rws-controller), which reports the identity of the controller hardware. `System` reports the software running on it.

## System information

`GetInfo` returns a `SystemInfo` with the name of the system, the robot software version and the installed options.

**C# : SystemGetInfo**
```csharp
using UnderAutomation.ABB;
using UnderAutomation.ABB.Rws.Data;

public class SystemGetInfo
{
    static void Main()
    {
        AbbController robot = new AbbController();
        robot.Connect("192.168.0.1");

        /**/
        SystemInfo info = robot.Rws.System.GetInfo();

        Console.WriteLine(info.Name);          // name of the system
        Console.WriteLine(info.VersionName);   // readable robot software version
        Console.WriteLine(info.Version);
        Console.WriteLine(info.SystemId);      // unique identifier of the system
        Console.WriteLine(info.StartTime);     // last start, null on some controllers
        Console.WriteLine(info.OptionCount);

        // The options come with the description, no second call needed
        foreach (string option in info.Options)
            Console.WriteLine(option);
        /**/

        robot.Disconnect();
    }
}
```

A virtual controller does not fill every field. The detailed version numbers, the build tag and the timestamps are usually empty on a simulated system, which is why they are nullable. The name, the version and the system identifier are always there.

The options are returned with the description, so `GetOptions` is not needed when you call `GetInfo`.

## Options, products, robot types and license

| Method              | Returns                                                                |
| ------------------- | ---------------------------------------------------------------------- |
| `GetOptions()`      | `string[]`, the names of the installed options                         |
| `GetProducts(name)` | `SystemProduct[]`, the installed software products with their versions |
| `GetRobotTypes()`   | `string[]`, for example `IRB 120-3/0.6`                                |
| `GetLicense()`      | `string`, the license the robot software runs under                    |

**C# : SystemOptions**
```csharp
using UnderAutomation.ABB;
using UnderAutomation.ABB.Rws.Data;

public class SystemOptions
{
    static void Main()
    {
        AbbController robot = new AbbController();
        robot.Connect("192.168.0.1");

        /**/
        // Installed options
        foreach (string option in robot.Rws.System.GetOptions())
            Console.WriteLine(option);

        // Installed products and their versions
        foreach (SystemProduct product in robot.Rws.System.GetProducts())
            Console.WriteLine($"{product.Name} {product.VersionName}");

        // One product only. The name must match exactly
        SystemProduct[] robotWare = robot.Rws.System.GetProducts("RobotWare");

        // Type of every robot the controller drives
        foreach (string type in robot.Rws.System.GetRobotTypes())
            Console.WriteLine(type);

        // License the robot software runs under
        Console.WriteLine(robot.Rws.System.GetLicense());
        /**/

        Console.WriteLine(robotWare.Length);
        robot.Disconnect();
    }
}
```

`GetProducts` takes an optional name to report a single product. The name has to match an installed product exactly, the controller rejects an unknown one with an error instead of returning an empty list. Call it without argument to get every product.

`GetRobotTypes` only reports standard ABB robots. Positioners, track motions and other mechanical units are left out. A controller that drives none of them returns an empty array, not an error. Use `robot.Rws.MotionSystem.GetMechanicalUnits()` when you need the complete list.

`GetLicense` returns `VIRTUAL_USE` on a RobotStudio virtual controller.

## Energy consumption

`GetEnergy` returns the energy the controller consumed, for the current measurement interval and since the last reset, broken down per mechanical unit and per axis. Values are in joules.

**C# : SystemEnergyRead**
```csharp
using UnderAutomation.ABB;
using UnderAutomation.ABB.Rws.Data;

public class SystemEnergyRead
{
    static void Main()
    {
        AbbController robot = new AbbController();
        robot.Connect("192.168.0.1");

        /**/
        SystemEnergy energy = robot.Rws.System.GetEnergy();

        // Always check this first, the other values mean nothing when it is false
        if (!energy.IsMeasurementValid)
        {
            Console.WriteLine($"No measurement available, state is {energy.State}");
            return;
        }

        Console.WriteLine($"Interval : {energy.IntervalEnergy} J over {energy.IntervalLength} s");
        Console.WriteLine($"Average power : {energy.AveragePower} W");
        Console.WriteLine($"Accumulated : {energy.AccumulatedEnergy} J since {energy.ResetTime}");

        // Breakdown per mechanical unit and per axis
        foreach (SystemEnergyMechanicalUnit unit in energy.MechanicalUnits)
        {
            Console.WriteLine(unit.Name);

            foreach (SystemEnergyAxis axis in unit.Axes)
                Console.WriteLine($"  axis {axis.Number} : {axis.IntervalEnergy} J");
        }
        /**/

        robot.Disconnect();
    }
}
```

Check `IsMeasurementValid` first. The controller answers with a complete but meaningless measurement while it has nothing to report, and `State` then tells why. `AveragePower` is computed by the SDK from the interval energy and the interval length, in watts, and is null when one of the two is missing.

| `SystemEnergyState`             | Meaning                                                          |
| ------------------------------- | ---------------------------------------------------------------- |
| `NotPaused`                     | Measurement is running                                           |
| `Paused`, `Pausing`, `Resuming` | Measurement is stopped or changing state                         |
| `Blocked`                       | Measurement is blocked, no new value is produced                 |
| `GoingToSleep`, `Sleep`         | The controller is entering or in its low energy consumption mode |
| `Unknown`                       | The state could not be determined                                |

## Polling the energy

Reading the whole measurement is not cheap. `GetEnergyChangeCount` returns a single number the controller increments each time a new measurement is available. Poll that number, and read the measurement only when it moved.

**C# : SystemEnergyPolling**
```csharp
using UnderAutomation.ABB;
using UnderAutomation.ABB.Rws.Data;

public class SystemEnergyPolling
{
    static void Main()
    {
        AbbController robot = new AbbController();
        robot.Connect("192.168.0.1");

        /**/
        int? lastCount = robot.Rws.System.GetEnergyChangeCount();

        while (true)
        {
            Thread.Sleep(1000);

            // One small request. Read the whole measurement only when the counter moved
            int? count = robot.Rws.System.GetEnergyChangeCount();

            if (count == lastCount) continue;

            lastCount = count;

            SystemEnergy energy = robot.Rws.System.GetEnergy();
            Console.WriteLine($"{energy.TimeStamp} : {energy.AccumulatedEnergy} J");
        }
        /**/
    }
}
```

The same counter is also in `SystemEnergy.ChangeCount`. Both return null when the controller does not report it.

## Reset the accumulated energy

`ResetAccumulatedEnergy` sets the accumulated counter back to zero. The energy counted before is lost, the controller keeps no history. The reset moment becomes the new reference reported by `ResetTime`. The energy of the current interval is not affected.

**C# : SystemEnergyReset**
```csharp
using UnderAutomation.ABB;
using UnderAutomation.ABB.Rws.Data;

public class SystemEnergyReset
{
    static void Main()
    {
        AbbController robot = new AbbController();
        robot.Connect("192.168.0.1");

        /**/
        // The accumulated counter goes back to zero, the energy counted before is lost
        robot.Rws.System.ResetAccumulatedEnergy();

        SystemEnergy energy = robot.Rws.System.GetEnergy();

        // ResetTime is now the reference of the accumulated energy
        Console.WriteLine($"{energy.AccumulatedEnergy} J since {energy.ResetTime}");
        /**/

        robot.Disconnect();
    }
}
```

## API reference