compareeHub

YOU CAN BUILD A 3D LASER SCANNER FROM A VELODYNE LIDAR AND MAP A CAVE

A Velodyne VLP-16 puck spun on a homemade rig just mapped a wild cave in 3D — 15 scans stitched into one 42-million-point cloud.

by 9nl (tthom289 on GitHub)

FULL CAD BOM FIRMWARE DOCS

ScienceOpen-hardware

Built withRaspberry PiTeensy

difficulty
●●●●●
time
several weekends
license
MIT
repo
repo ACTIVE21 stars

WHAT YOU’LL NEED

Videos
1
Jump to section

COMPAREE VERDICT

This is one of the most technically ambitious open DIY sensing projects around. You take a Velodyne VLP-16 LIDAR puck, which on its own only sees a 40-degree vertical slice, and spin it on a belt-driven platform with a brushless gimbal motor, a Teensy 4.0 SimpleFOC carrier board and a slip ring, so it captures everything around it. A Raspberry Pi 5 records the data as ROS 2 bags. The reconstruction pipeline deskews the spinning capture, aligns scans with ICP registration, and lets you fly through the result in an OpenGL viewer. In June 2026 maker 9nl and his brother carried the rig into a wild cave, a former saltpeter mine, recorded 15 static scans and stitched them into one cloud of about 42 million points. The three repos are MIT-licensed: the carrier board (KiCad, STEP, BOM), the motor firmware and the Python pipeline. The mechanical platform itself, which uses 3D-printed parts, is only shown in video, not published as CAD. The catch: there is no written build guide. You learn by reading code, watching the two YouTube videos (one on the rig build, one on the cave trip), and understanding ICP well enough to tune registration. The biggest trap is buying the LIDAR before you have the spinning platform, slip ring and ROS 2 recording working. But if you have done hardware bring-up before and want to build something that generates real survey-style data, this is the project.

GOOD TO KNOW

  • —Three repos (pointcloud-reconstruction, vlp16-spin-controller, TeensyFOC-Carrier) all MIT-licensed, no commercial restrictions.
  • —KiCad PCB, STEP file, Gerbers and BOM published for the Teensy 4.0 SimpleFOC carrier board — a through-hole board of pin sockets and JST-XH connectors.
  • —Teensy motor-control firmware (C++, PlatformIO) and a Python point cloud reconstruction pipeline (Open3D ICP, OpenGL flythrough) are both present.
  • —No written build guide — you piece together steps from code comments, commit messages, and the YouTube videos.
  • —The creator does not say where he bought his VLP-16 or what it cost, so check current listings, new or used, before you plan the budget.
  • —You need intermediate to advanced skills in PCB assembly, SimpleFOC tuning, ICP registration math, and OpenGL rendering to make this work.

Parts to buy

12 items

From our check of the build. Exact quantities and part numbers are in the creator’s BOM.

  • Used Velodyne VLP-16 LIDAR puckFind
  • Raspberry Pi 5 for recordingFind
  • Teensy 4.0Find
  • SimpleFOC driver boardFind
  • Brushless gimbal motor (the creator uses a 4015 motor)Find
  • AS5600 encoderFind
  • Slip ringFind
  • GT2 belt with 12T and 60T pulleysFind
  • 12 V lithium-ion batteryFind
  • Pin sockets and JST-XH connectorsFind
  • TripodFind
  • PCB fabrication for the carrier boardFind

BUILDS OF THE WEEK

Five open-source builds worth your weekend, every week.

Checked like this one: what’s really in the repo, what it costs, how hard it is. One email, unsubscribe anytime.

Can I build this?

PrintSeveral platform parts are 3D printed (the sensor cup in PLA — the creator found ASA and PETG split along layer lines — plus bearing housings and mounts), but no STL or CAD for them is published; you design your own from the video.
BuyUsed Velodyne VLP-16 LIDAR puck, Raspberry Pi 5 for recording, Teensy 4.0, SimpleFOC driver board, brushless gimbal motor (the creator uses a 4015 motor), AS5600 encoder, slip ring, GT2 belt with 12T and 60T pulleys, 12 V lithium-ion battery, pin sockets and JST-XH connectors, tripod, PCB fabrication for the carrier board, plus filament for the printed parts.
ToolsSoldering iron, multimeter, 3D printer, PlatformIO for the Teensy firmware, Python 3.11 with Open3D, an OpenGL-capable computer for visualization.
SkillsAdvanced. You need to integrate a spinning LIDAR platform with a slip ring, record ROS 2 bags, flash a Teensy with PlatformIO, and understand ICP point cloud registration well enough to tune it in Python (Open3D).
TimeSeveral weekends: one for board assembly and motor bring-up, one for firmware tuning and first scans, one or more for pipeline setup and registration parameter tuning. Field deployment adds another weekend.
Cost$$$ — the used VLP-16 is by far the biggest cost; the creator publishes no prices, so check current used-market listings. The carrier PCB, Teensy, motor, slip ring, battery and printed parts come on top.
SafetyClass 1 laser product (Velodyne VLP-16 is eye-safe under normal use, but do not stare directly into the rotating aperture). Spinning mechanical assembly — keep fingers clear during motor tuning. Cave fieldwork has its own risks (falling, getting lost, water, low oxygen in deep chambers) that are outside the scope of this build.

Build at your own risk. Projects involve tools, electronics and sometimes mains voltage — follow the creator’s safety notes.

Videos

We 3D Scanned A Cave (with my homemade scanning rig)

The cave field test, June 2026: 15 static scans in a wild cave, then a narrated walkthrough of deskewing and stitching the scans.

More builds like this

All projects
Allsky: a Raspberry Pi camera in a weatherproof dome that films the whole night sky by itselfScienceYou can build the rig that gives every bee in the hive its own barcodeScienceOhmPi: an open-hardware resistivity meter that images what is under the groundScience

Gallery

img.youtube.com
img.youtube.com

Start here

Navigation into the creator’s own docs — we don’t rewrite the guide, we route you to the source.

  1. 1.Read all three repos (pointcloud-reconstruction, vlp16-spin-controller, TeensyFOC-Carrier) to understand what connects to what. (Start here — the reconstruction pipeline repo has the most context.)
  2. 2.Watch both YouTube videos before buying anything — confirm you can do the soldering and motor tuning shown. (Build video first, then the cave deployment video.)
  3. 3.Order the Teensy carrier board PCB (Gerbers in TeensyFOC-Carrier repo) and gather BOM components.(Use a reputable PCB house (JLCPCB, PCBWay, OSH Park). The board is through-hole only: pin sockets for the Teensy and driver, JST-XH for motor, encoder and power.)
  4. 4.Buy the surplus Velodyne VLP-16 LIDAR puck last — only after you have the carrier board working and motor tuned.(Look for used or decommissioned VLP-16 units and confirm it powers on before full assembly.)

Resources

Documentation, files and community threads for this build — we link straight to the original sources and never rehost the creator’s files.

KNOWN ISSUES

  • Used VLP-16 prices and availability vary — do not buy the sensor until the carrier board and motor control are proven.
  • There is no written build guide. You learn by reading code, watching videos, and filling in gaps. If you need step-by-step instructions, this will frustrate you.
  • The published firmware spins the motor open-loop at a fixed 200 RPM (40 RPM at the platform) because closed-loop calibration was unreliable; if you want encoder-based closed-loop control, you will be tuning it yourself.
  • The pipeline uses ICP registration with adjustable slice, overlap, voxel and fitness settings. If scans do not line up in your environment, expect to tune these and understand what ICP is doing.
  • The carrier board is through-hole only (pin sockets and JST-XH connectors), so soldering is easy — the hard parts are the mechanics, slip ring wiring and getting the platform to spin smoothly.
  • The creator runs the LIDAR, Raspberry Pi and motor driver from a 12 V lithium-ion battery and feeds the Teensy separately from a power bank — plan power for the whole rig, not just the sensor, and carry spare batteries into the field.

Can I use a different LIDAR sensor instead of the Velodyne VLP-16?

The pipeline is written and tested for the VLP-16: it reads the /velodyne_points PointCloud2 topic from ROS 2 bags along with the platform encoder angle. Another sensor that can publish a PointCloud2 might be adaptable, but expect to change the topic, calibration and deskew logic yourself — the creator only shows the VLP-16.

Do I need the exact motor shown in the video?

No. The firmware is set for the creator's motor (he calls it a 4015 motor; 7 pole pairs in the code) with an AS5600 magnetic encoder, driving the platform through a 12T:60T GT2 belt at 40 RPM. Another SimpleFOC-compatible motor should work if you update the pole pairs and gearing in the code.

Can I skip the custom Teensy carrier board and wire the motor driver directly?

Technically yes — the carrier board only consolidates the Teensy, motor driver header, encoder and power connectors. The creator made it to get rid of the wiring mess of a breadboarded SimpleFOC setup, and the files are ready to order.

How big are the point cloud files and what GPU do I need to visualize them?

In the creator's videos, one static scan was a little over a gigabyte decompressed and about 21 million points before downsampling, and 15 stitched cave scans came to about 42 million points. The fly-through viewer is OpenGL; the creator does not state GPU requirements, so large clouds may need downsampling (the merge tool downsamples by default).

Is the cave scan data published anywhere?

Not in the repositories. The pipeline repo expects your own ROS 2 bag recordings; the cave dataset itself has not been published.

Community builds

No community builds yet — be the first, we feature the best ones.

Discussion1

FROM THE COMPAREE TEAM

The whole cave scan came from a Velodyne VLP-16 spun on a homemade rig — no commercial survey scanner involved. If you had this setup, what would you scan first?

CompareeTEAM1mo agoedited

Practical notes from our verification: the creator (9nl on YouTube) has published the pieces as separate MIT-licensed GitHub repositories — pointcloud-reconstruction for the processing pipeline, vlp16-spin-controller for the rotating platform, and TeensyFOC-Carrier for the motor-controller carrier board with KiCad files and a BOM. The platform is driven by a brushless gimbal motor (the creator calls it a 4015 motor) with an AS5600 encoder through a 5:1 belt reduction, running open-loop velocity control at about 40 RPM. The reconstruction runs offline in Python: it reads ROS 2 MCAP recordings, deskews each scan using the platform angle, merges the slices with ICP in Open3D, and includes a fly-through viewer — no ROS install needed, but Python 3.11 is recommended because Open3D does not support 3.13+. Two videos show the project: 'My LIDAR Was Half Blind (so I fixed it)' and the cave deployment, 'We 3D Scanned A Cave (with my homemade scanning rig)'. If your scans do not line up, the ICP merge step is the one to dig into. Correction (4 October 2026): we re-checked this page line by line against the project's own repository, documentation and videos, and fixed errors in earlier versions.

9nl (tthom289 on GitHub)

Built a rotating rig for a Velodyne VLP-16 to capture full 3D scans for cave mapping. In June 2026 he and his brother took it into a wild cave for its first real-world field test — no GPS and no light — and stitched 15 static scans into one point cloud.

GitHub

Star the project on GitHub

DISCLAIMER

  • Comparee is not the author of the projects featured here. All rights to each project belong to its creator — every page links to the original source, and we never host creators’ files.
  • Information is provided without warranty and may become outdated as projects evolve. Prices are indicative bands only — always check the creator’s parts list for current costs.
  • Building and operating any project is at your own responsibility. Protective equipment, safe workshop practice and compliance with local regulations are the builder’s responsibility.
GitHub repo