Skip to main content

ROSbot 3 (and previous 2x versions )

Overview​

ROSbot is a ROS powered 4x4 drive autonomous mobile robot platform equipped with LIDAR, RGB-D camera, IMU, encoders, distance sensors.

Available in the following versions: 3 / 3 PRO (current version), 2R / 2 PRO (discontinued) and 2 (deprecated).

ROSbot 3 is an affordable robot platform for rapid development of autonomous robots. It can be a base for custom service robots, inspection robots and robots working in swarms. All versions integrate:

  • 4-wheels mobile platform containing DC motors with encoders and an aluminum frame
  • IMU: BNO055 (accelerometer + gyro)
  • rear panel providing interfaces for additional modules

ROSbot versions​

ROSbot is available in three options which, next to features mentioned before, also include:

  • Raspberry Pi 5 (ARM64 architecture) quad-core ARM-8 Cortex A76 @ 2.4GHz, 8GB RAM and 64 GB MicroSD flash memory.
  • 3D camera: Luxonis OAK-D Lite / Pro
  • LIDAR: RPLIDAR C1 / S2
1 / 1

Quick Access
🛍️ Buy now

Gazebo Simulation Model​

You can also test the performance of ROSbot using our simulation model in Gazebo environment. It is available here, at our GitHub page.

ROSbot gazebo

You can find free ROS tutorials dedicated for ROSbot under this link. They will guide you through different aspects of programming autonomous vehicles in ROS

Hardware guide​

Specification​

ROSbot 3 dimensionsROSbot 3 dimensions
AttributeDescription
Dimensions with camera and LiDAR200 x 233 x 197 mm / 7.9 x 9.2 x 7.7 in [L x W x H]
Dimensions without camera200 x 233 x 141 mm / 7.9 x 9.2 x 5.6 in [L x W x H]
Dimensions without camera and LiDAR200 x 233 x 103 mm / 7.9 x 9.2 x 4.0 in [L x W x H]
Weight2,84 kg / 100 oz (with camera and LiDAR), 2,45 kg / 86 oz (without camera and LiDAR)
Standard wheel diameter / Clearance / Wheelbase84 mm / 23 mm / 106 mm
Mecanum wheel diameter / Clearance / Wheelbase97 mm / 30 mm / 106 mm
Chassis materialPowder-coated aluminum plate, 1.5 mm thick
Maximum translational velocity1.0 m/s
Maximum rotational velocity420 deg/s (7.33 rad/s)
Maximum load capacityUp to 5 kg / 176 oz *not in continuous work
Battery life1.5h - 5h

Components​

Scheme 2RScheme 2R

Components description​

ComponentQuantityDescription
Infrared distance sensor4VL53L0X Time-of-Flight distance sensor with up to 200 cm range, more details
Built-in Microcontroller1STM32F407.
DC motor4Xinhe Motor XH-25D, Motor used: RF-370, 6VDC nominal, 6200rpm. Maximum mechanical power: 4W, no load speed at the output shaft: 180 rpm, stall torque at the output shaft: 2.9 kg*cm, stall current: 2.0A, gear ratio: ~34 (exact ratio is 30613/900)
Encoder4Magnetic, 48cpr, 12 poles
Batteries3Li-Ion 18650 protected, rechargeable batteries, 3500mAh capacity, 3.7V nominal voltage. Note: Device may be shipped interchangeably with similar batteries.
ComponentQuantityDescription
SBC1Raspberry Pi 5 (ARM64 architecture) quad-core ARM-8 Cortex A76 @ 2.4GHz, 8GB RAM and 64 GB MicroSD flash memory. The SBC runs on Ubuntu-based OS, customized to use ROS.
3D camera1Luxonis OAK-D Lite (in ROSbot 3) / OAK-D Pro (in ROSbot 3 PRO)
LIDAR1RPLIDAR C1 (in ROSbot 3) / S2 (in ROSbot 3 PRO), 360 degree, more details
IMU sensor1Intelligent 9-axis absolute orientation sensor BNO055, more details
Antenna1Dual-band, connected to the Wi-Fi USB adapter.

Block diagram​

Graphic representation of ROSbot 3 components and connections between them.

Block diagramBlock diagram

Rear panel description​

Rear panel description

ComponentQuantityDescription
Antenna connector1Wi-Fi antenna RP-SMA socket - required for Wi-Fi connectivity
USB2USB 2.0 host ports from SBC
HDMI1HDMI output from SBC
Power switch1Turns ROSbot completely ON or OFF
LEDs6LR1(blue), LR2(yellow), L1(red), L2(green), L3(green), PWR(red). See LED statuses below.
Reset button1Button used for reset CORE2
hBtn2hBtn1, hBtn2 - programmable buttons
Outputs for servo6Servo output with PWM, more details here
USB serial1USB serial port used for debugging the firmware on CORE2-ROS controller
Charging connector16-pin connector for charging internal Li-Ion batteries
DC power input1DC for working with external 12V power supply - use the power supply included with charger or any 12V, min. 5A power supply with 5.5/2.5mm plug (center-positive)
Time-of-Flight distance sensor2VL53L0X Time-of-Flight distance sensor with up to 200 cm range, more details here
hExt112xGPIO, 7x ADC, SPI, I2C, UART, more details here
hSens14 xGPIO, ADC, UART, more details here

LED statuses​

LEDRoleBehavior
🔵 LR1RPi statusOn — problem with the RPi (robot's computer), hRP pin 3
🟡 LR2MCU statusOn — MCU in bootloader (BOOT0), or STM32 not running correctly
🔴 L1Firmware indicatorOff — everything OK
Solid on — no communication with firmware / ROS driver not running
Blinking — low battery (overrides the above)
🟢 L2UserProgrammable from ROS 2 (/leds topic)
🟢 L3UserProgrammable from ROS 2 (/leds topic)

L1 is a status indicator driven by the firmware. L2 and L3 are user-programmable through the /leds topic (std_msgs/msg/UInt8), where each bit controls one LED: bit 0 (value 1) → L2, bit 1 (value 2) → L3.

# Turn L2 on
ros2 topic pub /leds std_msgs/msg/UInt8 "data: 1"

# Turn L2 and L3 on
ros2 topic pub /leds std_msgs/msg/UInt8 "data: 3"

Power supply​

ROSbot is powered from an internal, rechargeable Li-Ion battery pack that contains 3 Li-Ion cells, connected in series. This type of connection is called “3S”. The schematic below explains how the cells are wired together and with the charging connector (on ROSbot side).

Batt connectionBatt connection

The BAT+ and BAT- are the power connections and the “bal Bxx” wires are used to monitor the voltage on each cell. It is strongly recommended to keep equal voltages on each cell during the charging process. The charger included with ROSbot can charge batteries in the described way and, thanks to that, the long life of the battery set is possible.

The nominal voltage of each cell is 3.7V but the useful range is 3.2V to 4.2V.

Important - discharge indicator If only the right firmware is preloaded to the internal controller (CORE2), the LED1 is programmed to indicate the power status:

  • the LED1 is on when the robot is turned on
  • the LED1 is blinking when battery is low – please charge immediately!

Please make sure that the user firmware always contains the function that monitors the supply voltage level. Deep discharging of batteries may decrease their lifecycle. Discharging to the voltage lower than 3.0V/cell can also trigger the over discharge protection. If the voltage is too low, turn ROSbot off and charge batteries as soon as possible.

Charging ROSbot​

Charger+cables+PSUCharger+cables+PSU

The ROSbot kit contains the Redox Beta charger. It is an universal charger, suitable for charging NiCd, NiMH, Li-Po, Li-Fe, Li-Ion and Pb (AGM, VRLA) batteries. ROSbot shall be charged using an included charger and cable.

Charger kit includes:

  • Redox Beta charger
  • AC/DC power adapter 100...240V to 12V 5A with 5.5/2.5mm plug on the 12V side
  • a cable to connect charger with ROSbot charging port

Quick charging guide:

  1. Connect the power adapter to the charger and the output cable between charger and ROSbot (2 connectors on charger side, 1 black connector to ROSbot charging port).
  2. Use red and blue buttons to select “LiPo BATT” mode and press [Start].
  3. Use arrows to select “LiPo CHARGE” mode.
  4. Press [Start] - the current value should start blinking. Use arrows to set the current to 1.5A.
  5. Press [Start] again - the voltage value should start blinking. Select “11.1V(3S)” using arrows. The picture below shows the desired result.
  6. Press and hold [Start] for 2 seconds. The charger should now ask for confirmation. Press [Start] again. The charging process should begin now.
  7. When the charging will be finished (after about 3 hours), the charger will generate a loud “beep” sound and will finish charging at the same time.

Charge config

If you need more information about charging, please read the Charging manual for ROSbot in PDF format.

Notes

  • You can change charging current to maximum 3A. Please note that a regular charging with the maximum current can shorten the battery life.
  • If you are going to use ROSbot stationary for a long time, you can use ROSbot with charger or power supply connected all the time. Please see the Charging manual for ROSbot for details.
  • In case you need to replace batteries, use only 18650 Li-Ion batteries, with the capacity in a range of 1800...3500mAh and with a protection circuit! Using unprotected batteries may result in serious injuries or fire.
  • Unplug charging connectors carefully. You shall not unplug the charger connectors holding the wires. The balancer connection on ROSbot side has a latching tab (see photo below) that must be pressed before unplugging. On the charger side there is no latching tab but you should also unplug this connector holding the white plug.
Charger connectorCharger connector

Software​

Software for ROSbot can be divided into 2 parts:

  • A low-level firmware that works on the real-time controller (CORE2). It can be developed using Visual Studio Code IDE.
  • OS based on Ubuntu, which runs on the SBC (Raspberry Pi 4, UP Board, or Asus Tinker Board) and contains all components needed to start working with ROS or ROS 2 immediately. The microSD card or MMC memory with OS is included with each ROSbot. The OS has been modified to make the file system insensitive to sudden power cuts.

ROS 2 / ROS packages and Docker containers​

All software on ROSbot 3 is based on docker containers. List of available containers you can find here.

ROS 2 / ROS API​

QUICK NOTE

This API is based on the ROS 2 firmware, which you can find more information about in the rosbot_ros2_firmware repository.

Detailed information about content of rosbot package for ROS2.

Control​

Gamepad​

After running the ROSbot XL Manipulation Package, you should be able to control the manipulator. The easiest way to move the manipulator is to connect a gamepad and steer the robot. The graphic below shows how to steer the manipulator using a gamepad.

gamepad_rosbot

Drive controls are defined in rosbot_joy/config/config.yaml and published to manual/cmd_vel, the highest-priority input of velocity command arbitration — a held gamepad always overrides navigation. The manipulator gamepad mappings (XL only) are hardcoded in rosbot_moveit/src/joy2servo.cpp.

ROS API​

Namespace policy​

Set the namespace launch arg (or the ROBOT_NAMESPACE env variable) and every topic below moves under /<namespace>/ — that is how you run several robots on one network without them talking over each other.

A few topics stay global on purpose:

  • /tf, /tf_static — bridged via tf_namespace_bridge.
  • /parameter_events, /rosout — ROS 2 infrastructure.
  • /clock — simulation only.
  • /asset_providers — so one router can find every robot on a single topic.

This is hard-coded; there is no runtime switch. Details in Namespacing and multirobot.

Velocity command arbitration​

Several things may try to drive the robot at once — you with a gamepad, a navigation stack, your own script. twist_mux_controller decides who wins: the highest-priority source that sent a command in the last 0.2 s.

InputTopicPriorityWho usually publishes it
manualmanual/cmd_vel100gamepad (rosbot_joy), keyboard teleop
autonomousautonomous/cmd_vel10nav2
unknowncmd_vel1anything else

So grabbing the gamepad overrides navigation, and letting go hands control back automatically — no button, no mode switch. Plain cmd_vel still works, it is just the lowest priority now.

twist_mux_controller/source tells you who is driving. On ROSbot XL the LED strip follows it: autonomous plays the navigation animation, everything else plays ready (turn this off with follow_cmd_vel_source: false in rosbot_utils/config/<robot_model>/config.yaml).

Priorities and the 0.2 s timeout live in rosbot_controller/config/<model>/controllers.yaml.

Available Nodes​

🤖🖥️NODEDESCRIPTION
✅❌battery_alertROSbot XL only. Watches battery and plays low_battery.wav on the on-board speaker when the charge drops below percentage_threshold, at most once per interval_sec (the cooldown does not reset when the charge jitters back above the threshold; 0% / NaN samples are ignored as firmware glitches). The ALSA playback device is auto-detected from /proc/asound (the USB sound card the speaker PCB sits behind); set audio_device to pin it. Toggle with the battery_alert launch arg.
rosbot_utils/battery_alert
✅✅controller_managerController Manager performs two main functions. First, it manages controllers and their required interfaces, handling tasks like loading, activating, deactivating, and unloading. Second, it interacts with hardware components, ensuring access to their interfaces.
controller_manager/controller_manager
✅✅manipulator_controller_managerROSbot XL manipulation* only. Second controller_manager that owns OpenManipulatorXSystem, manipulator_controller, gripper_controller and manipulator_joint_state_broadcaster (publishes the arm joints on joint_states next to joint_state_broadcaster). Split from controller_manager so a missing arm cannot take the drive down. Hardware: started and restarted by manipulator_supervisor; simulation: a second gz_ros2_control plugin.
controller_manager/controller_manager
✅✅differential_drive_controller / mecanum_drive_controllerThe controller managing a mobile robot with a differential or omni drive (mecanum wheels). Converts speed commands for the robot body to wheel commands for the base. It also calculates odometry based on hardware feedback and shares it.DiffDriveController or MecanumDriveController
diff_drive_controller/diff_drive_controller
✅✅ekf_nodeUsed to fuse wheel odometry and IMU data. Parameters are defined in rosbot_localization/config/config.yaml
robot_localization/ekf_node
❌✅/gz_bridgeTransmits Gazebo simulation data to the ROS layer
ros_gz_bridge/parameter_bridge
❌✅gz_ros_controlResponsible for integrating the ros2_control controller architecture with the Gazebo simulator.
gz_ros2_control/gz_ros2_control
✅❌husarion_asset_serverServes this robot's package:// meshes/URDF resources over a get_asset service; auto-derives owned packages from the co-located robot_description. Toggle with the asset_server launch arg.
husarion_asset_server/asset_server
✅✅imu_broadcasterThe broadcaster to publish readings of IMU sensors
imu_sensor_broadcaster/imu_sensor_broadcaster
✅❌imu_sensor_nodeThe node responsible for subscriptions to IMU data from the hardware
rosbot_hardware_interfaces/rosbot_imu_sensor
✅✅joint_state_broadcasterThe broadcaster reads all state interfaces and reports them on specific topics
joint_state_broadcaster/joint_state_broadcaster
✅✅manipulator_supervisorROSbot XL manipulation* only. On hardware pings the arm (Dynamixel ID 11 on manipulator_serial_port); starts manipulator_controller_manager and spawns the arm controllers once it answers, logs an error and keeps retrying every 5 s while it does not, and restarts the arm stack when its controller_manager exits or OpenManipulatorXSystem leaves active/inactive (arm unplugged). Publishes the arm-only description on manipulator_controller_manager/robot_description and restarts the arm controller_manager when its hardware does not initialize within hardware_init_timeout (30 s). In simulation it only publishes the description and spawns the arm controllers.
rosbot_controller/manipulator_supervisor
✅✅robot_state_publisherUses the URDF specified by the parameter robot*description and the joint positions from the topic joint*states to calculate the forward kinematics of the robot and publish the results using tf
robot_state_publisher/robot_state_publisher
✅❌rosbot_system_nodeThe node communicating with the hardware responsible for receiving and sending data related to engine control
rosbot_hardware_interfaces/rosbot_system
❌✅rosbot_gz_bridgeTransmits data about the robot between the Gazebo simulator and ROS.
ros_gz_bridge/parameter_bridge
✅❌rosbot_mcuMicrocontroller unit (MCU) communication node: rosbot_mavlink_bridge, translating the MCU's MAVLink link to ROS 2.
[rosbot_mavlink_bridge/rosbot_mavlink_bridge]
✅✅twist_mux_controllerChainable controller arbitrating velocity commands from several sources by priority and forwarding the winner straight into the drive controller's reference interfaces — the arbitration runs inside the 100 Hz control loop, not over topics. See Velocity command arbitration.
[twist_mux_controller/TwistMuxController]

Available Topics​

🤖🖥️TOPICDESCRIPTION
✅✅autonomous/cmd_velVelocity commands from an autonomy stack (nav2). Priority 10 — yields to manual/cmd_vel.
geometry_msgs/TwistStamped
✅✅cmd_velVelocity commands from an unclassified source. Priority 1 — the lowest, kept for backwards compatibility.
geometry_msgs/TwistStamped
✅✅diagnosticsContains diagnostic information about the robot's systems.
diagnostic_msgs/DiagnosticArray
✅✅dynamic_joint_statesPublishes information about the dynamic state of joints.
control_msgs/DynamicJointState
✅✅imu/dataBroadcasts IMU (Inertial Measurement Unit) data.
sensor_msgs/Imu
✅✅joint_statesPublishes information about the state of robot joints. On hardware the effort field carries wheel motor torque (measured on ROSbot XL rev 1.1, back-EMF estimate otherwise); in simulation effort is NaN.
sensor_msgs/JointState
✅✅joyPublishes joystick input data.
sensor_msgs/Joy
✅✅manual/cmd_velVelocity commands from a human operator (gamepad, keyboard teleop). Priority 100 — the highest, so it overrides autonomy.
geometry_msgs/TwistStamped
✅✅odometry/filteredPublishes filtered odometry data.
nav_msgs/Odometry
✅✅odometry/wheelsProvides odometry data from the base controller of the ROSbot XL.
nav_msgs/Odometry
✅✅robot_descriptionPublishes the robot's description.
std_msgs/String
✅✅scanPublishes raw laser scan data.
sensor_msgs/LaserScan
✅✅set_poseChanges the robot's odometry/filtered pose.
geometry_msgs/PoseWithCovarianceStamped
✅✅tfPublishes transformations between coordinate frames over time.
tf2_msgs/TFMessage
✅✅tf_staticPublishes static transformations between coordinate frames.
tf2_msgs/TFMessage
✅✅twist_mux_controller/sourceName of the input currently driving the robot: manual, autonomous, unknown or not_published. Latched (transient_local), republished only on handover. On ROSbot XL animation_publisher follows it, so the LED strip shows who is driving.
std_msgs/String

There are also additional topics related with the ROSbot firmware. For more information about them, please refer to the ROSbot Firmware documentation.

Available Services​

🤖🖥️SERVICEDESCRIPTION
✅❌husarion_asset_server/get_assetResolves a package://PKG/REL URI to bytes (ranged fetch) for the description packages husarion_asset_server owns.
husarion_asset_msgs/srv/GetAsset
✅❌led_strip/enableROSbot XL only. Enables (data: true) or disables (data: false) the LED strip animation. While disabled the animation_publisher node neither computes nor publishes the led_strip image, and the firmware idle animation shows instead. The current_animation parameter is remembered across the gate, so enabling resumes whatever was selected.
std_srvs/SetBool

Packages​

One-line purpose per package; full detail (launch flows, internals) in ARCHITECTURE.md.

PackageDescription
rosbotMeta-package — pins sibling repos via *.repos, no code.
rosbot_bringupHardware entry point: per-model bringup + MCU MAVLink bridge. Local-only.
rosbot_controllerros2_control setup — spawns drive, IMU and joint-state controllers (plus the manipulator on XL).
rosbot_descriptionURDF/xacro for hardware and simulation, robot configurations, robot_state_publisher.
rosbot_gazeboGazebo simulation launch and robot spawning. Local-only.
rosbot_hardware_interfacesC++ ros2_control plugins (RosbotSystem, RosbotImuSensor) — the firmware ABI.
rosbot_joyJoystick teleop for driving (joy_node + teleop_twist_joy).
rosbot_localizationEKF fusing wheel odometry + IMU → odometry/filtered.
rosbot_moveitMoveIt manipulation for the OpenMANIPULATOR-X (XL only) — see MANIPULATOR.md.
rosbot_utilsUtilities: firmware flashing, robot configuration, udev rules, battery alert, LED strip.

ROS API

The MCU's ROS 2 interface, advertised on the SBC by rosbot_mavlink_bridge, which translates the firmware's MAVLink link. Downstream nodes (e.g. rosbot_ros) consume this node name, topic list, types, namespacing and QoS; see ARCHITECTURE.md for the wire side.

Nodes​

NODEDESCRIPTION
rosbot_mcuNode exposing the ROSbot MCU's topics and services. Advertised by rosbot_mavlink_bridge.

Topics​

RbRb XLTOPICDESCRIPTION
✅✅batteryBattery status.
sensor_msgs/BatteryState
✅✅buttonsButton states.
std_msgs/UInt8
❌✅led_stripLED strip command.
sensor_msgs/Image
✅✅ledsRear panel LEDs command.
std_msgs/UInt8
✅❌rangesRange sensor data.
sensor_msgs/Range
✅✅_imu/dataRaw IMU data.
sensor_msgs/Imu
✅✅_imu/calibrationBNO055 calibration status, 5 Hz — see below.
std_msgs/UInt8MultiArray
✅✅_motors/cmdWheel speed commands.
std_msgs/Float32MultiArray
✅✅_motors/feedbackWheel feedback.
sensor_msgs/JointState

Services​

SERVICEDESCRIPTION
_mcu_idGet MCU ID.
std_srvs/Trigger
_imu/start_calibrationStart a calibration session (red LED fast blink, 180 s).
std_srvs/Trigger
_imu/stop_calibrationEnd the session early.
std_srvs/Trigger
_imu/save_calibrationPersist the chip's current offsets to flash.
std_srvs/Trigger

IMU calibration​

The BNO055 calibrates itself continuously; these entry points only show its progress and persist the result, so the robot keeps driving throughout and no MCU reset is needed.

_imu/calibration data layout: [sys, gyro, accel, mag, save_state, save_seq, has_saved, session].

  • sys/gyro/accel/mag — the chip's CALIB_STAT, 0..3 each.
  • save_state — result of the last save: 0 none, 1 saving, 2 saved, 3 rejected (not calibrated), 4 failed (flash).
  • save_seq — increments on every completed save attempt.
  • has_saved — 1 when flash holds a calibration record.
  • session — 1 while a session started by _imu/start_calibration is on.

Saving requires gyro == accel == mag == 3. sys is ignored: it is the fusion's confidence, not an offset status, and it does not reliably reach 3 on an assembled robot. The session only drives the LED; a save is accepted with or without one.

_imu/save_calibration replies success plus a JSON message: {"result": R, "sys": .., "gyro": .., "accel": .., "mag": ..} with R one of saved, not_calibrated, failed, timeout, no_ack, no_status. Start/stop reply {"result": "ok" | "rejected" | "no_ack"}.

External documentation​

System reinstallation​

In some cases you will need to restore ROSbot system to its default settings:

  • in case of accidental damage of the system,
  • to update the OS (it can be updated remotely, but flashing the microSD card can be easier sometimes),
  • to clear all user changes and restore factory settings.

This process will differ depending on ROSbot version that you have. Find the full instruction here

Connect ROSbot to your Wi-Fi network​

At first ROSbot need to be connected to your Wi-Fi network.

Option 1: Using display, mouse and keyboard​

ROSbot is basically a computer running Ubuntu, so let's open it like a standard PC computer.

  1. Plug in a display with HDMI, mouse and keyboard into the USB port in the rear panel of ROSbot.
  2. Turn on the robot and wait until it boots.
  3. Open a terminal.

ROSbot 2R LxQT desktop environment

warning

ROSbot's graphical desktop environment requires about 3 minutes to start during first boot. The following ones require only about 1 minute after power on.

Connecting to Wi-Fi with netplan​

Find available Wi-Fi networks with this Linux command:

husarion@rosbot2r:~$ ... 
sudo iwlist wlan0 scan

ROSbot 2R is using netplan instead of GUI Wi-Fi manager. It allows you to have all physical network interfaces configured from a single text file.

To connect your ROSbot to a Wi-Fi network edit /etc/netplan/01-network-manager-all.yaml file, eg. with nano:

husarion@rosbot2r:~$ ... 
sudo nano /etc/netplan/01-network-manager-all.yaml

And modify lines 22-23 by replacing "PLACE_YOUR_WIFI_SSID_HERE" with your SSID (Wi-Fi network name) and "PLACE_YOUR_WIFI_PASSWORD_HERE" with your Wi-Fi password:

/etc/netplan/01-network-manager-all.yaml
network:
  version: 2
  renderer: networkd

  ethernets:

    all-eths:
      match:
        name: eth*
      dhcp4: no
      dhcp6: no
      addresses:
       - 192.168.77.2/24

  wifis:

    wlan0:  # external USB Wi-Fi card (with antenna)
      dhcp4: true
      dhcp6: true
      optional: true
      access-points:
        "PLACE_YOUR_WIFI_SSID_HERE":
          password: "PLACE_YOUR_WIFI_PASSWORD_HERE"

save the file then, apply the new network setup:

husarion@rosbot2r:~$ ... 
sudo netplan apply

You can check to which Wi-Fi network your ROSbot is connected by using this command:

husarion@rosbot2r:~$ ... 
sudo iwgetid

If your Wi-Fi network setup is more complex (eg. if you want to connect to Eduroam based Wi-Fi that is popular in many universities), visit netplan configuration examples.

Open Linux terminal and type

husarion@rosbot2r:~$ ... 
sudo ifconfig

to find your IP address (for wlan1 network interface). Save it for later.

Option 2: Using an Ethernet adapter​

In the ROSbot 2R set there is one USB-Ethernet card.

  1. Turn on the robot and wait until it boots.

  2. Plug in the Ethernet adapter (included in a set) to a USB port in the rear panel.

  3. Plug in one end of the Ethernet cable into your computer and another one to the adapter.

  4. Set a static IP address on your computer for its Ethernet card in a 192.168.77.0/24 subnet, eg:

    • IPv4: 192.168.77.27
    • mask: 255.255.255.0

  5. To connect with ROSbot via ssh, type in your terminal application:

    user@mylaptop:~$ ...
    ssh husarion@192.168.77.2

    The default password for user husarion is also husarion.

At this point the Wi-Fi configuration process is the same as in the section above

Access ROSbot terminal using wireless connection​

Connecting over LAN network​

While ROSbot is connected to a Wi-Fi network, you can access it by using its IPv4 address by SSH:

user@mylaptop:~$ ...
ssh husarion@ROSBOT_IP

Connecting over the internet (optional)​

You can access the robot not only in LAN but also over the Internet. The connection is based on Husarnet VPN.

Learn how to do it here.

Low level firmware installation​

In the heart of each ROSbot there is a CORE2 board equipped with STM32F4 family microcontroller. The board is responsible for real time tasks like controlling motors, calculating PID regulator output or talking to distance sensors. High level computation is handled by SBC (single board computer) - Asus Tinker Board (in ROSbot 2), UP Board (in ROSbot 2 PRO) or Raspberry Pi 4 (in ROSbot 2R).

In order to use ROSbot you have to flash ROSbot's CORE2 board with low level firmware.

The firmware running on STM32F4 microcontroller is open source and available on GitHub. There are:

SSH to ROSbot over LAN network or VPN to get access to it's Linux terminal.

warning

Before flashing the firmware all previously launched docker containers must be stopped (you can display running containers with the docker ps command). Just execute the commands below:

husarion@rosbot2r:~$ ... 
docker kill $(docker ps -q)
husarion@rosbot2r:~$ ... 
docker container prune -f

The firmware for STM32 is available in the ROSbot snap.

To flash the right firmware, open ROSbot's terminal and execute the following command:

sudo rosbot.flash

ROS / ROS 2 Tutorials​

ROS (Robot Operating System) offers libraries and tools to help software developers create robotic applications. It provides hardware abstraction, device drivers, libraries, visualizers, message-passing, package management, and more. It's very powerful and functional tool dedicated to design robots. We created the set of ROS Tutorials dedicated for this platform to make it easier to familiarize yourself with these frameworks.

Reference projects​

warning

Please note that the following projects are based in Docker only (including running the ROS 2 driver for ROSbot 3). Before running those demos, please stop the ROS 2 driver running in snap first:

sudo rosbot.stop
linkdescription
rosbot-gamepadControl the robot manually using a Logitech F710 gamepad
rosbot-telepresenceStream a live video from Orbbec Astra to a window on your PC. Control the robot using teleop-twist-keyboard
rosbot-autonomyA combination of mapping and navigation projects allowing simultaneous mapping and navigation in unknown environments.

Here is an example map generated with the rosbot-autonomy project.

map example

All helpful documents and links in one place: