---
title: "Info: controller identity and motion groups"
description: "Read the model, serial number, software version and motion groups of a Fanuc, Yaskawa, Universal Robots, ABB or Stäubli controller with robot.Info. Brand support table, C# and Python examples."
---

# Info: controller identity and motion groups

`robot.Info` reads the identity of a robot controller: brand, model, serial number, software version and motion groups. The result types are the same for Fanuc, Yaskawa, Universal Robots, ABB and Stäubli controllers.

## Prerequisites

- A connected `RobotController`. See [Connect to your robot](/robotics/documentation/connect).
- The license of the brand of the controller, or the 30 day trial. See [Licensing](/robotics/documentation/license).
- Nothing else: the two methods only read, they never change the controller.

## Brand support

Each cell gives the protocol that the method uses on this brand, in the default order. The page [Routing](/robotics/documentation/routing) explains how the library chooses it. The table is generated from the route data of the library. (manual) marks a route that you enable yourself. "n of m" is the number of methods of the service that have a route on this brand.

Routes of each method in the default order. The first route is used, the next ones are fallbacks. (manual) marks a route that you enable yourself.

| Method | Fanuc | Yaskawa | Universal Robots | ABB | Stäubli |
| --- | --- | --- | --- | --- | --- |
| Info.Read | CGTP (Cgtp), FTP | High Speed Ethernet Server | Dashboard Server | Robot Web Services | SOAP |
| Info.ReadGroups | CGTP (Cgtp), FTP | High Speed Ethernet Server | Dashboard Server | Robot Web Services | SOAP |
| Info | **2 of 2** | **2 of 2** | **2 of 2** | **2 of 2** | **2 of 2** |

Before you call a method, `robot.Info.IsAvailable(InfoFeature.Read)` tells you if the connected controller supports it.

## Example

### Read the identity of the controller

`Read` returns a `RobotControllerInfo`. A text that the controller does not give is empty, never null.

**C# : InfoRead**
```csharp
using UnderAutomation.Robotics.Controllers;

public class InfoRead
{
    static void Main()
    {
        RobotController robot = new RobotController();
        robot.Connect(RobotConnectionParameters.Create("fanuc", "192.168.0.1"));

        /**/
        RobotControllerInfo info = robot.Info.Read();
        Console.WriteLine($"{info.BrandName} {info.Model}, serial {info.SerialNumber}, software {info.SoftwareVersion}");
        /**/

        robot.Disconnect();
    }
}
```

**Python : InfoRead**
```python
from underautomation.robotics.controllers.robot_controller import RobotController
from underautomation.robotics.controllers.robot_connection_parameters import RobotConnectionParameters

robot = RobotController()
robot.connect(RobotConnectionParameters.create("fanuc", "192.168.0.1", ""))

##
info = robot.info.read()
print(f"{info.brand_name} {info.model}, serial {info.serial_number}, software {info.software_version}")
##

robot.disconnect()
```

### Read the motion groups

A motion group is an arm, a set of external axes or a positioner, moved as one unit. `ReadGroups` returns one `MotionGroupInfo` per group. The number of a group, from 1, is the number that the motion methods take.

**C# : InfoReadGroups**
```csharp
using UnderAutomation.Robotics.Controllers;

public class InfoReadGroups
{
    static void Main()
    {
        RobotController robot = new RobotController();
        robot.Connect(RobotConnectionParameters.Create("fanuc", "192.168.0.1"));

        /**/
        foreach (MotionGroupInfo group in robot.Info.ReadGroups())
            Console.WriteLine($"Group {group.Number}: {group.Kind}, {group.AxisCount} axes ({string.Join(", ", group.AxisNames)})");
        /**/

        robot.Disconnect();
    }
}
```

**Python : InfoReadGroups**
```python
from underautomation.robotics.controllers.robot_controller import RobotController
from underautomation.robotics.controllers.robot_connection_parameters import RobotConnectionParameters

robot = RobotController()
robot.connect(RobotConnectionParameters.create("fanuc", "192.168.0.1", ""))

##
for group in robot.info.read_groups():
    print(f"Group {group.number}: {group.kind.name}, {group.axis_count} axes ({', '.join(group.axis_names)})")
##

robot.disconnect()
```

## Reference

In Python, the names are in snake_case: `robot.info.read()`, `robot.info.read_groups()`, `robot.info.is_available(...)`. The enum members keep their names.

### Methods of IInfoService

**Members of Controllers.IInfoService**
```csharp
public interface IInfoService {
    // Returns true when the method can be called on the connected controller.
    // The answer depends on the brand, on the routing settings and on the protocols that answered at the connection, not on the state of the controller.
    bool IsAvailable(InfoFeature feature)

    // Reads the identity of the controller: model, serial number, software version
    RobotControllerInfo Read()

    // Reads the motion groups of the controller
    MotionGroupInfo[] ReadGroups()
}
```

### RobotControllerInfo

**Members of Controllers.RobotControllerInfo**
```csharp
public sealed class RobotControllerInfo {
    // Creates an identity with the default value of each property
    public RobotControllerInfo()

    // Name of the brand of the controller
    public string BrandName { get; set; }

    // Motion groups of the controller, when the controller gives them with its identity. Empty otherwise: the info service of the robot reads them on demand.
    public MotionGroupInfo[] Groups { get; set; }

    // Model of the controller or of the robot, as given by the controller. Empty when the controller does not give it.
    public string Model { get; set; }

    // Object of the brand SDK this information comes from. Null when there is none.
    public object Native { get; set; }

    // Serial number, as given by the controller. Empty when the controller does not give it.
    public string SerialNumber { get; set; }

    // Version of the software of the controller. Empty when the controller does not give it.
    public string SoftwareVersion { get; set; }

    public override string ToString()
}
```

### MotionGroupInfo

**Members of Controllers.MotionGroupInfo**
```csharp
public sealed class MotionGroupInfo {
    // Creates a group whose split between robot axes and extended axes is unknown (-1)
    public MotionGroupInfo()

    // Number of axes of the group
    public int AxisCount { get; set; }

    // Name of each axis. Empty when the controller does not give them.
    public string[] AxisNames { get; set; }

    // Unit of each axis. Empty when the controller does not give them.
    public AxisUnit[] AxisUnits { get; set; }

    // Number of extended axes in the group, for example a track moved with the arm. 0 when the group has none, -1 (default) when the controller does not give it.
    public int ExtendedAxisCount { get; set; }

    // Kind of the group
    public MotionGroupKind Kind { get; set; }

    // Name of the group, as given by the controller. Empty when the controller does not give it.
    public string Name { get; set; }

    // Object of the brand SDK this information comes from. Null when there is none.
    public object Native { get; set; }

    // Number of the group, from 1
    public int Number { get; set; }

    // Number of axes of the robot arm in the group, without the extended axes. -1 (default) when the controller does not give it.
    public int RobotAxisCount { get; set; }

    public override string ToString()
}
```

**Members of Controllers.MotionGroupKind**
```csharp
public enum MotionGroupKind {
    // Robot arm
    Arm = 1

    // External axes, for example a track
    ExternalAxes = 2

    // Positioner that holds the part
    Positioner = 3

    // The controller does not give the kind
    Unknown = 0
}
```

**Members of Controllers.AxisUnit**
```csharp
public enum AxisUnit {
    // Rotary axis, values in degrees
    Degrees = 1

    // Linear axis, values in mm
    Millimeters = 2

    // The controller does not give the unit
    Unknown = 0
}
```

### Errors

The page [Errors](/robotics/documentation/errors) explains each exception and how to avoid it.

- `FeatureNotSupportedException`: the brand has no route for the method.
- `RouteUnavailableException`: the method has routes, but none of them can be used, for example because the protocol did not answer at the connection.
- `RobotControllerException`: the route failed. Its inner exception is the exception of the brand SDK.

`IsAvailable` only throws `ArgumentOutOfRangeException`, for a value that is not in the enum.

## What to read next

- [State](/robotics/documentation/state): read the operating mode and switch the servo power.
- [Routing](/robotics/documentation/routing): see which protocol answers each method.
- [Common API](/robotics/documentation/common-api): the types shared by every brand.