← All projects

01 · Robotics · 2026

AMR

Autonomous 3D mapping and weld inspection

Put it in a warehouse and it explores on its own, mapping the entire floor in 3D. Then it goes to work. It drives itself to every zone with welds to inspect, scans each weld with a gimbal-mounted camera that refocuses in milliseconds, sends the images back and moves on to the next zone, with no one at the controls. This is how a bare tracked chassis became that robot.

In active development

Role
Robotics engineer
Started
August 2026
Status
Ongoing
Runs on
NVIDIA Jetson Orin Nano, on board

Exploded view · 11 parts

Anatomy of autonomy

Eleven parts, one mission: explore a floor no one has mapped, then inspect it with no human in the loop. A tilted 3D LiDAR maps every surface it passes. An NVIDIA Jetson plans each route and runs the AI driver on board. A gimbal aims the inspection camera at each weld, and an encoder board holds both tracks within 1% of their target speed.

Scroll to take it apart. Pick any part to see what it does, zoom in for a closer look, or switch to V2 to see the weld-inspection camera.

Chassis from its CAD file · parts on top modelled to match · cables left out

Exploded 3D model of the AMR: camera, LiDAR, gimbal, LiDAR mount, Raspberry Pi, battery, deck, Jetson, encoder board, motors and tracked chassis pulled apart.
  1. Rides on the pan-tilt gimbal, so the robot can look wherever it needs to as it drives. Frames from it are rebuilt into photo-realistic 3D models of the spaces it visits.

    In the story · 06 Seeing in 3D →

    V2 · Weld-inspection build

    A machine-vision box camera with a liquid lens. Instead of a motor sliding glass back and forth, a voltage reshapes the lens itself, so focus jumps from one distance to the next in milliseconds and every weld stays sharp as the gimbal moves. Each image is sent back as soon as it's captured.

    In the story · 08 Inspecting welds on its own →
  2. The robot's main sense. It scans in 3D 12 times a second, and its built-in motion sensor lets FAST-LIO2 stitch those scans into a live 3D map of the whole floor, with the robot's own position on it.

    In the story · 02 Giving it senses →
  3. Aims the camera. The newest AI driver steers it together with the tracks, deciding where to look while it drives, and reaches every goal in 93.8% of runs in a narrow-corridor test. On an inspection run, it points the camera at each weld.

    In the story · 07 Aiming its own camera →
  4. Tilts the LiDAR 30° down so it sees the floor just ahead of the tracks. Fitting the floor on every scan, instead of trusting a one-time measurement of this angle, eliminated a 3–4° drift for good.

    In the story · 02 Giving it senses →
  5. A second computer dedicated to the gimbal. It takes aiming commands from the Jetson over the network and drives the two servos.

    In the story · 07 Aiming its own camera →
  6. Powers every sensor, computer and motor on board, so the robot runs with no cable from its first scan to its last weld.

  7. A slotted plate on brass standoffs over the hull. The LiDAR, battery and gimbal ride on top; the Jetson and the encoder board sit protected underneath.

  8. Runs the whole robot on board: 3D mapping, route planning, the AI driver, the safety layer, the inspection mission and the web console. Moving the route planner onto its own thread made re-planning 89× faster for the control loop and lifted the loop from 30 Hz to 51 Hz.

    In the story · 04 Crossing from simulation to reality →
  9. The Jetson sends it a target speed for each track. It works out the power each motor needs and reads the motors' encoders to hold every track within 1% of that speed. The same encoder counts tell the AI driver how fast the robot is really moving.

    In the story · 03 Teaching it to drive →
  10. Geared motors with encoders, one per track. I measured their real top speed, how far the robot coasts and how it pivots, and built the training simulator around those numbers.

    In the story · 03 Teaching it to drive →
  11. Steers like a tank, by running its two tracks at different speeds, on sprung road wheels that ride over uneven floors. Top speed 0.36 m/s.

    In the story · 02 Giving it senses →

Exploded view

Sense, think, move

Sensors ride on top, the computers sit in the middle and the drivetrain runs underneath. Pick any part to see what it does and where it appears in the story.

1.0×

Run an inspection mission

A simplified, in-browser version of the console the real robot serves from its own computer. It starts an inspection run as soon as it's on screen, working through the floor zone by zone and scanning the welds at each stop. The map is an occupancy grid like the robot's: black is what the LiDAR has seen, grey is unknown, and the blue band is the clearance the planner keeps.

  • Inspection run. Watch it drive itself from zone to zone, scan each one and move on. Click anywhere on the map to take over.
  • Send to goal. Click any spot and it plans a route and drives there. Click too close to an obstacle and it moves the goal clear, just like the robot.
  • Drive. Hold the arrows, or use the arrow keys. The safety layer won't let you drive into anything, whoever is in control.
  • Add obstacle. Drop something it doesn't know about. It isn't on the map until the LiDAR sees it, and then the robot reroutes around it.

At a glance

Built to work alone

96.5%of test runs reached every goal
94.5%of test runs never touched an obstacle
89×faster route planning on the robot
51 Hzcontrol loop, up from 30 Hz

Point it at a floor and let it go. It explores unknown space on its own and builds a 3D map of everything it passes. Give it the zones that hold welds and it plans a route through them, drives itself from one to the next and scans every weld in each zone with its gimbal camera, sending the images back as it captures them. Under the hood, an AI driver sets the speed of each track about a dozen times a second, and a safety layer can always overrule it: an emergency stop, sensor watchdogs and a hard block on driving into anything.

Test runs: 200 runs at fixed difficulty in a cluttered room with partitions and alcoves, 3–5 goals each.

Body
Tracked base, 30 × 19 cmTop speed 0.36 m/s; drives at up to 0.31 m/s
Mission
3D floor mapping and weld inspectionZone to zone with no operator; images are sent back as they're captured
Senses
Unitree L2 3D LiDAR and a RealSense depth cameraV2 swaps the gimbal camera for a liquid-lens inspection camera the robot aims itself
Brain
NVIDIA Jetson Orin Nano, on board3D mapping, planning, the AI driver, the mission and the web console all run on the robot
Software
Python, PyTorch, ROS 2, FAST-LIO2, YOLO11Driver trained with reinforcement learning in a GPU simulator I wrote

The journey

From a bare chassis to an autonomous inspector

  1. Early August 2026

    The mission: go anywhere, see everything, report back

    Industrial inspection still runs on people walking the floor: checking welds, counting stock, confirming an aisle is clear. It's slow, it's repetitive, and it's exactly the kind of work a robot should own.

    Underneath every one of those jobs is the same skill: reach any spot on your own, touch nothing on the way, and capture what's there. I started by prototyping an AI driver in NVIDIA Isaac Lab and testing it in a phone-scanned copy of a real room it had never trained in.

    What I foundCheck the test before blaming the model. Two unfair setups in my test were hiding real progress. Fixing them tripled the prototype's score in the held-out room.

  2. August 8–12

    Giving it senses

    I built the robot around a small tracked chassis, a 3D LiDAR on top and an NVIDIA Jetson as its brain. FAST-LIO2 fuses the LiDAR with an inertial sensor into a live map with the robot's own position on it, and a route planner finds the way to any goal on that map. On its best early run, the path it drove was only 2% longer than a straight line.

    Then I hunted down the quiet bugs, the kind that produce believable output that's wrong. The LiDAR's 30° downward tilt hid obstacles from the planner. The position it reported was the sensor's, not the robot's, so every on-the-spot turn swung it by 11.6 cm. And the sensor sat 5° off the robot's axis. All three are fixed.

    What I foundMeasure constants from the data, on every scan. A mounting angle I measured once had drifted by 3–4°. Fitting the floor plane on every scan fixed it for good.

  3. August 13–22

    Teaching it to drive

    Hand-written driving rules break the moment a space gets cluttered, so the robot learns to drive instead. I wrote my own GPU simulator in PyTorch, built from the robot's measured physics: its real top speed, how far it coasts, how its tracks pivot, how late its position arrives. The AI driver practises in endlessly varied rooms, sees the world exactly as the robot does (50 LiDAR rays across the front, 13 sectors behind) and makes a decision about 12 times a second.

    Every training run has to earn its compute. Before one starts, a scripted expert driver must pass the same test. If a hand-built driver can't do the task, a learned one won't either, so the gate catches a broken task before it wastes a run.

    What I foundWhere training settles is a design choice. Letting practice rooms outgrow the driver's skill made it bump into things in 77% of runs. Capping the difficulty cut that to about 17% and produced the driver that runs on the robot today.

  4. August 23–24

    Crossing from simulation to reality

    On the real robot, the driver that aced the simulator spun in circles, turning up to 439° for every metre it drove. Rather than retrain and hope, I recorded everything the robot sensed and compared it, channel by channel, with what it saw in simulation.

    Five faults surfaced, one after another. Its sense of its own turning was estimated from its commands rather than measured, and its position arrived about 300 ms late. The mapping software deleted everything within 30 cm. Phantom obstacles caged it inside its own map. Part of the obstacle sensing read the carpet as an obstacle 90% of the time. And the route planner was hogging the control loop, so for two-thirds of the drive the AI driver wasn't running at all.

    With the carpet fixed, it reached 38% of its goals. With the planner fixed too, the same trained driver reached 100% of them that afternoon. No retraining.

    What I foundA planner on the control thread is a driver that isn't running. The simulator plans in zero time; the real robot doesn't. Moving the planner to its own thread did more than any retrain could have.

  5. August 25 – September 2

    Training for the spaces it actually works in

    The real test space was a corridor 2.44 m wide, but the narrowest practice room in the simulator was 3 m, so not one training room looked like the place it actually had to drive. I added rooms down to 1.8 m wide, taking corridor-width rooms from 0% of practice to 29%.

    I also moved the robot's safety layer, and its habit of clearing map cells it has driven over, into the simulator, so the driver practises under the exact rules it lives by.

    What I foundPut every input from a real drive next to the same input from simulation. That one habit exposed both the carpet problem and the corridor gap.

  6. September 3–6

    Seeing in 3D

    With driving solid, I gave it better eyes. A RealSense depth camera adds colour 3D, and the LiDAR builds a live 3D map that erases things once they've moved away. A box detector trained on about 53,000 images from 27 datasets finds boxes with 93% mAP50 on held-out images. Frames from the robot's camera can also be rebuilt into a photo-realistic 3D model of the space (a Gaussian splat) that you can explore on a phone.

    All of it runs from a web console the robot serves itself. Tap a spot to send it there, drive with a thumb joystick, fence off keep-out zones, let it explore unknown space on its own, and save maps by name for later missions.

  7. September 2026

    Aiming its own camera

    The newest driver steers a pan-tilt gimbal as well as the tracks, so it decides where to look while it drives. In a harder narrow-corridor test it reaches every goal in 93.8% of runs.

    Building it also exposed a bug that had been hiding in the simulator for two weeks: its map-clearing was mirrored. Fixing it lifted the scripted expert from 71.6% to 85.9% on a harder test level. The new driver is now being tuned on real floors.

    What I foundA test that shares a bug's assumptions can't see the bug, and a test that doesn't exist never fails.

  8. Now

    Inspecting welds on its own

    Everything above comes together in one mission. The robot explores the warehouse and maps the entire floor in 3D. Then it works through every zone that holds welds: it drives itself to the zone, sweeps the gimbal across each weld, captures it and sends the images back, then moves on to the next zone. Zone after zone, unsupervised.

    The camera is built for the job. The V2 build carries a machine-vision box camera with a liquid lens. Instead of a motor sliding glass back and forth, a voltage reshapes the lens itself, so focus jumps from one distance to the next in milliseconds. As the gimbal swings between welds near and far, every image is already sharp.

    See the V2 camera in the exploded view

Missions

One robot, many missions

Reaching any spot on its own, avoiding everything in the way and capturing what's there is a universal skill. Weld inspection is where it starts.

On the robot Tested in software Next

  • On the robotWeld inspection, zone to zone

    Drives itself to each zone with welds to inspect, scans every weld with the gimbal camera, sends the images back and moves on to the next zone.

  • On the robotMap an entire floor in 3D

    Explores unknown space on its own and builds a 3D map of the whole floor, saved for later missions or rebuilt as a photo-realistic 3D model.

  • On the robotDrive to any spot and scan

    Pick a spot on a saved map. It plans the route, drives there around whatever is in the way and captures a colour 3D scan of what it finds.

  • On the robotRemote inspection

    Drive it by hand from a phone to check a spot that's hard to reach or unsafe to walk to.

  • Tested in softwareFind and inspect boxes

    The detector spots boxes, the robot places each one on its map, plans views of up to five sides and drives to each.

  • Tested in softwareGesture commands

    "Follow me", "point to go", "scan and store" and "stop", read from a person's hand and body pose.

  • NextInventory cycle counts

    Drive a route of shelves on a schedule, read each label or barcode and reconcile the counts with the inventory system.

  • NextAisle and safety patrols

    Walk the floor after hours and log blocked aisles and exits, spills and pallets left in walkways.

  • NextBeyond the warehouse

    Weld and structural inspection in factories, shipyards and construction sites, rack audits in data centres, out-of-stock checks in retail, supply runs in labs and hospitals, and overnight security rounds.

What's next

Where it's going

Still in progress

I'm still building this

AMR is an active build. These are the next milestones, and this page will grow as they land.

  • Grade each weld on the robot itself, flagging defects the moment they're captured.
  • Feed the depth camera into driving and route planning, so it catches low and thin obstacles the LiDAR can miss.
  • Handle moving obstacles: people, carts and forklifts crossing its path.
  • Run box-finding, gesture commands and label reading on the real robot, for full inventory counts on its own.
  • Navigate a whole building, room to room and zone to zone, from saved maps.
  • Make full-length missions as dependable as the short tests.

Expect further improvements and changes to this project as it develops.

Contact

Hiring? Let's talk.

I'm looking for full-time engineering roles in software, robotics and applied AI. Email is the fastest way to reach me.

pranch555@gmail.com