Software and Hardware components
Hardware
Raph Rover integrates several key hardware components that work together to provide a robust mobile robotics platform:
These components are integrated into a compact chassis designed for durability and ease of maintenance. The modular architecture allows for customization while maintaining core functionality.
Software
Overview
Raph Rover's software heavily relies on The Robot Operating System (ROS) which offers many functionalities that are used on the robot, such as:
- Abstraction layer facilitating communication between software components.
- Open-source software components, maintained by the community.
- A collection of standard message interfaces.
- Tools for introspection and debugging.
The primary segment of the software stack is partitioned into several ROS Nodes, treated as computational units, each performing one logical task. The nodes interact via:
- Topics - Named buses enabling message exchange between nodes. They are strongly typed and employ anonymous publish/subscribe semantics.
- Services - A client/server mechanism for remote procedure calls between nodes. The service server accepts remote procedure requests identified by name and type, which must be known to the service client beforehand.
- Parameters - Sets of key/value pairs maintained separately by each node, utilized for node configuration during startup and runtime without necessitating code modifications.
- TF transforms - A single transform describes the relationship between 2 coordinate frames at a specific point in time. TF transforms are distributed between nodes using topics, but, for the sake of clarity, we will refer to them as separate entities.
There are two important software components which don't run as native ROS nodes:
- Controller firmware - The firmware itself acts as a ROS node but uses eProsima's Micro XRCE-DDS as its middleware. Thus, it requires the presence of the Micro-ROS Agent on the built-in computer to communicate with other ROS nodes.
- Web User Interface - The WebUI establishes a connection with the Rosbridge Server via WebSocket transport layer and employs the rosbridge protocol for communication with the ROS nodes.
ROS nodes
| ROS Node | Description |
|---|---|
| Controller Node | The node created by the Controller firmware. Provides access to functionalities via topics and services for the management of the drivetrain, LED panels, Power System and many more. Additionally, it publishes relevant information, including:
|
| Robot State Publisher | Parses the kinematic tree model of the robot in URDF format and broadcasts the robot state using TF transforms. Here's how it operates:
|
| Camera Driver | Publishes the data provided by the stereoscopic camera. In the default configuration used in Raph Rover, it includes:
|
| Depth Processing Node | Publishes point cloud data computed from depth images and camera calibration parameters. Employs “lazy subscription”, meaning it doesn't process any depth images until at least one node subscribes to the Point Cloud topic. |
| LIDAR Driver | Publishes data from the LIDAR sensor. Additionally, it provides services for starting and stopping the sensor's motor. |
| Raph System Node | Enables rebooting and shutting down the onboard computer via ROS services. |
| LIDAR Filter Node | Filters out LIDAR measurements from the robot's footprint. |
| ROS API Node | Exposes ROS API services so the Web UI can inspect the ROS graph, query/set parameters and call services. |
| Rosbridge Server | Provides a WebSocket interface for communication with the Web User Interface using the rosbridge protocol. |
| Web Video Server | Streams camera images to the Web User Interface. |
Custom ROS nodes can be created to extend the robot's capabilities even further. Raph Rover's software stack provides a robust framework for developing and integrating custom software and other sensors.
You can learn how to create custom ROS nodes for Raph Rover in the ROS Development Tutorial.
Firmware
Rover's low-level hardware functions are managed by the RaphCore microcontroller, which runs an RTOS app (firmware) based on FreeRTOS. Communication between the firmware and the onboard computer is facilitated by Micro-ROS.
The firmware is responsible for:
- Controlling the wheel motors and servos.
- Managing the power system, including battery monitoring and charging.
- Operating the LED panels.
- Publishing data from the IMU sensor.
- Publishing odometry calculated from wheel encoders and IMU.
The firmware also uses a custom bootloader which is responsible for loading and updating the firmware itself. To learn how to flash or update the firmware, follow the guide below:
LED controller
The built-in LED controller manages the LED states of the robot by processing user-defined states and animations, integrating them with ongoing animations, and updating the LEDs accordingly.
Users can control the LED strip by specifying colors, duration, and priority of specific LEDs via ROS topics.
The robot features four LED panels that combine to form one long LED strip. LEDs can be controlled either as a full strip or as specific panels, providing flexibility for different use cases:
- Full Strip Control: Ideal for animations that span the entire perimeter of the robot, such as police lights. Can be set using controller/led_strip_state ROS topic.
- Panel-Specific Control: Useful for targeted functions, such as using all front LEDs as a floodlight or using side LEDs to indicate battery levels. Can be set using controller/led_panel_state ROS topic.
LED priorities range from 1 to 127. Higher priority animations override lower priority ones. Sending an LED state with priority -1 will reset the LED (turn it off). Messages with priority 0 are ignored.
Web User Interface
Web User Interface can be used to control Raph Rover, view camera streams and monitor robot status. It utilizes the rosbridge protocol to communicate with ROS nodes on the robot via WebSocket.
To find out how to connect to and use the Web UI, visit the documentation page below: