roslibpy

What is roslibpy?

roslibpy is a Python ROS Bridge library that allows Python (CPython) and IronPython to interact with ROS via WebSockets. It connects to rosbridge 2.0 and provides essential ROS functionality without requiring a local ROS installation, making it suitable for non-Linux platforms.

Key Capabilities

• Topics: Publishing and subscribing to ROS topics.
• Services: Service calls (client) and service advertisement (server).
• Parameters: ROS parameter management (get, set, and delete).
• Meta-information: Accessing ROS API services for system metadata.
• Actionlib: Interfacing with preemptable tasks via actionlib.
• TF: TF Client support via the tf2_web_republisher.

Compatibility

• ROS 1: Fully supported.
• ROS 2: Support is currently in progress.
• Runtimes: Supports Python 3.x and IronPython 2.7.

roslibpy is a Python (and IronPython) library designed to interact with ROS (Robot Operating System) via WebSockets. It connects to rosbridge 2.0 to provide essential ROS functionalities including:

• Publishing topics
• Subscribing to topics
• Service calls
• actionlib
• TF (Transform Library)

Key Advantage: Unlike rospy, roslibpy does not require a local ROS installation, making it possible to interact with a robot from platforms other than Linux (e.g., Windows or macOS).

Compatibility:

• ROS 1: Fully supported.
• ROS 2: Support is currently in progress.
• API Design: The API is modeled to closely match roslibjs.

The roslibpy.Ros class provides two ways to manage the event loop:

1. run(): Starts the event processing in a separate background thread. This is useful for non-blocking integration into existing applications.
2. run_forever(): Blocks the calling thread to run the event loop in the foreground. This is useful when you want to manage the main loop explicitly. When using run_forever(), you must set up all connection handlers (like on_ready) before calling it.

Use on_ready to register a callback that executes once the connection is established.

import roslibpy

ros = roslibpy.Ros(host='localhost', port=9090)

def on_ready_callback():
    print("Connected!")

ros.on_ready(on_ready_callback)
ros.run_forever()

Actions are designed for long-running tasks (like navigation) because they are non-blocking and support cancellation (preemption). roslibpy supports both consuming actions and providing them.

• Action Server: Uses roslibpy.actionlib.SimpleActionServer to provide an action service.
• Action Client: Consumes an action. You can use roslibpy.actionlib.Goal.wait for simple synchronous-style waiting, or hook into the result event with a callback for robust asynchronous handling.
• ROS 2 Support: roslibpy also provides clients specifically for dealing with ROS 2 action servers.

ROS Topics allow nodes to communicate via a publish/subscribe model.

• Talker: A node that publishes messages to a specific topic in a loop.
• Listener: A node that subscribes to a topic and reacts to incoming messages.

These can run in separate processes or even on different computers, provided they connect to the same ROS instance.

If you are using IronPython, use the following command to install the library for your user:

ipy -X:Frames -m pip install --user roslibpy

To connect to a ROS environment, import roslibpy and initialize a Ros instance with the host and port of your rosbridge instance. By default, host is 'localhost'. Use .run() to start the connection in a background thread.

Note: If ROS is running on a different machine, replace 'localhost' with the IP address of the ROS instance.

import roslibpy

ros = roslibpy.Ros(host='localhost', port=9090)
ros.run()

print(ros.is_connected)  # Should return True

To install roslibpy for CPython, use the standard pip command. Note that you must have a working ROS setup with a rosbridge server and TF2 web republisher accessible on your network for the library to function.

For IronPython users, the installation command requires specific flags to ensure correct environment handling.

pip install roslibpy

Services provide a request/response communication pattern.

Calling an existing service

To call a service, you must know the service name and the request type definition. For example, calling get_loggers:

# Example logic for calling a service
service = roslibpy.Service(ros, '/rosout/get_loggers', 'roscpp/GetLoggers')
# ... call service with request ...

Creating a new service

You can create new services if the service type definition is present in your ROS environment (e.g., std_srvs/SetBool).

By default, CPython uses the twisted transport and IronPython uses cli. You can switch to the asyncio transport, which runs the Autobahn WebSocket stack on an asyncio event loop without requiring extra dependencies.

You can select the transport in three ways:

1. Per client instance: Pass the transport argument to the Ros constructor.
2. Process-wide default: Use roslibpy.set_default_transport().
3. Environment variable: Set ROSLIBPY_TRANSPORT before running your script.

# Per client
roslibpy.Ros(host='localhost', port=9090, transport='asyncio')

# Process-wide default
roslibpy.set_default_transport('asyncio')

To set the transport for an entire execution, set the ROSLIBPY_TRANSPORT environment variable in your shell:

ROSLIBPY_TRANSPORT=asyncio python my_script.py