Benchmarking Perception Workloads on a Rover: Jetson Orin Nano vs Raspberry Pi 5

TL;DR: In a Jetson Orin Nano vs Raspberry Pi 5 robot comparison focused on perception workloads, the Orin Nano (8 GB, MAXN Super mode available with JetPack 6.2 or newer) delivers roughly 6-10x higher throughput on YOLOv8n object detection (approximately 90-120 FPS at 640×640, INT8/TensorRT) than a Raspberry Pi 5 (8 GB) running the same model on CPU with NCNN (approximately 10-14 FPS). For 2D LiDAR SLAM with slam_toolbox, both platforms sustain a 10 Hz scan rate in real time; the Pi 5 uses about 35-45% CPU, the Orin Nano about 15-20%. For H.264 1080p30 encoding, the Pi 5’s software x264 pipeline reaches about 22-28 FPS at ~6 W, while the Orin Nano’s dedicated NVENC hardware encoder sustains ~30 FPS at ~9-12 W. Recommendation logic: pick the Pi 5 for telemetry, teleop, 2D SLAM, and light CV; pick the Orin Nano when you need real-time deep learning inference onboard.

Why benchmark Jetson Orin Nano vs Raspberry Pi 5 on a real robot?

Datasheet TOPS numbers rarely survive contact with a rover. Thermal envelope, DC-DC efficiency, ROS 2 middleware overhead, USB bandwidth contention, and vibration on uneven terrain all shift the picture. If you are choosing a compute module for a mobile robot or UGV like the Leo Rover, the question is not “which chip is faster in isolation” but “which chip sustains your perception pipeline at target frame rate, within your power budget, at ambient temperatures you actually operate in.”

Fictionlab’s team ran a repeatable benchmark on a single Leo Rover chassis, swapping only the compute module and re-running three workloads representative of field robotics: object detection, 2D SLAM, and video compression for teleoperation. All tests used ROS 2 Humble on Ubuntu 22.04.

Hardware under test

Both boards were mounted inside the Leo Rover payload bay, powered from the rover’s regulated 5 V rail (Pi 5) and 19 V input via the official Jetson carrier (Orin Nano). Ambient during testing was approximately 22 °C indoors.

• Raspberry Pi 5, 8 GB: Broadcom BCM2712, 4x Cortex-A76 @ 2.4 GHz, VideoCore VII GPU, active cooler.
• NVIDIA Jetson Orin Nano Developer Kit, 8 GB: 6x Cortex-A78AE @ 1.7 GHz, 1024 CUDA cores + 32 Tensor cores (Ampere), MAXN Super power mode enabled (JetPack 6.2 or newer).
• Sensors: RPLIDAR A2M12, Intel RealSense D435i, USB 3.0 hub.

How were the perception workloads defined?

Three workloads were selected because they map to real Leo Rover and Raph Rover deployments in research and inspection: onboard object detection for autonomous behaviors, LiDAR SLAM for mapping, and video streaming for supervised teleoperation.

Workload 1: Object detection with YOLOv8n at 640×640

The same ultralytics YOLOv8n weights were exported to platform-native runtimes.

On the Raspberry Pi 5, NCNN was used with the following export and run pattern:

• yolo export model=yolov8n.pt format=ncnn
• yolo predict model=yolov8n_ncnn_model source=video.mp4 imgsz=640

On the Jetson Orin Nano, TensorRT INT8 was used with an INT8 calibration dataset:

• yolo export model=yolov8n.pt format=engine half=False int8=True imgsz=640 data=calibration.yaml
• yolo predict model=yolov8n.engine source=video.mp4 imgsz=640

Measurements were averaged over 2000 frames from a recorded rover POV video.

Workload 2: 2D SLAM with slam_toolbox at 10 Hz

The RPLIDAR A2M12 published at 10 Hz. slam_toolbox ran in async mode with default parameters and wheel odometry from the Leo Rover firmware.

• ros2 launch slam_toolbox online_async_launch.py

Workload 3: H.264 encoding of 1080p30 for teleop

A GStreamer pipeline captured from the D435i RGB stream and encoded to H.264 for RTP streaming.

Pi 5 (software x264; Raspberry Pi 5 has no hardware H.264 encoder):

• gst-launch-1.0 v4l2src ! video/x-raw,width=1920,height=1080,framerate=30/1 ! videoconvert ! x264enc tune=zerolatency bitrate=4000 speed-preset=ultrafast ! rtph264pay ! udpsink host=... port=5000

Orin Nano (dedicated NVENC hardware encoding via nvv4l2h264enc on JetPack 6):

• gst-launch-1.0 v4l2src ! video/x-raw,width=1920,height=1080,framerate=30/1 ! nvvidconv ! nvv4l2h264enc bitrate=4000000 ! rtph264pay ! udpsink host=... port=5000

What do the numbers say for jetson orin nano vs raspberry pi 5 robot builds?

The following results are from Fictionlab’s in-house testing on a single Leo Rover chassis. Treat them as approximate and workload-specific.

Object detection results (YOLOv8n, 640×640)

• Raspberry Pi 5: approximately 11 FPS, end-to-end latency ~90 ms, package power ~7 W under load, SoC temperature ~68 °C with active cooler.
• Jetson Orin Nano (Super, INT8): approximately 105 FPS, latency ~10 ms, module power ~14 W, SoC temperature ~62 °C with stock fan.

Cost-per-FPS at MSRP (board only, approximate): Pi 5 8 GB at ~$80 gives ~$7.3/FPS; Orin Nano Dev Kit at ~$249 gives ~$2.4/FPS. If your workload is deep learning inference, the Jetson is markedly more efficient per dollar and per watt-per-inference.

SLAM results (slam_toolbox, 10 Hz LiDAR)

• Raspberry Pi 5: sustained 10 Hz, average CPU load ~40% across 4 cores, RAM ~600 MB, power ~6 W.
• Jetson Orin Nano: sustained 10 Hz, average CPU load ~18% across 6 cores, RAM ~700 MB, power ~9 W.

Both are sufficient. The Pi 5 leaves headroom for navigation2, costmaps, and behavior trees; only when you add heavy CV nodes on the same board does it saturate.

Video encoding results (H.264 1080p30, 4 Mbps)

• Raspberry Pi 5: 24 FPS sustained (dropped frames at 30 FPS target), glass-to-glass latency ~180 ms, power ~8 W, temperature ~72 °C.
• Jetson Orin Nano: 30 FPS sustained, latency ~90 ms, power ~11 W, temperature ~60 °C.

For teleop over cellular or Wi-Fi where you need reliable 30 FPS at 1080p plus a perception stack running concurrently, hardware-accelerated encoding on the Jetson matters. For 720p30 teleop only, the Pi 5 is adequate.

How should you pick between them for a Leo Rover or Raph Rover payload?

The decision is workload-driven, not brand-driven. Use this mapping as a starting point and validate on your own dataset.

• Teleoperation, telemetry, 2D SLAM, waypoint navigation, classical CV (OpenCV, ArUco, line following): the Raspberry Pi 5 handles it with headroom, at lower power and lower cost.
• Onboard deep learning (YOLO, segmentation, depth estimation, visual odometry with learned features): the Jetson Orin Nano is the appropriate choice; the Pi 5 will not reach real-time on most modern networks without aggressive quantization and resolution cuts.
• Multi-camera pipelines with concurrent H.264/H.265 encoding: the Jetson’s dedicated encoder frees the CPU for control and planning.
• Battery-constrained long missions with light perception: the Pi 5 generally draws less power continuously, which on a 100 Wh pack can translate to noticeably longer runtime.

A common pattern in field robotics on the research applications Fictionlab supports is a hybrid: Pi 5 or the Leo Rover’s stock controller handles motor control, ROS 2 bringup, and telemetry, while a Jetson Orin Nano sits on the payload bus dedicated to perception. This isolates the real-time control loop from GPU thermal transients and simplifies debugging.

Thermals and power on a moving rover

Bench numbers assume steady airflow. Inside a sealed payload bay on a rover under sun, SoC temperatures can rise by 10-15 °C compared to open-bench conditions. As the Orin Nano approaches its configured thermal limits, it reduces clock frequencies; the applicable threshold depends on the installed thermal profile. The Pi 5 begins soft-throttling around 80 °C. Plan for forced airflow or a heatsink extension to the chassis if you operate above 30 °C ambient.

Reproducing the benchmark

To reproduce these numbers on your own hardware, follow this sequence.

1. Flash Ubuntu 22.04 with ROS 2 Humble on both boards. On Jetson, use JetPack 6.2 or newer, select the available MAXN Super power profile with nvpmodel, and use sudo jetson_clocks where appropriate for repeatable peak-performance testing.
2. Install ultralytics, NCNN (Pi) or TensorRT (Jetson), and slam_toolbox from apt.
3. Record a 60 s rosbag with LiDAR and camera on your rover for consistent replay.
4. Measure power with an inline USB-C or barrel power meter; do not rely on software estimates alone.
5. Log temperatures with vcgencmd measure_temp (Pi) or tegrastats (Jetson) at 1 Hz during the run.

Frequently asked questions

Can the Raspberry Pi 5 run YOLO in real time on a robot?

Only for small models at reduced resolution. YOLOv8n at 320×320 with NCNN reaches approximately 25-30 FPS on the Pi 5. At 640×640, expect ~11 FPS. For anything larger than YOLOv8n or requiring 640+ input, use an accelerator.

Does the Jetson Orin Nano work with ROS 2 out of the box?

Yes. JetPack 6 is based on Ubuntu 22.04, which supports ROS 2 Humble via standard apt packages. GPU-accelerated nodes from NVIDIA Isaac ROS require additional setup but run natively.

What about the Raspberry Pi 5 AI Kit (Hailo-8L)?

The Hailo-8L add-on changes the picture for inference: it delivers up to 13 TOPS at low power and can substantially accelerate compatible YOLO models. It is a valid third option, though software integration into ROS 2 pipelines generally requires more manual work than TensorRT on Jetson.

Which board is better for VSLAM (ORB-SLAM3, RTAB-Map)?

Both can run RTAB-Map with an RGB-D camera at modest resolutions, although achievable update rates depend strongly on camera settings, map size, and enabled features. The Jetson provides more headroom when you enable GPU-accelerated feature extraction or loop closure with learned descriptors.

How much power does each board draw at idle?

In testing: Pi 5 idles at approximately 3 W, Orin Nano at approximately 5-6 W in MAXN Super mode. Lower Jetson power modes reduce idle to ~4 W at the cost of peak inference throughput.

Can I run both boards on the same Leo Rover?

Yes. The Leo Rover’s payload bay and 5 V/12 V rails accommodate dual-compute setups. A typical split assigns ROS 2 control and sensor drivers to one board and perception to the other, connected over Ethernet with DDS discovery configured explicitly.

Does the choice affect ROS 2 DDS performance?

Usually only marginally for typical ROS 2 topic traffic. For high-bandwidth image topics, CPU cost from serialization and compression as well as network bandwidth can become bottlenecks. Prefer image_transport with compressed transports or offload encoding as shown above.

Build your rover with the right compute

Whether your project calls for a lean Pi 5 build for classical navigation or a Jetson Orin Nano payload for onboard deep learning, the Leo Rover chassis supports both. Explore configurations and add sensors or compute modules that match your workload in the Fictionlab shop.