Autonomous
Zero-Turn Mower

The full machine, in your browser

Every component is modeled to the datasheet as one parametric assembly. This is the real exported geometry — drag to rotate, scroll to zoom. The retrofit hardware bolts onto a confirmed Gravely ZT X 52 (2021, Kohler), itself spec-matched to the FULL published envelope — 1968 × 1610 × 1039 mm, 1321 mm deck, treaded 20×10-8 drive tyres — with the GRAVELY and ZT X 52 lettering modeled as raised geometry, not a texture. The deck is hollow like the real one: hover the machine and the three 460 mm blades spin on their spindles — and the Phase-3 rig (power bagger, blower/trimmer boom, tow sprayer) rides along; pull the exploded-view slider to see every subsystem fly out.

Three brains, one bus

Not one black box — responsibility is split across compute that's purpose-built for each job, coordinating over MAVLink. A real-time flight controller drives and navigates; a Linux companion sees; a microcontroller closes the analog steering loop the autopilot can't.

The interface, not a screenshot

This is the actual planned control UI — one web app that serves both the iPad over WiFi and the on-unit touchscreen. It's embedded here running on an in-browser telemetry simulator, so it arms, drives a coverage route, draws the mowed trail, and reacts to live hazards in real time. Tap the controls — they work.

Centimeters, not "close enough"

The upgrade that matters is dual-antenna moving-baseline heading. One RTK antenna gives a great position but a noisy heading at a standstill; a second antenna fixes heading geometrically, so the machine tracks straight rows from the moment it starts.

A layered kill chain

A 52" deck can kill. Safety isn't one switch — it's independent layers that each cut drive and blades, so no single failure leaves the machine moving. Blades stay disconnected until every layer is proven.

Every pin accounted for

The kill chain gets wired and tested first, then power, then signal. Each branch has its own fuse; every ground returns to one bus. This is the map — verbatim from docs/WIRING.md and the lapbar_controller.ino pin defs.

+12 VGND5 Vsignal / data

MowerCarrier — a board for the messy part

The wiring above is a rat's nest to build by hand — and the safety kill-chain is the last thing you want to get wrong twice. So it becomes one 2-layer board: the 30 A power tree, reverse-polarity + load-dump protection, the two 40 A safety relays, and the ESP32 lap-bar controller — every module plugs in by connector. The proven modules (Pixhawk, Pi, buck, BTS7960) stay off-board; the board is the glue, power, and safety. Full design package — schematic, placement, netlist, verified BOM — in hardware/pcb/.

+12 V+5 V+3V3signalGND

The safety gate

Each 40 A relay energises only when the E-STOP is closed (coil high side) and the controller commands it on (coil low side, via a MOSFET). Either one dropping cuts motor power instantly — a hardware button press and a software fault both kill it. A second E-STOP contact signals the ESP32 for fail-to-neutral.

Honest scope

This is a real, fabricable design package — ready to open in KiCad, drop the BOM parts on, and route. The BOM has verified LCSC/JLCPCB part numbers with the tricky bits flagged (P-FET thermals, ESP32 header pitch, load-dump TVS). Rev B ships Gerbers + a one-click JLCPCB order.

Netlistevery net ↗ BOMLCSC parts ↗ Fab guideKiCad → JLCPCB ↗

Parametric · print-ready · reproducible

The entire mount system is one OpenSCAD model. Section 1 of params.scad holds the only per-machine measurements — change those and re-render to fit a different zero-turn. Every printable part is bed-fit checked and ships with a baked-in adhesion brim.

Full assembly — isometric · brain box, GPS masts, LiDAR, cameras, e-stop

Side profile — sensor sightlines

Front — camera + LiDAR mast

Rear — dual GPS baseline

Under the hollow deck — 3 × 460 mm blades on their spindles

Seat-mounted brain box

E-stop pedestal · PTO relay

RPLidar front-mast mount

RTK antenna mast

Built and tested, end to end

Full itemized order sheet with live prices lives in cart/ORDER.md (machine-readable ORDER-SHEET.csv). ArduSimple ships from the EU; bundle the Holybro and PiShop orders to save on shipping.

Building the obstacle brain

Off-the-shelf detectors know "car" and "dog" — they don't know a garden hose, a sprinkler head, or a child's toy left in the grass, and they can't tell you how far. So the perception model is trained for this job: what's in a yard, is it in my path, and how many meters away — small enough to run entirely on the Hailo-8L, no cloud.

How the model gets trained

No hand-labeling thousands of images. The machine labels its own data: every teach-and-repeat run records camera frames with a time-synced LiDAR scan, and the LiDAR does the hard part — it already knows where the solid things are.

Vision is one voice, never the only one — every stop is cross-checked against the LiDAR and ultrasonic, and the blade stays disconnected until the model is proven in the field. See software/companion/vision.py.

Small, pure, testable

The parts that can hurt someone are pure functions with no hardware in them, so they're unit-tested off the machine — 25/25 green. The safety interlock, the vision verdict, the fail-to-neutral loop, and the MAVLink mission encoder, verbatim from the repo.

def evaluate(s):
    """(state) -> (allow_move, reason). Single most important blocker,
    checked in strict priority order. Pure + unit-tested."""
    if s.get("estop"):
        return False, "E-STOP"
    slope = slope_of(s.get("roll"), s.get("pitch"))
    if slope > MAX_SLOPE_DEG:               # 15 deg rollover cutoff
        return False, f"too steep ({slope:.0f} deg)"
    oh = s.get("overhead_m")
    if oh is not None and oh < MIN_OVERHEAD_M:
        return False, f"low branch ({oh:.1f} m)"
    if s.get("obstacle"):
        return False, "obstacle ahead - holding"
    return True, None

def evaluate(detections):
    """PURE. detections: [{cls, conf, box:[cx,cy,w,h]}...]
    -> (obstacle, range_m, objects, grass_pct)."""
    hazards = [d for d in detections
               if d["cls"] in HAZARD and d["conf"] >= CONF_MIN
               and _in_stop_zone(d["box"])]
    if hazards:
        nearest = max(hazards, key=lambda d: d["box"][1])   # largest cy = closest
        range_m = round((1.0 - nearest["box"][1]) * 6.0 + 0.4, 1)
        return True, range_m, objects, grass_pct
    return False, None, objects, grass_pct

void loop() {
  bool estop = digitalRead(PIN_ESTOP);          // HIGH = NC opened
  bool lostL = (now - lastEdgeL) > FAILSAFE_MS; // FC signal lost?
  bool fail  = estop || lostL || lostR;
  // fail -> command bars to CENTER, then cut the bridges (coast to neutral)
  int tgtL = fail ? (POT_L_MIN+POT_L_MAX)/2 : targetFromPwm(pulseL);
  if (fail) {
    drive(step(pidL, tgtL, potL));              // PID toward neutral
    if (centered) disableAll();                 // FAIL-TO-NEUTRAL
  }
}

def to_mission_items(waypoints):
    """[[lat,lon]...] -> MISSION_ITEM_INT (NAV_WAYPOINT).
    lat/lon scaled to 1e7 ints as MAVLink requires. Unit-tested."""
    return [dict(seq=i, command=MAV_CMD_NAV_WAYPOINT,
                 current=1 if i == 0 else 0, autocontinue=1,
                 lat=int(round(lat * 1e7)),
                 lon=int(round(lon * 1e7)), alt=0.0)
            for i, (lat, lon) in enumerate(waypoints)]

Engineered with an AI agent loop

A build this broad — mechanical, electrical, firmware, ML, safety — normally takes a team. It was done solo by driving AI agents hard and precisely: decomposing the problem, constraining every prompt, and verifying the output instead of trusting it. The prompt engineering was the multiplier.

You are sourcing the linear actuators for a bladed outdoor robot.
Constraints: 12V, ≥150 lbf, ≥100mm stroke, IP65+, with a
position-feedback potentiometer (closed-loop steering). Verify each
part on its live page - never invent an ASIN or a spec. Return a
table: part, real link, price-read-off-page, and the one spec that
would disqualify it. # flagged the PA-14P: genuine IP54, not IP66 -> needs a rod boot

Write the LiDAR mount in OpenSCAD, fully parametric off params.scad.
The RPLidar A1M8 base is a teardrop 96.74 x 70.28 mm with a
4-hole trapezoid bolt pattern - NOT 3 holes on a circle
(verify against the datasheet drawing). It must split to fit the
150 mm bed and print without supports. # caught: my first pass
assumed 3 holes on a bolt circle - the datasheet drawing showed a 4-hole trapezoid.

After every STL export, run export_stl.sh and reject any part whose
bounding box exceeds 145 mm on any axis. Don't eyeball it - fail the build
and tell me which part and by how many mm. # this gate caught the
equipment plate at 179.5 mm and the e-stop pedestal at 145.1 mm before they ever printed.

The pattern throughout: tight constraints in, structured output back, an automated or adversarial check before it counts. That's what let one person carry a multi-subsystem robotics build end-to-end.

Every number that matters

The whole kit is parametric off one file — so it has to be exact. These are the real, sourced dimensions the CAD is built from: the machine, the parts that bolt to it, and the tolerances the printer actually holds. Change SECTION 1 of params.scad and it re-fits any zero-turn.

Standing on real hardware

No black boxes — every subsystem is a known, documented, buy-it-today component. Logos link to the makers; brand marks via logo.dev.

Gravelythe machineRaspberry PiPi 5 + camerasHailo8L · 13 TOPS NPUHolybroPixhawk 6C · PM02ArduPilotRover firmwareu-bloxZED-F9P RTKArduSimplesimpleRTK2BSlamtecRPLidar A1M8EspressifESP32Adafruitparts + guides

Designed in the open — every wrong turn logged

Nothing here was right the first time. The loop is model → render → measure against the spec sheet → find what's wrong → fix → re-export, and every iteration maps to a real commit. The full log — including the constraints A–Z that actually bit — lives in docs/DESIGN-LOG.md.

From files to metal

Every CAD source, drawing, and supplier is researched, verified, and logged — so the build is buildable by anyone. The retrofit parts print in ASA/PETG today; the same files go out to a metal shop when it's time to machine them in aluminium. Full sourcing sheet in docs/SOURCING-AND-FABRICATION.md.

Component CAD — official, free downloads

Base machine — parts diagrams & manuals

No exact ZT X 52 CAD is published, so brackets are modeled from the OEM exploded parts diagrams + measured critical dims (the CAD's SECTION 1 params).

Machined in metal — instant-quote suppliers

Flat parts (e-stop face, relay lid, plates) go out as DXF for laser cutting (cad/dxf/); 3D mounts as STEP solids for CNC (cad/step/, generated from the STLs by stl_to_step.py). General tolerance ISO 2768-m / ±0.005″; anodize for outdoor.

Prototype plan: flat brackets as DXF at OSH Cut + 3D mounts as STEP at SendCutSend / Protolabs — or the whole 24-part mixed order through SendCutSend / eMachineShop (US, no minimum).

Fabrication package — ready to send

The full quote package is generated and downloadable: 8 flat parts as DXF, 8 dimensioned drawing PDFs (title block, material, tolerance, finish), and 16 CNC parts as solid STEP — machinable geometry, not raw mesh. Grab everything in one click, or pick individual files, then upload straight into any supplier's instant quoter.

Ballpark cost (public instant-quote rates, 6061-T6, qty 1, prototype — indicative, not a live quote):

Numbers are indicative of published SendCutSend / OSH Cut / Xometry rates — a binding price needs the files run through the supplier's own quoter under an account (a manual, human-in-the-loop step, not automated here). Every file above is upload-ready today.

One brain, every yard tool

Once the machine holds ±2 cm lines at a controlled speed, every implement inherits that precision. Mowing was the beachhead — the same navigation stack now carries a self-dumping power bagger, a rotating blower + string-trimmer boom, a 30-gal tow sprayer with speed-perfect application, TPMS on all four tyres, and an ignition sequence so the machine starts itself. Design + tested policy layer today, hardware with the build — spec in docs/ATTACHMENTS.md.

Build videos — rails ready, camera pending

One short video per build phase lands here as the physical build progresses. The design is done on screen; this section is where it gets real.

The questions everyone asks

Build it yourself — or scale it

The whole project is open source under the MIT License — CAD, firmware, control software, the carrier PCB, wiring diagrams, and the build manual. Most open-source mowers convert a toy robot-mower; this retrofits a 615 lb commercial gas zero-turn — which is what makes it reproducible on any ZTR and opens a path toward robot-mowing-as-a-service for commercial grounds and solar-farm vegetation management.