Sowbot (ROS 2 stack)

July 30, 2026 · View on GitHub

An open-source, containerised ROS2 Jazzy stack for autonomous agricultural robotics. This repository provides the drivers and orchestration for the Sowbot platform, featuring RTK-GNSS localisation and ESP32-based hardware control.

Development is led by the Agroecology Lab building on the core developed by Zauberzeug.

Reference open hardware stack(s) under development at Sowbot.co.uk

Quick start Collaborators welcome. See CONTRIBUTING.md.

Contact: sowbot.co.uk

Milestone — multi-row mission following validated in Gazebo:

Multi-row mission following in Gazebo

Sowbot Roadmap

#FeatureDescriptionStatusTRLPhase
FOUNDATION2025
F1Containerised deploymentFull ROS 2 Jazzy stack managed via Docker and manage.py. Live volume mapping to /workspace. Build, full-build, and +sim build modes.Done62025
F2Stable device addressingfixusb.py with Jetson/generic architecture detection, kernel low_latency mode, and udev symlink generation. Writes .env consumed by all launch files. Note: run_neo() never calls fixusb.py so .env is not written for neo-only runs.Done62025
F3Teleop dashboardNiceGUI web cockpit on :80. Three-tab interface: Nav (joystick, e-stop, topo map, node-drop, track mode), Mission (fields2cover corner entry, F2C row plan generator, reorderable mission queue), System (telemetry, safety indicators, GPS leaflet map).Done62025
F4ublox DGNSS driverDual F9P moving-base configuration with dynamic port assignment via fixusb.py.Done62026
F5Diagnostics TUIagbot-diagnostic.py terminal status view of all hardware topics. Run inside container via login.sh.Done62025
MVP FIELD2026
M1Agri Open Core platform integrationDemonstrates AOC platform abstraction on affordable ARM hardware accessible to smallholders.Done32026
M2Topological navigation + Nav2LCAS topological_navigation (aoc_refactor branch) building in Dockerfile. RViz visualisation confirmed working. Self-contained navigation2.py with A* route planning, explicit state machine, and row_traversal / NavigateToPose / goal_align edge actions. fake_nav2_server with /limbic_row_follow stub enables full pipeline testing in sim. sim_nav.launch.py now routes through real Nav2. Multi-row mission following (entry/exit node pairs across boustrophedon rows) validated end-to-end in Gazebo. Pending: Jazzy field validation on hardware.~85% Done42026
M2afusioncore Nav2 bridgefusioncore_node launched via devkit.launch.py. Nav2 topic remapping shim wired. Pending: end-to-end test on live hardware.~75% Done42026
M3Open-field row-crop scenarioLive node-drop in UI. F2C row plan generator implemented in ui_node.py (corners → swaths → topo rows via _run_f2c()). YAML written to /workspace/maps/, switch_topological_map with fallback. Topo map auto-generated at container start. Multi-row traversal across generated swaths confirmed in sim. Pending: tmap2 authoring from real field survey; F2C obstacle costmap integration.~70% Done42026
M4RTK-GNSS localisationFull pipeline implemented: dual F9P, shims, UKF fusion, NTRIP. Lever-arm offsets in fusioncore.yaml are zeroed placeholders (commented # measured TODOs). Pending: antenna lever-arm measurement, live hardware test.~75% Done32026
M5Dual-SBC ROS 2 stackmanage.py detects crossover interface, builds CYCLONEDDS_URI peer config and injects into Docker. neo.launch.py and devkit.launch.py finalised for Limbic+Neo split. DDS peer path is the active one.~90% Done32026
M6Gazebo simulationsowbot_sim.launch.py + sim_nav.launch.py fully restructured. kill_fake_nav2_on_clock implemented. use_sim_time=True now threaded through topo stack. Multi-row mission following demonstrated end-to-end (see video above).Done42026
M7Sentor safety monitoringsowbot_monitor.yaml fully authored (e-stop, bumpers, battery, camera, odom, neo_vision heartbeat, node monitors). sentor_node.py wired into devkit.launch.py. Pending: smoke-test on live hardware; battery voltage cutoff needs field confirmation (# TODO: CONFIRM in YAML).~75% Done32026
M8Visual crop-row navigationsowbot_row_follow package implemented. ExG+Otsu, visual servo, limbic_row_follow_node.py as Nav2 action server. Cancel and heartbeat-loss safety. TSM row-swap hold with 6-second debounce implemented. Camera calibration params required before field use. Pending: camera calibration, field test.~75% Done32026
PRODUCTION~2027
P1STM32H7 + copper-rs MCUReplace ESP32/Lizard DSL with STM32H745 running copper-rs statically-scheduled Rust firmware. Hard real-time motor PID, hardware safety interlocks.Research22027
P2CANopen busISO 11898 FDCAN at 500 kbit/s / 2 Mbit/s. lely-core CANopen master on T527 native M_CAN. DSP402 drive profile.Research22027
P3RT kernel + core isolationPREEMPT_RT on Limbic T527. isolcpus=4-7, RTK EKF on core 2 (SCHED_FIFO 60), AOC nav on cores 4-6, watchdog on core 5. GbE/CAN IRQ pinned to core 0.Planned22027
P4ROFS imageRead-only rootfs — Ubuntu Noble minimal or Yocto with RT kernel, pre-built LCAS topo nav, Nav2, rmw_zenoh_cpp. Immutable field deployment.Research12027
END-EFFECTORSTBD
E1Delta weeding moduleOpen-Weeding-Delta precision mechanical weeding. CANopen actuator node on delta controller.Research1TBD
E2LASER weeding moduleLaudando LASER integration. Requires E-Stop interlocking with CANopen safety chain.Research1TBD
DATASETS & COLLABORATIONOngoing
D1UK open-field datasetField imagery and GNSS logs from UK agroecological farm conditions. CC licence.Planned22026
D2Caatinga biome datasetSemi-arid row-crop imagery from caatingarobotics. Validated on T527 AIPU.Active52026

TRL = Technology Readiness Level (1–9, ESA/NASA scale): 1–2 concept/formulation, 3 proof of concept, 4 validated in lab/simulation, 5 validated in relevant (non-lab) environment, 6 demonstrated in relevant environment, 7 operational prototype, 8 qualified system, 9 field-proven. Self-assessed per feature, not a formal review — adjust as needed.

Collaboration

This project is built on and aims to maintain upstream compatibility with zauberzeug/feldfreund_devkit_ros.

High Level navigation is developed from the work of Lincoln Centre for Autonomous Systems (LCAS) as part of the Agri-OpenCore open ROS 2 ecosystem for agricultural robotic

Simulation configuration is partially derived from work by caatingarobotics,

Rewrite-from-Scratch Cost Estimate

Estimate for reimplementing the full stack pulled in by feldfreund_devkit_ros/docker/Dockerfile (caatinga-dev), instead of building on ROS 2 Jazzy + Nav2 + third-party packages.

Foundational infra

ComponentRewrite hrs
ROS 2 core + Nav2120,000–250,000

Packages pulled in & developed in house

PackageWhat it doesRewrite hrs
Gazebo Harmonic (INSTALL_SIM)Physics engine + rendering + SDF15,000–70,000
topological_navigation (LCAS)Topo-nav stack4,000–8,000
Fields2CoverCoverage path planning2,500–5,000
YOLOXReal-time object detector arch4,000–10,000
NiceGUI (web cockpit)Web UI framework4,000–8,000
ublox_dgnssRTK GNSS driver1,200–2,500
septentrio_gnss_driverRTK GNSS driver1,200–2,500
vision_opencv (cv_bridge, image_geometry)ROS↔OpenCV bridge1,000–2,500
fusioncoreUKF GNSS/IMU fusion800–2,000
LizardESP32 firmware bridge800–1,500
virtual_maize_fieldGazebo row-crop world gen400–1,200
Forest3DProcedural terrain gen400–1,200
sentor, mongodb_store, ros2graph_explorer, ros2grapherMonitoring/dev-tool glue600–1,800
sowbot_row_follow TSM vision pipelineLine fitting, ExG masking, multi-row detection, gating800–1,800
sowbot_row_follow state machine + action serverFOLLOW_ROW transitions, control loop integration550–1,300
sowbot_row_follow field tuning/debuggingReaching current maturity400–1,000

Subtotal, non-core: ~37,750–120,100 hrs

Total

~157,750–370,100 engineering hours (≈76–183 person-years)

Excludes OpenCV, GDAL, Boost, Eigen, PyTorch — rewriting those too pushes this into the millions of hours and isn't a serious option.

At a $120/hr fully-loaded US engineering rate, that's ≈$18.9M–$44.4M.

⚠️ CRITICAL SAFETY WARNING:

This software is under active development and may be broken at any given moment. For a stable reference implementation see the upstream Zauberzeug project.

THIS SOFTWARE COULD CONTROL PHYSICAL HARDWARE CAPABLE OF PRODUCING SIGNIFICANT KINETIC FORCE.

  1. EXPERIMENTAL STATUS: This branch ('sowbot') contains experimental code generated and refined with AI assistance. It has NOT undergone full-scale field validation.
  2. STATUTORY NOTICE (UK): Usage of this software is at the user's sole risk. While standard open-source licenses apply, users are reminded that operating agricultural robotics requires a professional duty of care.
  3. MANDATORY HARDWARE SAFETY: Under no circumstances should this software be used to control a robot of any size without a independent, hard-wired, physical Emergency Stop (E-Stop) system. Software-based stops (such as /estop/soft) are NOT a substitute for Category 0 or 1 hardware safety stops.
  4. NO LIABILITY: To the extent permitted by the laws of England and Wales, the contributors exclude all liability for property damage, crop loss, or indirect consequential damages.

Health Warning

This repo may contain traces of LLM slop, We've done our best to mitigate this. If you are allergic to slop, please help us refactor.

Quick Start

0. Install dependencies

Linux

Mac

  • xcode-select --install
  • Git
  • Docker
  • & launch Gazebo in a browser from the WebUI.

Windows?

1. Clone the Repository

Open a terminal on your host machine and download the workspace:

git clone -b caatinga-dev https://github.com/Agroecology-Lab/feldfreund_devkit_ros.git
cd feldfreund_devkit_ros

2. Build & Launch

Use the management script to build the ROS 2 workspace and launch the robot stack. This script automatically handles hardware discovery and port permissions:

./manage.py full-build
xhost +local:docker
./manage.py

Access http://localhost to access the WebUI

Linux

If you're getting this error:

docker: Error response from daemon: could not select device driver "" with capabilities: [[gpu]]

You'll need to install the Nvidia Container runtime.

Gazebo

If you'd like to use Gazebo then add a +sim argument to your build instruction

./manage.py full-build +sim
xhost +local:docker
./manage.py

Management & Tools

manage.py

The primary entry point for the system. While it runs the full stack by default, it supports several optional arguments for development:

CommandLogic / ArgumentResulting Action
./manage.py(No arguments)Runs run_runtime() immediately using live volumes.
./manage.py buildbuildlocal-only, fully cached including external clones
./manage.py build +pullbuildRe-clones the 9 external repos, keeps apt/pip/local layers cached
./manage.py build +pull +simbuild Same, plus INSTALL_SIM=true
./manage.py full-buildfull-buildRuns run_build(full=True). Cleans system & Re-installs all system dependencies.
./manage.py neoneoRuns neo. Runs only the line following code for the second 'neo'(cortex) perception SBC. Then check http://localhost:8080
./manage.py neo-tsmneo-tsmRuns neo-tsm. Runs experimental line following informed by Vision based Crop Row Navigation under Varying Field Conditions in Arable Fields - Rajitha de Silva1, Grzegorz Cielniak2 and Junfeng Gao. Then check http://localhost:8080
./manage.py pull-caatingapulls & builds vision pipelineRequires the container to already be running

One-command sim launch (TMuLE)

Whilst you can launch Gazebo and other tools from the webui, some may prefer the terminal, this makes terminal use a bit easier.

TMuLE brings the whole row-following sim up in a single tmux session — one window per process — instead of running the three launch steps by hand in separate terminals:

tmule -c tmule/row_follow_sim.yaml launch
tmux attach -t row_follow_sim

That starts ./manage.py --sim (nav stack + Nav2 + UI), Gazebo (sowbot_sim.launch.py) and the crop-row CV node (crop_row_nav.launch.py), each in its own tmux window. launch returns immediately and leaves the session detached, so attach to watch the panes come up (and to type the nav_stack sudo password).

Stop the stack with tmule -c tmule/row_follow_sim.yaml stop; re-attach later with tmux attach -t row_follow_sim.

If a runtime container is already running, the nav_stack window will fail on a docker run name collision. Either docker stop sowbot_runtime first, or launch just the windows that reuse the container: tmule -c tmule/row_follow_sim.yaml launch -w gazebo.

tmux basics

The stack runs in a detached tmux session named row_follow_sim, so closing your terminal does not kill it — detaching is not stopping. The session holds one window per sub-system (plus a stray 0: bash that tmux always creates):

0: bash   1: nav_stack   2: gazebo   3: crop_row

Every shortcut starts with the prefix Ctrl-b — press and release it, then the next key:

KeysResulting Action
Ctrl-b dDetach — leaves the whole stack running in the background
Ctrl-b wInteractive window picker (easiest way to move around)
Ctrl-b 1 / 2 / 3Jump straight to nav_stack / gazebo / crop_row
Ctrl-b n / pNext / previous window
Ctrl-b [Scroll back through ROS log output — arrows/PgUp, q to exit
Ctrl-b zZoom the current pane fullscreen (press again to unzoom)
Ctrl-b ?List every binding
tmux ls                              # list sessions
tmux attach -t row_follow_sim        # attach
tmux kill-session -t row_follow_sim  # nuke the session

Scrolling back (Ctrl-b [) is the one you'll reach for most — it's how you read ROS output that has already scrolled past. For mouse-wheel scrolling instead, add set -g mouse on to ~/.tmux.conf.

Scenario configs live in tmule/ — see tmule/README.md to tweak launch arguments or add your own scenario.

Interactive Shell

To enter the running container for debugging or manual ROS 2 commands:

./login.sh

Diagnostics

If hardware is connected but topics are not flowing, run the diagnostic tool from inside the container:

After running ./login.sh

python3 agbot-diagnostic.py

TUI Status.

You can also make it verbose with:

python3 agbot-diagnostic.py full

Sketch of MVP 2026 architecture

1. The Lizard Brain (RT Microcontroller)

  • Hardware: ESP32 MCU.
  • Software: Lizard DSL.
  • Role: Hard Real-Time Execution.
  • Function: Motor PID control and physical safety (bumpers/cliffs).
  • I/O: 3.3V UART receiving v,ωv, \omega via the teleop_lizard ROS 2 bridge.

2. The Limbic System (Executive)

  • Hardware: Avaota A1 #1 (Allwinner T527).
  • Software: ROS 2 Jazzy + topological_navigation (AOC branch).
  • Role: Navigation Executive.
  • Function: Runs the Topological Navigation stack. UBLOX sensors Manages the move_base sequence and Action on Condition (AOC) logic.
  • I/O: Connects to u-blox via USB/UART using ublox_dgnss node. Translates graph goals into velocity commands for the Lizard Brain.

<1GbE interconnect between 2&3>

3. The Neo (Perception)

  • Hardware: Avaota A1 #2 (Allwinner T527 + NPU).

  • Software: Dockerised ROS 2 Jazzy.

  • Role: Asynchronous Perception.

  • Function: NPU-accelerated inference (YOLO/Object tracking) and sensor fusion.

  • Connectivity: Native Zenoh integration via rmw_zenoh_cpp. Publishes environment states and "Conditions" to the Zenoh network.

                        |

Sketch of possible eventual ~2027 architecture

1. The Lizard Brain (Hardware Abstraction)

  • Hardware: STM32 H7 MCU.
  • Software: copper-rs.
  • Role: Hard Real-Time Execution.
  • Function: Manages motor PID loops and hardware-level safety interlocks.
  • I/O: Canbus

2. The Limbic System (Executive)

  • Hardware: Avaota A1 #1 (Allwinner T527).
  • Software: RT kernel, Buildroot copper-rs
  • Role: Deterministic Executive.
  • Function: UBLOX sensors, Executes Action on Condition (AOC) logic for topological navigation.
  • Data Entry: Directly consumes Zenoh keys from the Neo board to trigger mission state transitions and motion planning.
Core(s)RoleAllocation Strategy
Core 0OS / I/OHandles kernel house-keeping, SSH, and the 1GbE driver interrupts.
Core 1Zenoh / Neo-linkDedicated to the Zenoh router and serializing incoming "Nice-to-Have" data.
Cores 2-6The Pilot (Nav)This is where the RTK EKF, Path Planner, and Task Graph live.
Core 7The Bridge (Lizard)Dedicated to SocketCAN and the high-frequency heartbeat to the STM32 (Lizard).

<1GbE interconnect between 2&3>

3. The Neo (Perception)

  • Hardware: Avaota A1 #2 (Allwinner T527 + NPU).
  • Software: Dockerised ROS 2 Jazzy & Dockerised CV packages
  • Role: Asynchronous Perception.
  • Function: NPU-accelerated inference (YOLO/Object tracking) and sensor fusion.
  • Connectivity: Native Zenoh integration via rmw_zenoh_cpp. Publishes environment states and "Conditions" to the Zenoh network.

Licenses & papers

Sowbot / feldfreund_devkit_ros — Dependency Licence Audit

ComponentSourceLicenceCommercial useAcademic PaperNotes
feldfreund_devkit_ros (root)your repoMIT (©Zauberzeug GmbH & Agroecology Lab)✅None (Local Project)Derivative of upstream field-friend; retain Zauberzeug notice
devkit_driverlocalMIT (©ATB)✅None (Utility Driver)Retain ATB copyright notice
devkit_uilocalMIT (©Agroecology Lab)✅None (UI Extension)
devkit_bringuplocalMIT✅None (Config/Launch)Corrected from proprietary
sowbot_row_followcaatingaroboticsBSD-2-Clause✅de Silva et al., 2024LICENSE file fixed to match header/metadata; updated to use the Transition State Model (TSM) for visual crop row navigation; ©PRBonn + ©Agroecology Lab
caatingarobotics (devkit_simulation, caatinga_nav, caatinga_vision)github.com/samukApache-2.0✅None (Fork Infrastructure)Your fork (row_follow is the BSD-2 exception, above)
topological_navigationLCAS (aoc_refactor)Apache-2.0 (©LCAS)✅Fentanes et al., 2015High-level planner; derived from the EU STRANDS long-term autonomy project framework
fusioncoremanankharwarApache-2.0✅Kharwar, 2026GNSS fusion; patched in-build; retain NOTICE if present
Forest3DunitsSpaceLabGPL (©UNITS Space Lab)Do not ship in final productCottiga,S., Bourr, K., & Seriani, S. (2026)Sim-only — 3D forestry /agriculture simulation environment
ublox_dgnssaussierobotsApache-2.0✅None (Hardware Driver)GNSS driver
sentorLCAS (fork of francescodelduchetto/sentor)MIT✅None (Monitoring Tool)Topic- and node-monitoring health node
ros2graph_explorernilseuropaBSD-3-Clause✅None (Debug Tool)Dev/debug graph inspector
Fields2Cover v2.0.0Fields2CoverBSD-3-Clause✅Mier et al., 2023Built from source; pulls OR-tools (Apache-2.0) + GDAL (MIT)
lizardAgroecology-LabMIT (©Zauberzeug GmbH)✅None (Firmware Tool)ESP32 tooling; retain Zauberzeug notice
YOLOX 0.3.0 + yolox_nano weightsMegviiApache-2.0✅Ge et al., 2021Confirm weights terms for commercial use
PyTorch (CPU)MetaBSD-3-Clause✅Paszke et al., 2019Core machine learning runtime engine

===============================================================

Feldfreund DevKit ROS

(Below from original Zauberzeug forked repo)

Feldfreund DevKit ROS is a comprehensive ROS2 package that handles the communication and configuration of various Feldfreund components:

  • Communication with Lizard (ESP32) to control the Feldfreund
  • GNSS positioning system
  • Camera systems (USB and AXIS cameras)
  • Example UI to control the robot

All launch files and configuration files (except for the UI) are stored in the devkit_bringup package.

Components

DevKit driver

The DevKit driver (based on ATB Potsdam's field_friend_driver) manages the communication with the ESP32 microcontroller running Lizard firmware - a domain-specific language for defining hardware behavior on embedded systems.

The package provides:

  • config/devkit.liz: Basic Lizard configuration for DevKit robot
  • config/devkit.yaml: Corresponding ROS2 driver configuration

Available ROS2 topics:

  • /cmd_vel (geometry_msgs/Twist): Control robot movement
  • /odom (nav_msgs/Odometry): Robot odometry data
  • /battery_state (sensor_msgs/BatteryState): Battery status information
  • /bumper/front_top (std_msgs/Bool): Front top bumper state
  • /bumper/front_bottom (std_msgs/Bool): Front bottom bumper state
  • /bumper/back (std_msgs/Bool): Back bumper state
  • /estop/soft (std_msgs/Bool): Software emergency stop control
  • /estop/front (std_msgs/Bool): Hardware front emergency stop state
  • /estop/back (std_msgs/Bool): Hardware back emergency stop state
  • /configure (std_msgs/Empty): Trigger loading of the Lizard configuration file

Camera System

The camera system supports both USB cameras and AXIS cameras, managed through a unified launch system in camera_system.launch.py that handles USB cameras, AXIS cameras, and the Foxglove Bridge for remote viewing.

The USB camera system provides video streaming through ROS2 topics using the usb_cam ROS2 package. Camera parameters can be configured through config/camera.yaml.

The AXIS camera system integrates with the ROS2 AXIS camera driver to support multiple IP cameras with individual streams. Each camera can be configured through config/axis_camera.yaml, with credentials managed through config/secrets.yaml (template provided in config/secrets.yaml.template). The cameras' authentication mode (basic or digest) might need to be configured - see AXIS Camera Authentication section for details.

The visualization system integrates with Foxglove Studio for remote camera viewing, supporting compressed image transport. The Foxglove Bridge is accessible via WebSocket connection on port 8765.

GNSS System

The GNSS system uses the Septentrio GNSS driver with the default config/gnss.yaml configuration. Available topics:

  • /pvtgeodetic: Position, velocity, and time in geodetic coordinates
  • /poscovgeodetic: Position covariance in geodetic coordinates
  • /velcovgeodetic: Velocity covariance in geodetic coordinates
  • /atteuler: Attitude in Euler angles
  • /attcoveuler: Attitude covariance
  • /gpsfix: Detailed GPS fix information including satellites and quality
  • /aimplusstatus: AIM+ status information

DevKit UI

The example UI provides a robot control interface built with NiceGUI, featuring a joystick control similar to turtlesim. It gives you access to and visualization of all topics made available by the DevKit driver, including:

  • Robot movement control through a joystick interface
  • Real-time visualization of GNSS data
  • Monitoring of safety systems (bumpers, emergency stops)
  • Software emergency stop control

The interface is accessible through a web browser at http://<ROBOT-IP>:80 when the robot is running.

Example UI Screenshot
Example UI: Control, data, safety, and GPS map in one interface.

Docker Setup

Using Docker Compose

  1. Build and run the container:
cd docker
docker-compose up --build
  1. Run in detached mode:
docker-compose up -d
  1. Attach to running container:
docker-compose exec devkit bash
  1. Stop containers:
docker-compose down

The Docker setup includes:

  • All necessary ROS2 packages
  • Lizard communication tools
  • Camera drivers
  • GNSS drivers

Connect to UI

To access the user interface (UI), follow these steps:

  1. Connect to the Robot's Wi-Fi: Join the robot's WLAN network.

  2. Open the UI in your browser: Navigate to:

    http://<ROBOT-IP>:80

    (Replace <ROBOT-IP> with the actual IP address once you have it.)

Launch Files

The system can be started using different launch files:

  • devkit.launch.py: Launches all components
  • devkit_nocams.launch.py: Launches all components without the cameras
  • devkit_driver.launch.py: Launches only Feldfreund DevKit driver
  • camera_system.launch.py: Launches complete camera system (USB + AXIS) and Foxglove Bridge
  • usb_camera.launch.py: Launches USB camera only
  • axis_cameras.launch.py: Launches AXIS cameras only
  • gnss.launch.py: Launches GNSS system
  • ui.launch.py: Launches the example UI node

To launch the complete system:

ros2 launch devkit_bringup devkit.launch.py

AXIS Camera Authentication

The AXIS cameras can be configured to use either digest or basic authentication. To check and configure the authentication mode:

  1. Check current authentication settings:
curl --digest -u root:pw "http://192.168.42.3/axis-cgi/admin/param.cgi?action=list&group=Network.HTTP" | cat
  1. Switch authentication mode (e.g., from digest to basic):
curl --digest -u root:pw "http://192.168.42.3/axis-cgi/admin/param.cgi?action=update&Network.HTTP.AuthenticationPolicy=basic" | cat

Replace root:pw with your camera's credentials and 192.168.42.3 with your camera's IP address. The authentication mode can be set to either basic or digest. Note that you should always use the --digest flag in these commands even when switching to basic auth, as the camera's current setting might be using digest authentication.

Quickstart guide

1. Clone the Repository

git clone https://github.com/zauberzeug/devkit_ros.git
cd devkit_ros

2. Validate Configuration

Before building, check and adjust if needed:

  1. ROS2 Configuration (devkit_bringup/config/devkit.yaml):

    • Verify serial_port matches your setup (default: "/dev/ttyTHS0")
    • Check flash_parameters for your hardware (default: "-j orin --nand")

  2. Lizard Configuration (devkit_bringup/config/devkit.liz):

    • Verify motor configuration matches your hardware
    • Check pin assignments for bumpers and emergency stops
    • Adjust any other hardware-specific settings

3. Build with Docker

./docker.sh u

4. Send Lizard Configuration

Once the system is running:

  • Use the "Send Lizard Config" button in the UI
  • Or use the /configure topic in ROS2

5. Ready to Go

Check the UI at http://<ROBOT-IP>:80 to control and monitor your robot.

Future features

This repository is still work in progress. Please feel free to contribute or reach out to us, if you need any unimplemented feature.

  • Complete tf2 frames
  • Handle camera calibrations
  • Robot visualization