Get started with Python

This page shows how to install the ABB SDK for Python and write a first program for an IRC5 or OmniCore controller. The Python package has the same features as the .NET library, with Python names.

How it works

The package UnderAutomation.ABB contains the .NET library UnderAutomation.ABB.dll and a Python layer that calls it through pythonnet. pythonnet runs .NET code in the Python process. Nothing is installed on the controller.

• Windows: the DLL runs on the .NET Framework 4.x of Windows. Nothing else to install.
• Linux and macOS: install the .NET runtime (for example .NET 8), then select it for pythonnet before you start Python. Without this, pythonnet uses Mono, its default runtime on Linux and macOS.

sudo apt-get install -y dotnet-runtime-8.0
export PYTHONNET_RUNTIME=coreclr

Always write the export: a variable set without it does not reach the Python process. The same choice can be made in code, before the first import of the package:

# Linux and macOS: use the .NET runtime instead of Mono.
# Same effect as "export PYTHONNET_RUNTIME=coreclr", before the first import of the SDK.
from pythonnet import load

load("coreclr")

from underautomation.abb.abb_controller import AbbController

Install from PyPI

Install the package in a virtual environment:

python -m venv .venv

# Windows
.venv\Scripts\activate

# Linux and macOS
source .venv/bin/activate

pip install UnderAutomation.ABB

Package page: pypi.org/project/UnderAutomation.ABB

Install from the sources

git clone https://github.com/underautomation/ABB.py.git
cd ABB.py
pip install -e .

The repository also holds runnable examples, one folder per feature: examples/controller, examples/io, examples/rapid, examples/motion, and others.

First program

Import AbbController, connect and call a service.

from underautomation.abb.abb_controller import AbbController
# Without a key, the SDK runs in its 30 day trial period.
# With a license, register it once, before the first connection.
AbbController.register_license("YourCompanyName", "YOUR_LICENSE_KEY")

# The whole SDK is reachable from a single object
robot = AbbController()
robot.connect("192.168.0.1")

# Controller identity
identity = robot.rws.controller.get_identity()
print(f"Connected to {identity.name}")

# RAPID tasks
for task in robot.rws.rapid.get_tasks():
    print(f"{task.name} : {task.execution_state}")

robot.disconnect()

The SDK runs for 30 days without a key. After that, register_license is needed: see Licensing.

The default parameters target an OmniCore controller. For an IRC5 with RobotWare 6, set the RWS version. See Connect to your robot for the connection parameters. When the controller answers on HTTPS with a certificate it signed itself, the SDK accepts it and enables TLS 1.2: nothing has to be set in Python.

How the names are written

The Python package follows the .NET API, with Python names:

Methods and properties become snake*case. Enumeration values keep the name they have in .NET. A value whose name is a Python keyword gets a trailing underscore: RapidRegainMode.Continue*, RapidStartCondition.None*, RapidTextQueryMode.Try*.

Each type is in its own module, named after it:

# One module per type, named after the type in snake case
from underautomation.abb.abb_controller import AbbController
from underautomation.abb.connection_parameters import ConnectionParameters
from underautomation.abb.rws.rws_version import RwsVersion
from underautomation.abb.rws.data.controller_state import ControllerState
from underautomation.abb.common.pose import Pose

Errors

Every failure reported by the controller raises an RwsException. It comes from the .NET runtime: import it from its .NET namespace, after the import of the package. Its members keep their .NET names: StatusCode, RwsErrorCode, RwsErrorMessage, ResponseBody.

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
try
{
    robot.Rws.Io.SetSignalValue("Local", "PANEL", "DO_Gripper", 1);
}
catch (RwsException ex)
{
    // StatusCode is the HTTP status code the controller answered
    if (ex.StatusCode == 403)
        Console.WriteLine("Mastership is held elsewhere, or the user account lacks the grant");
    else if (ex.StatusCode == 404)
        Console.WriteLine("This signal does not exist on this controller");
    else
        Console.WriteLine($"RWS error {ex.StatusCode} : {ex.RwsErrorMessage}");
}
robot.Disconnect();
}

Differences with the .NET API

• The asynchronous methods are not wrapped. Every service method is available in its synchronous form.
• The file service reads and writes bytes, not text or streams. Decode and encode in your own code: bytes(robot.rws.file.get_file_as_bytes(path)).decode("utf-8").
• Python has no method overloading, so a .NET method that exists in several forms is wrapped once. The mastership is an example: it is always taken with the domain it applies to, robot.rws.mastership.request(MastershipDomain.Rapid). To hold every domain, as the parameterless .NET call does, take them one by one:

robot = AbbController()
robot.connect("192.168.0.1")
# The parameterless .NET Request() is not wrapped: take the domains one by one
domains = robot.rws.mastership.get_domains()
for domain in domains:
    robot.rws.mastership.request(domain)

try:
    pass  # changes that need every domain
finally:
    for domain in domains:
        robot.rws.mastership.release(domain)
robot.disconnect()

What to read next

• Connect to your robot: connection parameters, IRC5 and OmniCore, errors.
• Test with a RobotStudio virtual controller: work without a real robot.
• Robot Web Services overview: the services of the SDK, one page per topic. Every code sample has a Python tab.
• Licensing: the 30 day trial and the license key.