Glonce

Open MicroManipulator: open-source XYZ stage with 50 nm steps

toolsThe Glonce editorsHacker News🔥56Glonce rating56Impact40Novelty50Relevance70Surprise40Players8Credibility70
Open MicroManipulator: open-source XYZ stage with 50 nm steps

The GitHub README describes Open MicroManipulator, an open-source, low-cost, easy-to-build motorized XYZ micro-manipulator motion control platform that it says achieves submicron precision. Its intended uses are optical alignment, probing electronic components and microscopy. A YouTube video, "An Open Source Motorized XYZ Micro-Manipulator - Affordable sub µm Motion Control", explains the device and how it is built.

The mechanics use a parallel kinematic structure and miniature ball joints, which the README says give good mechanical stiffness and a large range of motion. The motors are off-the-shelf stepper motors driven by a 30 kHz closed loop controller and a very precise PWM signal. A "magnetic gearing" approach increases the resolution of the low-cost magnetic rotary encoders by a factor of 30, allowing steps down to 50 nm. The README adds a caveat: resolution is not accuracy, and the absolute accuracy is significantly worse. No accuracy figure is given.

The device takes simple G-Code commands over a USB serial interface, so it can be built into other projects. The firmware, written in C++ with some inspiration from the SimpleFOC project, implements a full motion planning stack with look-ahead for smooth path following. It supports true 6DOF-Pose interpolation and planning, which the README says makes it ready for driving hexapod motion platforms; that "may or may not be the next step" for the project. The firmware accepts only a small subset of G-Code. Each command is answered with ok or error, and the client must wait for that acknowledgment before sending the next command, otherwise behavior is undefined.

The build steps listed are: read the document and watch the linked videos, get the parts from the Bill of Materials, build the device and electronics, adjust the hardware configuration in hw_config.h, upload the firmware with VSCode and the PlatformIO plugin, and calibrate the axes. There is a setup guide for new devices and a community Discord server.

A new hardware version fixes six problems of the previous design: self collision during homing; a ball joint block held by screws only, which was not well constrained and could rotate a bit; no reliable way to get a consistent linkage rod length; unnecessary ball joint friction; ball position accuracy that depended heavily on print quality and corner rounding; and rubber bands that could not be changed or removed once glued in. A second video covers the improved ball joint and linkage process. The FreeCAD model was restructured and now includes all pins and fasteners, serving as a reference for every mechanical part. The README warns that the Bill of Materials is not yet updated for the new version.

For software, a Python control program with a graphical interface shows a live camera feed (for example from a microscope camera), has simple controls for moving the device, a simple G-code runner and real-time mouse control, which the README suggests for biology applications. A lightweight Python API, the single file open_micro_stage_api.py plus the dependencies in requirements.txt, handles serial communication. It offers functions to home, move and calibrate the device and to query device information, including connect (default baud rate 921600), home, calibrate_joint, move_to, set_tool_output, set_pose, dwell, enable_motors, wait_for_stop, set_max_acceleration and set_servo_parameter.

Firmware 1.0.4 brings many smaller improvements and bugfixes plus one headline feature: tool support, for example laser engraving, on the two GPIO pins of J5 on the PCB. Tools are integrated into the planner, run with correct timing during G-code execution, and support PWM using the PIO feature for extra channels without software PWM. An example is M3 T0 S0.7, which sets tool 0 to 70% PWM, followed by a dwell command such as G4 S0.001 (or any other motion command) to apply the output. Calibration gains extra error checks to report problems such as encoder alignment. Kinematic parameters are cleaned up and preset for hardware v4.0; owners of v3.0 hardware must switch back to the old parameters in kinematic_model_delta3d.cpp, where a #define at the top handles it. An earlier update improved homing (parallel homing, higher repeatability, a more accurate geometric reference), joint calibration (refined, stored in flash so no recalibration after reboot) and logging, and added G-Code commands: G28 (home joints, several axes at once), G24 (set pose, bypassing the motion controller), M17/M18 (enable or disable motors, recovering pose from the encoders on enable), M51 (read encoder values), M55 (set servo loop parameters), M56 (joint calibration, optionally saved to flash), M57 (read device state) and M58 (read firmware version).

CAD models are made in FreeCAD so anyone can view and modify the design without paying for proprietary CAD; the files were made with FreeCAD 1.2.0dev and may not open in older versions. Most parts are designed to be machinable on a 3-axis CNC mill. They can also be 3D-printed, but with thermal drift; carbon filled filaments can reduce it. STL files are provided. The electronics are designed in KiCAD, use only commonly available modules (motor drivers and MCU boards) joined by a simple PCB, and need no SMD soldering. Fabrication files are in the repository. Boards labelled v1.2 have a misplaced via on diode D1 that shorts the 5V rail to ground and must be drilled out; v1.3 fixed it.

The maintainers ask for help in four ways: improving the build guide through pull requests or issues, measuring radial shaft error motion on multiple Nema-17 stepper motors (pointing to a Cylos Garage video on the subject), sharing feedback on the build experience, and supporting the project on Ko-fi.

Key facts

  • Open MicroManipulator is an open-source, low-cost motorized XYZ micro-manipulator with parallel kinematics and off-the-shelf stepper motors, aimed at optical alignment, probing electronics and microscopy.
  • A 30 kHz closed loop controller and a "magnetic gearing" trick that raises encoder resolution by a factor of 30 allow steps down to 50 nm; the README says absolute accuracy is significantly worse.
  • The device is controlled with simple G-Code over USB serial, with a Python API and a GUI that shows a live camera feed.
  • A new hardware version fixes six earlier design problems, including self collision during homing and ball joint friction, but the Bill of Materials is not yet updated.
  • Firmware 1.0.4 adds tool outputs (such as laser engraving) on two GPIO pins of J5, driven by PWM and integrated into the planner.

Why it matters

Precision positioning at the micron scale usually means specialised equipment. This project offers an open design that uses off-the-shelf stepper motors, FreeCAD and KiCAD files, a PCB that needs no SMD soldering and parts that can be machined or 3D-printed. Its main trick is the "magnetic gearing" approach, which raises the resolution of cheap magnetic rotary encoders by a factor of 30 to reach 50 nm steps. The firmware also handles 6DOF-Pose planning, which the README says could drive hexapod platforms, though it calls that only a possible next step.

Who it affects

The README names optical alignment, probing electronic components and microscopy as target uses, and it suggests real-time mouse control for biology applications. In practice that means hobbyists and makers who want to build a stage, labs that want to integrate it into their own setups via G-Code, and anyone who wants to contribute to the build guide or test stepper motors. Owners of hardware v3.0 or PCB v1.2 have specific actions to take.

How to use it

Follow the README steps: get the parts from the Bill of Materials (which is not yet updated for the new hardware), build the device and electronics, set hw_config.h for your build, flash the firmware from VSCode with PlatformIO, and calibrate the axes. Control it with G-Code over USB serial, with the Python GUI, or by copying open_micro_stage_api.py into your project and installing requirements.txt. The API connects at a default 921600 baud. Wait for each command's ok or error reply before sending the next one. For tools, send for example M3 T0 S0.7 and then a dwell or motion command to apply the output. The README gives no price or total cost for the build.

How solid is it

Everything here comes from the project's own README, which backs its claims with linked videos but cites no benchmarks, and it gives no comparison with commercial micro-manipulators. The 50 nm figure is a resolution, and the README itself says the absolute accuracy is significantly worse without stating a number. No stiffness figures, range-of-motion dimensions or load capacity are given either. The "submicron precision" claim therefore cannot be checked from the page alone.

Risks and caveats

The Bill of Materials is not yet updated for the new hardware. Hardware v3.0 owners must switch the kinematic parameters back in kinematic_model_delta3d.cpp. PCB v1.2 has a misplaced via on diode D1 that shorts the 5V rail to ground and must be drilled out; v1.3 fixed it. 3D-printed parts suffer thermal drift, which carbon filled filaments can reduce. The FreeCAD files need version 1.2.0dev and may not open in older versions. The firmware supports only a small subset of G-Code, and sending a command before the previous one is acknowledged gives undefined behavior. The hexapod and 6DOF platform idea is only a possible next step, not announced work.

“Please mind the difference between resolution and accuracy. The absolute accuracy is significantly worse.”

— Open MicroManipulator README