Fejemis ROS2 Software

Back to Fejemis_2026

Fejemis Software Overview

The Fejemis software is split into multiple components. The full ROS2 workspace and related repositories are available on GitHub: https://github.com/Melvin-Angel/Fejemis_Workspace_2026.git

Introduction

This documentation summarises the main software components used on the robot and explains how the system can be distributed across multiple Raspberry Pis (Multi‑Pi setup).

The two primary concerns are:

• Hardware bridge and low-level microcontroller integration (the Fejemis bridge).
• The ROS 2 software stack for mapping, perception, and high-level behaviours (the Fejemis ROS2 workspace).

Fejemis

The top-level `fejemis` package is the entry point for the robot stack. It ties the bridge, description, map/localisation, simulation, and vision packages together and installs the main launch files for the complete system.

Launch files:

• `launch/robot.launch.py` - main bringup file for the real robot and multi-Pi setup. It starts the bridge control first and then launches odometry, LiDAR, SLAM, localisation, and vision depending on the selected options.
• `launch/sim.launch.py` - convenience entry point for simulation. It starts `launch/robot.launch.py` with `in_sim=True`.

Configurable parameters in `launch/robot.launch.py`:

• `is_aux` - marks whether the launch is running on the auxiliary Raspberry Pi. The default is detected automatically.
• `in_sim` - enables simulation mode.
• `localization` - runs RTAB-Map in localisation mode when `true`.
• `map_location` - selects the map database to load (`lab` or `asta`).
• `enable_vision` - enables the vision stack for people, cable, and net detection.

Fejemis Bridge

The `fejemis_bridge` package handles the low-level interface between the main Raspberry Pi and the Teensy controllers. It contains the serial bridge, the command mixer, and the joystick helper nodes used for manual control.

Launch files:

• `launch/bridge.launch.py` - starts the bridge node itself.
• `launch/mixer.launch.py` - starts the command mixer and joystick input nodes.
• `launch/control.launch.py` - launches the full control side of the bridge stack and forwards the serial-device arguments.

Nodes in this package:

• `bridge` - main bridge executable, published in the `fejemis` namespace.
• `raubase_core/rcmixer` - command mixer that combines control inputs.
• `joy/game_controller_node` - joystick/gamepad input node.
• `raubase_core/joy_control` - joystick mode switch node.
• `joy_brush_toggle.py` - button toggle for the brush control.
• `joy_linear_actuator.py` - button toggle for the linear actuator.

Configurable parameters:

• `front_device` - serial device for the front Teensy controller.
• `drive_device` - serial device for the drive Teensy controller.
• `log_level` - logging level for the bridge node.
• `in_sim` and `is_aux` - forwarded through the control launch file to select the correct runtime path.
• Joystick helper settings such as `joy_topic`, `steer_manage_topic`, `linear_actuator_topic`, `button_index`, `initial_brush_on`, and `initial_actuator_up`.

Fejemis Description

The `fejemis_description` package provides the robot model and URDF/Xacro setup. It is responsible for publishing the robot description and state so the rest of the stack can use the same model.

Launch files:

• `launch/model.launch.py` - generates the URDF from the Xacro description and launches `robot_state_publisher`.

Nodes in this package:

• `robot_state_publisher` - publishes the robot TF tree from the generated `robot_description`.

Configurable parameters:

• `use_sim_time` - enables simulated time when running in Gazebo or another simulator.

Fejemis Sim

The `fejemis_sim` package contains the Gazebo simulation resources and the simulation bringup. It combines the robot description with the simulation world and connects ROS topics to Gazebo.

Launch files:

• `launch/sim.launch.py` - starts the full simulation stack.

Nodes in this package:

• `ros_gz_sim/create` - spawns the robot in Gazebo from `/robot_description`.
• `ros_gz_bridge/parameter_bridge` - bridges ROS and Gazebo topics.
• `raubase_core/rover_2_twist` - optional adapter that converts rover commands into Twist commands for Gazebo.

Configurable parameters:

• `world` - world file to load, defaulting to `fejemis_sim::worlds/room.world`.
• `rover_cmd_adapter` - enables or disables the RoverCommand-to-Twist adapter.
• `rviz` - optional RViz flag provided by the launch file.

Multi pi setup

This system supports a multi‑Pi arrangement where some hardware (for example, a RealSense camera or other sensors) runs on an auxiliary Raspberry Pi while the main robot and ROS 2 stack run on the primary Pi.

Recommended minimal steps for a Multi‑Pi setup:

1. Network and host setup

• Ensure all Pis are on the same local network (switch, VLAN or Wi‑Fi SSID) and can reach each other via IP.
• Prefer DHCP reservations or static IPs for each Pi to simplify configuration.

2. SSH and automation

• Install SSH keys on each Pi so you can run remote commands and automation without passwords.

3. Clone the workspace and install dependencies On each Pi that needs software from the repository, clone the workspace and run the provided install scripts:

```bash git clone https://github.com/Melvin-Angel/Fejemis_Workspace_2026.git cd Fejemis_Workspace_2026 ./install.sh source ./activate.sh ```

4. Camera / sensor hosts

• If the camera is on an auxiliary Pi, run the camera driver or streaming node there and expose the expected ROS topics across the network.
• In this workspace the mapping components expect RealSense RGB‑D topics; when the camera is on an aux Pi you can launch the camera remotely. Example (run on the primary Pi to start the aux launch):

```bash fejemis launch_aux fejemis_maploc realsense.launch.py ```

5. Time sync and reliability

• Enable NTP or systemd‑timesyncd on all Pis so timestamps on messages line up for logging and perception.

Convenience commands

These helper commands make working with a two‑Pi setup easier.

• `fejemis launch_aux` — start a launch file on an auxiliary Pi from the primary Pi. This is commonly used to start camera or sensor nodes remotely. Example:

```bash fejemis launch_aux fejemis robot.launch.py ```

• `fejemis sync_clocks` — synchronise system clocks across Pis (uses SSH and sudo on targets). Run this before recording or starting perception stacks so timestamps align. Example:

```bash fejemis sync_clocks ```