roslibjs

The Ros class is the central entry point for interacting with a ROS master via a rosbridge server. You can initialize it by providing a url in the constructor to attempt an immediate connection, or call .connect(url) manually.

By default, it uses a WebSocketTransportFactory. You can provide a custom transportFactory in the constructor if you need a different transport mechanism.

Common events emitted by the Ros instance:

• connection: Emitted when successfully connected to the rosbridge server.
• close: Emitted when disconnected.
• error: Emitted when a transport or ROS error occurs.
• <topicName>: Emitted when a message is received on a specific topic (e.g., ros.emit('chatter', message)).
• <serviceID>: Emitted when a service response is received with a specific ID.

import Ros from 'roslib';

const ros = new Ros({
  url: 'ws://localhost:9090'
});

ros.on('connection', () => {
  console.log('Connected to rosbridge!');
});

ros.on('error', (error) => {
  console.error('ROS Error:', error);
});

The ITransport interface defines the abstraction for sending and receiving messages between the client and the rosbridge server. It is inspired by the WebSocket API and provides methods for managing the connection lifecycle and message transmission.

Key capabilities include:

• Event Listening: Listen for open, close, error, and message events.
• Message Transmission: Send RosbridgeMessage objects via .send().
• Connection State: Query the current state using .isConnecting(), .isOpen(), .isClosing(), and .isClosed().
• Lifecycle Management: Explicitly terminate the connection using .close().

// Example of how an ITransport implementation might be used
const transport: ITransport = getTransportInstance();

transport.on('open', () => console.log('Connected!'));
transport.on('message', (message) => console.log('Received:', message));
transport.on('error', (err) => console.error('Transport error:', err));

transport.send({ type: 'op', topic: '/chatter', msg: { data: 'hello' } });

You can turn an Action instance into an action server by calling advertise(). This allows the client to receive goal requests and manage their lifecycle.

• actionCallback: Triggered when a new goal is received. It receives the goal data and a unique id for that goal.
• cancelCallback: Triggered when the specific goal associated with the provided id is canceled.

Use the provided helper methods (sendFeedback, setSucceeded, setCanceled, setFailed) within your callbacks to communicate the status of the goal back to the client using the goal's id.

const action = new Action({
  ros: ros,
  name: '/fibonacci',
  actionType: 'example_interfaces/Fibonacci'
});

action.advertise(
  (goal, id) => {
    console.log(`Received goal ${id}:`, goal);
    
    // Simulate work and send feedback
    action.sendFeedback(id, { current_value: 1 });
    
    // Complete the action
    action.setSucceeded(id, { result: 1 });
  },
  (id) => {
    console.log(`Goal ${id} was canceled`);
  }
);

// To stop advertising the action:
// action.unadvertise();