This page shows how to read the identity and the configuration of a Yaskawa Motoman controller with the SDK: software version, axis names, operating times and system parameters. All these methods only read: they work in any mode.

## Software version and robot model

`GetSystemInformation()` reads the system software version, the model of the first robot (R1) and the version of its parameters.

**C# : SystemInformation**
```csharp
using UnderAutomation.Yaskawa;
using UnderAutomation.Yaskawa.HighSpeedEServer;

public class SystemInformation
{
    static void Main()
    {
        var robot = new YaskawaRobot();
        robot.Connect("192.168.0.1");

        /**/
        // Software version, robot model and parameter version of the first robot (R1)
        RobotSystemInformation info = robot.HighSpeedEServer.GetSystemInformation();
        Console.WriteLine($"{info.SoftwareVersion} {info.Name} {info.Parameter}");
        /**/

        robot.Disconnect();
    }
}
```

**Python : SystemInformation**
```python
from underautomation.yaskawa.yaskawa_robot import YaskawaRobot
from underautomation.yaskawa.connect_parameters import ConnectParameters
from underautomation.yaskawa.high_speed_e_server.robot_system_type_data import RobotSystemTypeData

robot = YaskawaRobot()
robot.connect(ConnectParameters("192.168.0.1"))

##
# Software version, robot model and parameter version of the first robot (R1)
info = robot.high_speed_e_server.get_system_information(RobotSystemTypeData.Default)
print(f"{info.software_version} {info.name} {info.parameter}")
##

robot.disconnect()
```

Log these values with the data of your application: the answers of the controller can depend on its software version.

`GetSystemInformation(RobotSystemTypeData)` reads the same values for another robot, a station or an application, on the controllers that have several. In Python 2.2.0, only this form exists: pass `RobotSystemTypeData.Default` for the first robot.

## Axis names

`GetConfigurationInformation(group)` reads the names of the axes of a control group, for example `S L U R B T` for a 6 axis robot. Use it to check the number of axes before you read the joint positions.

**C# : SystemAxisConfiguration**
```csharp
using UnderAutomation.Yaskawa;
using UnderAutomation.Yaskawa.HighSpeedEServer;

public class SystemAxisConfiguration
{
    static void Main()
    {
        var robot = new YaskawaRobot();
        robot.Connect("192.168.0.1");

        /**/
        // Names of the axes of the first robot, for example S, L, U, R, B, T
        var group = new RobotControlGroup(ControlGroup.RobotPulseValue, 1);
        RobotAxisConfigData config = robot.HighSpeedEServer.GetConfigurationInformation(group);

        Console.WriteLine(string.Join(" ", config.Axes));
        /**/

        robot.Disconnect();
    }
}
```

**Python : SystemAxisConfiguration**
```python
from underautomation.yaskawa.yaskawa_robot import YaskawaRobot
from underautomation.yaskawa.connect_parameters import ConnectParameters
from underautomation.yaskawa.high_speed_e_server.robot_control_group import RobotControlGroup

robot = YaskawaRobot()
robot.connect(ConnectParameters("192.168.0.1"))

##
# Names of the axes of the first robot, for example S, L, U, R, B, T
group = RobotControlGroup.DefaultRobotPulse
config = robot.high_speed_e_server.get_configuration_information(group)

print(" ".join(config.axes))
##

robot.disconnect()
```

`RobotControlGroup` selects the robot, the base axes or the station, and its number. See [Positions](/yaskawa/documentation/hses-positions#other_control_groups).

## Operating times

`GetManagementTime(type, index)` reads an operating time of the controller: its start date and the elapsed time, as texts of the controller.

**C# : SystemManagementTime**
```csharp
using UnderAutomation.Yaskawa;
using UnderAutomation.Yaskawa.HighSpeedEServer;

public class SystemManagementTime
{
    static void Main()
    {
        var robot = new YaskawaRobot();
        robot.Connect("192.168.0.1");

        /**/
        // Time since the control power was switched on
        RobotManagementTimeData power = robot.HighSpeedEServer.GetManagementTime(ManagementTimeType.ControlPowerOnTime);
        Console.WriteLine($"Since {power.StartTime}: {power.EllapseTime}");

        // Servo power time and motion time of the first robot (index 1 is R1)
        RobotManagementTimeData servo = robot.HighSpeedEServer.GetManagementTime(ManagementTimeType.ServoPowerOnTimR1ToR8, 1);
        RobotManagementTimeData motion = robot.HighSpeedEServer.GetManagementTime(ManagementTimeType.MotionTimeR1ToR8, 1);
        Console.WriteLine($"Servo on: {servo.EllapseTime}, moving: {motion.EllapseTime}");
        /**/

        robot.Disconnect();
    }
}
```

**Python : SystemManagementTime**
```python
from underautomation.yaskawa.yaskawa_robot import YaskawaRobot
from underautomation.yaskawa.connect_parameters import ConnectParameters
from underautomation.yaskawa.high_speed_e_server.management_time_type import ManagementTimeType

robot = YaskawaRobot()
robot.connect(ConnectParameters("192.168.0.1"))

##
# Time since the control power was switched on
power = robot.high_speed_e_server.get_management_time(ManagementTimeType.ControlPowerOnTime)
print(f"Since {power.start_time}: {power.ellapse_time}")

# Servo power time and motion time of the first robot (index 1 is R1)
servo = robot.high_speed_e_server.get_management_time(ManagementTimeType.ServoPowerOnTimR1ToR8, 1)
motion = robot.high_speed_e_server.get_management_time(ManagementTimeType.MotionTimeR1ToR8, 1)
print(f"Servo on: {servo.ellapse_time}, moving: {motion.ellapse_time}")
##

robot.disconnect()
```

| `ManagementTimeType`           | Time                        | `index`                   |
| ------------------------------ | --------------------------- | ------------------------- |
| `ControlPowerOnTime`           | Control power on            | `0`                       |
| `ServoPowerOnTimR1ToR8`        | Servo power on of a robot   | `1` to `8` for R1 to R8   |
| `ServoPowerOnTimeS1ToS24`      | Servo power on of a station | `1` to `24` for S1 to S24 |
| `PlayBackTimeR1ToR8`           | Playback of a robot         | `1` to `8`                |
| `PlayBackTimeS1ToS24`          | Playback of a station       | `1` to `24`               |
| `MotionTimeR1ToR8`             | Motion of a robot           | `1` to `8`                |
| `OperationTimeApplication1To8` | Operation of an application | `1` to `8`                |

The totals (`ServoPowerOnTimeTotal`, `PlayBackTimeTotal`, `MotionTimeTotal`) take the index `0`. These times help to plan the maintenance, or to measure the use of a cell over a shift.

## System parameters

`GetSystemParameter(type, number, group)` reads one system parameter of the controller as an unsigned integer. For example, `RS029` and `RS214` must be `1` to overwrite files (see [Connect to your robot](/yaskawa/documentation/connect#allow_the_file_overwrite)).

**C# : SystemParameter**
```csharp
using UnderAutomation.Yaskawa;
using UnderAutomation.Yaskawa.HighSpeedEServer;

public class SystemParameter
{
    static void Main()
    {
        var robot = new YaskawaRobot();
        robot.Connect("192.168.0.1");

        /**/
        // Parameter RS029 of the controller (RS parameters have no group)
        RobotSystemParamData rs029 = robot.HighSpeedEServer.GetSystemParameter(SystemParameterTypes.RS, 29, group: 0);
        Console.WriteLine($"RS029 = {rs029.Value}");

        // Parameter S1CG000 of the first robot (group 1)
        RobotSystemParamData s1cg = robot.HighSpeedEServer.GetSystemParameter(SystemParameterTypes.S1CG, 0, group: 1);
        Console.WriteLine($"S1CG000 = {s1cg.Value}");
        /**/

        robot.Disconnect();
    }
}
```

**Python : SystemParameter**
```python
from underautomation.yaskawa.yaskawa_robot import YaskawaRobot
from underautomation.yaskawa.connect_parameters import ConnectParameters
from underautomation.yaskawa.high_speed_e_server.system_parameter_types import SystemParameterTypes

robot = YaskawaRobot()
robot.connect(ConnectParameters("192.168.0.1"))

##
# Parameter RS029 of the controller (RS parameters have no group)
rs029 = robot.high_speed_e_server.get_system_parameter(SystemParameterTypes.RS, 29, 0)
print(f"RS029 = {rs029.value}")

# Parameter S1CG000 of the first robot (group 1)
s1cg = robot.high_speed_e_server.get_system_parameter(SystemParameterTypes.S1CG, 0, 1)
print(f"S1CG000 = {s1cg.value}")
##

robot.disconnect()
```

| `SystemParameterTypes`    | `group`                             |
| ------------------------- | ----------------------------------- |
| `S2C`, `S3C`, `S4C`, `RS` | `0`: these parameters have no group |
| `S1CG`, `AP`, `SE`        | The number of the group, from `1`   |

The meaning of each parameter is in the parameter manual of your controller. The SDK reads the parameters, it does not write them.

## Try it in the demo application

Everything on this page can be tried without writing code, in the **System Parameters** page of the [demo application](/yaskawa/documentation/demo-app).

![System Parameters page of the Yaskawa SDK demo application](/yaskawa/WinformsScreenshots/Parameters.jpg)

Its C# source is [ParametersControl.cs](https://github.com/underautomation/Yaskawa.NET/blob/main/UnderAutomation.Yaskawa.Showcase.Forms/Components/ParametersControl.cs).

## Reference

**Methods of HighSpeedEServerClientBase**
```csharp
// Reads axis configuration information for the default robot control group. Returns axis type names for each of the 8 possible axes.
RobotAxisConfigData GetConfigurationInformation();

// Reads axis configuration information for a specified control group. Returns axis type names (e.g., "S", "L", "U", "R", "B", "T") for each axis.
RobotAxisConfigData GetConfigurationInformation(RobotControlGroup type);

// Retrieves management time statistics from the robot controller. Can query various timing metrics like control power ON time, servo ON time, etc.
RobotManagementTimeData GetManagementTime(ManagementTimeType type, int index = 0);

// Retrieves system information about the default robot system (R1). Returns software version, robot name, and parameter file information.
RobotSystemInformation GetSystemInformation();

// Retrieves system information for a specific robot system or control group. Use for multi-robot controllers or to query specific axes groups.
RobotSystemInformation GetSystemInformation(RobotSystemTypeData type);

// Reads a system parameter from the robot controller.
RobotSystemParamData GetSystemParameter(SystemParameterTypes type, int number, int group = 1);
```

Every method also exists in an asynchronous version, with the same name followed by `Async` and an optional `CancellationToken`.

**Members of HighSpeedEServer.RobotSystemInformation**
```csharp
public class RobotSystemInformation : RobotData {
    // Gets the system/robot name or model identifier.
    // Maximum 16 characters.
    public string Name { get; }

    // Gets parameter file or configuration information.
    // Maximum 8 characters.
    public string Parameter { get; }

    // Gets the controller software version string.
    // Format typically includes model and version number. Maximum 24 characters.
    public string SoftwareVersion { get; }

    // Returns a string representation of the system information.
    public override string ToString()
}
```

**Members of HighSpeedEServer.RobotAxisConfigData**
```csharp
public class RobotAxisConfigData : RobotAxisRawData<string> {

}
```

**Members of HighSpeedEServer.RobotManagementTimeData**
```csharp
public class RobotManagementTimeData : RobotData {
    // Gets the elapsed time for the tracked metric.
    // Format: "HHHH:MM:SS.ss" or similar time duration format (12 characters).
    public string EllapseTime { get; }

    // Gets the start time of the tracked period.
    // Format: "YYYY/MM/DD HH:MM" (16 characters).
    public string StartTime { get; }
}
```

**Members of HighSpeedEServer.ManagementTimeType**
```csharp
public enum ManagementTimeType {
    // Total time the controller power has been on.
    ControlPowerOnTime = 1

    // Motion time for robots R1 through R8.
    // Add robot number (0-7) to get specific robot.
    MotionTimeR1ToR8 = 210

    // Motion time for stations S1 through S24.
    // Add station number (0-23) to get specific station.
    MotionTimeS1ToS24 = 221

    // Total motion time across all robots.
    MotionTimeTotal = 210

    // Operation time for applications 1 through 8.
    // Add application number (0-7) to get specific application.
    OperationTimeApplication1To8 = 300

    // Playback time for robots R1 through R8.
    // Add robot number (0-7) to get specific robot.
    PlayBackTimeR1ToR8 = 110

    // Playback time for stations S1 through S24.
    // Add station number (0-23) to get specific station.
    PlayBackTimeS1ToS24 = 120

    // Total playback time across all robots.
    PlayBackTimeTotal = 110

    // Servo power on time for robots R1 through R8.
    // Add robot number (0-7) to get specific robot.
    ServoPowerOnTimR1ToR8 = 10

    // Servo power on time for stations S1 through S24.
    // Add station number (0-23) to get specific station.
    ServoPowerOnTimeS1ToS24 = 20

    // Total servo power on time across all robots.
    ServoPowerOnTimeTotal = 10
}
```

**Members of HighSpeedEServer.RobotSystemParamData**
```csharp
public class RobotSystemParamData : RobotData {
    // Returns a string representation of the system parameter value.
    public override string ToString()

    // Gets the raw system parameter value returned by the controller.
    public uint Value { get; }
}
```

**Members of HighSpeedEServer.SystemParameterTypes**
```csharp
public enum SystemParameterTypes {
    // AxP. Requires a group number.
    AP = 5

    // RS
    RS = 4

    // S1CxG. requires group number.
    S1CG = 0

    // S2C
    S2C = 1

    // S3C
    S3C = 2

    // S4C
    S4C = 3

    // SxE. Requires a group number.
    SE = 6
}
```