Skip to content

Straddling robot demo

A portal field robot driving every row of a generated vineyard: a leg in the alley either side of the row, the trellis passing under its frame. The navigation path is derived from the USD. No sensor input is used in this demo.

Contents: Requirements · Running the demo · Recording the video · What it shows · Trimming · The robot · Layout

Requirements

  • uv installed
  • Isaac Sim 6.2 compatible hardware
  • Rust installed (this demo builds the scene generator from source)

Running the demo

uv run main.py

The first run generates the vineyard and converts the robot, and caches both; later runs start straight up. --help lists the launcher's options — --row picks the row it starts on, --physics the backend and --viz the viewer.

The default backend is Newton coupled with VBD, the one solver that bends the vineyard's flexible shoots as the frame pushes through them. Any other -- --physics newton_mjwarp for the robot alone at near real time, or a PhysX backend -- spawns the stray shoots static, at the same lean.

Recording the video

./record.sh

films the robot driving down a row of the default scene with a third of its shoots strayed into the alleys, from behind and above it, in Isaac Sim's RTX renderer and headless, and writes target/video/straddler.mp4 at the repo root, small enough to upload, and a contact sheet beside it. The shot and its length are the top of video.py. docs/video/publish.sh target/video/straddler.mp4 examples/straddler_demo/README.md, run from the repo root on the branch whose pull request changes the video, uploads it to that pull request and puts it on this page.

What it shows

The robot has four swerve modules — a steering joint about the vertical and a drive joint through the wheel centre — which means it never has to turn around. It holds the row heading for the whole run, drives alternate rows in reverse, and crabs sideways across the headland to line up on the next row. That is what the machine is for: a gantry that turned round would have to put its legs somewhere, and either side of it is a vine.

The route is read off the generated scene's own trellis posts, so it re-solves whenever the vineyard parameters change. So does the robot: for_vineyard takes the track from the row spacing and the frame height from the trellis height, and the robot is built at that size.

The route closes on itself — down every row, then back the way it came — so --row rotates where the drive begins rather than shortening it, and the whole block is covered whichever row it starts on.

Trimming

uv run main.py --trim

--trim hangs a hedger under the frame: an upright cutter bar either side of the row, 0.4 m out from it, reaching from 0.3 m above the ground to the frame. Every stray shoot that crosses a bar's plane is cut right where it crosses, and the piece past the cut falls and lies where it lands. The vineyard it drives has more strays than the plain demo, so there is something to trim on every row.

That is how summer hedging is done: cutter bars on a frame over the row trim the canopy's sides back to a plane, sickle bars at 3–4 km/h and rotary knives at 5–6, about the pace this robot drives at. A real hedger cuts the whole canopy face. Here the shoots the trellis holds are static meshes, so the bars sit just outside them and cut only the flexible strays.

Trimmer in straddler.py holds the bars' reach, bottom, width and thickness. The cut itself is misina_lab.isaaclab.cutting, which any script can use on a running simulation:

from vinery_lab.isaaclab import Shears

shears = Shears()                           # after sim.reset()
shears.cut_through(corner, along, up)       # every rod crossing a rectangle
shears.cut(body, 0.4)                       # one rod body, 40% along it

A cut between two joints shortens the capsule it lands on and stretches the next one back to meet it, so a shoot comes apart exactly at the knife, not at the nearest joint. Only values in the model change, never its size, so the cut runs under the CUDA graph that steps the simulation.

The robot

Straddler is a dataclass of dimensions, and straddler.py generates a URDF from it, so every one of them moves:

Straddler(track=1.80, clear_height=2.35, leg_thickness=0.10, mass=1700.0)
Straddler.for_vineyard(VINEYARD_CFG, clearance=0.3)
dataclasses.replace(PRESETS["bakus_s"], mass=900.0)

The defaults are a bare frame on wheels — a 1.2 m track, 0.4 m wheels, 160 kg — and the range each dimension is worth moving inside is the commercial portals': 1.1–2.0 m of track, openings 1.4–2.35 m high, 0.10–0.25 m of leg between a wheel centre and the opening, 0.86 m wheels, and 500–2400 kg with a tank and tools aboard. PRESETS holds four of those machines at their published figures — VitiBot Bakus S and L, Naïo Ted 180 and 235 — to drive, and to check the generator against: an opening that stops coming out at the published width means the frame below it is built wrong.

The geometry is primitives — boxes for the frame and the legs, cylinders for the wheels — so there is no manufacturer's description in here to be bound by.

Layout

file what it owns
main.py the vineyard, the sky, the robot, the simulation loop, the trimming
straddler.py the robot: its dimensions, the URDF built from them, the actuators, the trimmer
route.py waypoints down every row, read off the trellis posts
driver.py waypoint following and swerve kinematics
video.py, record.sh the video: the robot driving down a row, filmed headless, and its encoding

DEVELOPMENT.md in ../isaaclab_demo covers the pinned Isaac Lab release, which this example shares.