Connecting to sources…

How to build Amazing Hand (AH!): the whole process

156 steps to build Amazing Hand (AH!), from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop links and the off…

The official BOM sheet totals €116.89 per hand (about $135.59, including €15 of 3D prints), €128.28 with a Waveshare driver board or €142.29 with an Arduino Mega and TTL Linker; Enhanced is €275.61, or €287.00 with the driver board. Ready kits (2026‑10‑31): Seeed Studio $99.00 per hand, WowRobo $99–179 (taxes included, shipping extra)

Buy parts

  • Prepare an external power supply

    Prepare an external power supply for the eight actuators inside the hand, and check the required components in the BOM.

  • Choose a power adapter

    Without an external supply, a DC/DC 220V -> 5V / 2A adapter with a jack connector can be used.

  • Buy the Seeed Studio kit

    Buy the Amazing Hand Right Hand open-source robotic hand developer kit from Seeed Studio.

  • Buy the WowRobo kit

    Buy the Amazing Hand open-source robotic hand kit from WowRobo.

  • Get the Chinese BOM

    Get the specific Chinese BOM linked by the document.

  • Prepare the frame and bushings

    Set out 1 Finger frame part1 and 2 Bushing Dint 6mm bushings.

  • Prepare the actuator assembly

    Set out 1 Finger frame part1 with bushings, 1 Finger frame part2, 2 Feetech SCS0009 servos, and 4 Servo 2x7 screws.

  • Prepare the final finger parts

    Set out 1 Finger mechanism, 1 Actuator assembly, 2 Servo horn assembly, 2 M2 nuts, 1 thermoplastic screw 2.5x8, and 1 M2.5 large washer.

  • Gather AmazingHand build resources

    Open the project’s GitHub resources, including the AmazingHand BOM, CAD folder, 3D Printing Guide, and Assembly Guide PDF.

  • Power the Hand's Eight Servos

    Use a simple 5V / 2A DC adapter with a jack connector. Do not power the servos directly from the computer's USB port.

  • Download the Open-Source Build Resources

    Open the AmazingHand GitHub repository to obtain the BOM, 3D files, 3D-printed guide, assembly guide, and basic demo programs.

Print and make

  • Download the CAD files

    Download the STL and Steps files from the CAD directory to make the hand parts.

  • Open the Onshape document

    Open the provided Onshape document to inspect the AmazingHand CAD assembly.

  • Inspect predefined positions

    Use the predefined positions and their corresponding servo angles in the Onshape “named position” tooling.

  • Get the Amazing Base CAD files

    Get the Amazing Base STL or STEP file from the project's cad directory.

  • Get the SO-Arm interface CAD

    Get the SO-Arm interface STL or STEP file from the project's cad directory, or directly from the Onshape workspace folder named "community update".

  • Print Parts Using the 3D Guide

    Download the 3D files and follow the provided 3D-printed guide to print the hand parts.

  • Print the fingers and hand

    Print 4 Finger parts and 2 Hand parts; see the “AmazingHand_3D printing tips” document for more details.

  • Download CAD and printing guide

    Download the models from the CAD folder and obtain the AmazingHand_3DprintingTips.pdf printing instructions.

Assemble

  • Prepare the required tools

    Prepare a ϕ1.5 drill bit, ϕ2 drill bit, M2 tap, PH0 cross screwdriver, flat pliers, scalpel or thin cutter, Dremel with abrasive disk or strong cutting pliers, and portable drill.

  • Prepare finger frame part 1

    Prepare 1 Finger frame part1 for finger assembly.

  • Prepare finger frame part 2

    Prepare 1 Finger frame part2 for finger assembly.

  • Prepare the proximal part

    Prepare 1 Proximal for finger assembly.

  • Prepare the distal part

    Prepare 1 Distal for finger assembly.

  • Prepare the gimbal

    Prepare 1 Gimbal for finger assembly.

  • Prepare the link

    Prepare 1 Link for finger assembly.

  • Prepare the proximal shell

    Prepare 1 Proximal shell for finger assembly.

  • Prepare the distal shell

    Prepare 1 Distal shell for finger assembly.

  • Prepare the spacers

    Prepare 2 Spacer parts for finger assembly.

  • Prepare the M2 ball joints

    Prepare 4 M2 Ball joints; each comes with an M2x12 screw and M2 nuts.

  • Prepare the D bushings

    Prepare 2 Bushing D interior 6 parts.

  • Prepare the M2.5 large washer

    Prepare 1 M2.5 large washer.

  • Prepare the D2x10 axes

    Prepare 2 Axis D2x10 parts.

  • Prepare the D2x16 axes

    Prepare 2 Axis D2x16 parts.

  • Prepare the 2.5x6 thermoplastic screws

    Prepare 4 Thermoplastic screw 2.5x6 parts.

  • Prepare the 2.5x8 thermoplastic screw

    Prepare 1 Thermoplastic screw 2.5x8.

  • Prepare the M2 threaded rod

    Prepare 1 or 2 M2 threaded rods, each 300 mm long.

  • Prepare the Feetech servos

    Prepare 2 Feetech SCS0009 servos.

  • Prepare the cross servo horns

    Prepare 2 Cross servo horn parts.

  • Prepare the servo 2x7 screws

    Prepare 4 Servo 2x7 screw parts.

  • Prepare the servo M2x4 screws

    Prepare 2 Servo M2x4 screw parts.

  • Cut the long M2 threaded rods

    Cut the M2 threaded rod into 4 pieces, each at least 26 mm and at most 28 mm long.

  • Cut the short M2 threaded rods

    Cut the M2 threaded rod into 8 pieces, each at most 16 mm and at least 14 mm long.

  • Shorten the ball joint screws

    Cut the 12 mm M2 ball joint screws into 8 screws of 9 mm; the nuts may be kept on during cutting and removed afterward.

  • Rework the cross servo horns

    Drill the hole closest to the center of each of 8 cross servo horns with a ϕ1.5 mm bit, then make an M2 thread with a tap or screw; cut away the unwanted branches and smooth the horns.

  • Install the spacer and second ball joint

    Insert a spacer at one end of the ball joint rod, then screw in the second ball joint at the other end until both sides contact the spacer. Align both ball joints in parallel and place the assembly on the tooling to check the length; if it does not fit, adjust by screwing or unscrewing one ball joint.

  • Connect the ball joint rod to the servo horn

    Screw the M2 screw into the remaining hole of the custom servo horn. When it protrudes through the other face, place the nut on it and continue tightening the horn and nut together until the ball joint contacts the horn.

  • Assemble the distal part and link

    Push the D2x10 axes into the holes of the distal part. Place the link between the distal part ears and push the axes until they no longer protrude from the distal part. Repeat the same step for the gimbal part.

  • Assemble the proximal part and subassembly

    Push both D2x16 axes into the holes of the proximal part. Place the previous subassembly between the proximal part ears and continue pushing the axes until they no longer protrude from the proximal part.

  • Check the mechanism and install the threaded rod

    When the finger mechanism is ready, check whether flexion and extension are smooth and do not block anywhere over the full range. Then insert the M2 threaded rod L25mm into the remaining hole of the link part until both ends are the same length.

  • Insert the proximal shell over the mechanism

    First insert the proximal shell through the finger mechanism; it is easier when the finger is in the extension pose.

  • Fasten the proximal shell

    Align the shell hole with the proximal-part hole and fasten it with a thermoplastic 2.5x6 screw. Flip the finger and repeat on the opposite shell side.

  • Fasten the distal shell

    Insert the distal shell, align both holes, and fasten it in the same way as the proximal shell. Flip the finger and repeat on the opposite side. Do not overtighten the shell screws, or they may penetrate the soft, thin surface around them.

  • Press in both bushings

    Push a bushing into each side of Finger frame part1. Push against a flat surface until each bushing is fully inserted, creating the finger's abduction and adduction motion.

  • Assemble the two servos

    The servo screw holes in finger frame part1 and part2 are counterbored to make screwing into the plastic easier. Place both SCS0009 servos side by side between the frames and fix them with Servo 2x7 screws, with the servo axes away from the finger's abduction and adduction pivot.

  • Insert the gimbal assembly

    Insert the finger assembly into the bushings and place the large washer and thermoplastic screw 2.5x8 together in the gimbal hole. Tighten until the washer contacts the bushing, but do not overtighten; manually check that abduction and adduction move smoothly while minimizing the functional gap.

  • Connect the ball-joint links

    Fit the free end of a ball-joint rod onto the M2-threaded end of the link part, with the servo horn oriented to mount later on the servo axis. Tighten the M2 nut until the ball and link contact, then turn it at least another half turn; repeat on the other side with a second rod and use a glue point if a nut remains too loose.

  • Secure the servo horns

    Following the picture, place the servo horns in the closed position as closely as possible. Secure both servo horns with M2x4 screws; each servo has a different 0 position because of its coupling with the servo horn.

  • Secure the servo horns

    Following the picture, place the servo horns in the closed position as closely as possible. Secure both servo horns with M2x4 screws; each servo has a different 500 position because of its coupling with the servo horn, so the middle position must be fine-tuned in the next step.

Software

  • Clone the AmazingHand Repository

    Clone the project repository to your computer to get all the necessary code.

  • Open the Python Examples Directory

    Navigate into the PythonExample directory to run its testing and control scripts.

  • Install the SCServo Library

    Before using the examples in the Arduino IDE, ensure that the required SCServo library is installed.

  • Flash XIAO ESP32-S3 Firmware

    Flash the data acquisition firmware onto the ESP32. The firmware reads the strain gauge values and sends them over the serial port in the format "value1,value2".

  • Define sensor pins

    Assign the three main finger sensors to D0, D1, and D2, and assign the independent thumb sensor to D3; these pins are valid for both the ESP32-S3 and ESP32-C3.

  • Configure serial and ADC

    Initialize serial at 115200 baud to match the host Python script, wait for the serial port, and set the ADC resolution to 12 bits for a 0–4095 reading range.

  • Read main finger sensors

    Read the analog values from the three main finger sensors through D0, D1, and D2.

  • Calculate main finger average

    Add the three main finger sensor readings and divide by 3 to create the single value used by the Python script to control the finger group.

  • Read independent thumb value

    Read the independent analog value from the thumb sensor through D3.

  • Send processed serial data

    Transmit the main finger average and thumb value over USB serial in the "fingers_avg,thumb_val" format, with an automatic newline.

  • Stabilize serial data stream

    Delay 50 milliseconds after each transmission to maintain a stable data stream and allow time for processing on the receiver.

  • Configure Finger and Servo Mapping

    Map Index, Middle, Ring, and Thumb to servo IDs 1–2, 3–4, 5–6, and 7–8, respectively. The Thumb uses an independent ADC channel.

  • Set Servo Angle Range

    Set the open angle offset to -30° and the closed angle offset to +90°. The servos move in real time within the [-30, 90]° range according to the ADC value.

  • Initialize Hand Controller and ESP32

    Set the hand controller to /dev/ttyACM0 at 1000000 baud and the ESP32 to /dev/ttyACM1 at 115200 baud. Flush the ESP32 serial input buffer after initialization.

  • Create index.html and backend.py files

    Create two files in the same directory: save the HTML code as index.html and the Python code as backend.py. index.html requests webcam access and streams video to the backend, while backend.py launches a local WebSocket server, detects hand landmarks with MediaPipe and translates them into motor commands.

  • Run the Python backend server

    Open a terminal, navigate to the directory with the saved files, and run python backend.py to start the server. The terminal should show a message that the server started and is waiting for a connection, for example: WebSocket server started on ws://localhost:8765.

  • Configure fingers and servo parameters

    Configure the two servo IDs for the index, middle, ring, and thumb fingers; the pinky is not controlled. Set the close offset to 90, the open offset to -30, and the gesture input range from 20 to 160 degrees.

  • Connect and initialize the hand controller

    Connect the Scs0009PyController through the configured serial port at 1000000 baud with a 0.5-second timeout. After connecting, enable torque on all eight controlled motors, set their speed to 6, and wait 0.5 seconds.

  • Install the SCServo library

    First install the Arduino library named “SCServo”.

  • Set IDs with Feetech software

    Use the Feetech software to set the servo IDs.

  • Upload the custom control program

    Upload a custom program to the Arduino board for control mode.

  • Configure the Arduino Uno serial port

    For an Arduino Uno or another small Arduino with only one serial port, configure serial communication as shown in the document.

  • Configure the Arduino Mega serial port

    The Arduino used here is a Mega with several built-in serial ports, so configure serial communication as shown in the document. The Rx and Tx pins used on the Mega are RX1 and TX1, pins 19 and 18.

  • Install Rust

    Install Rust using the Rust tools installation page.

  • Install uv

    Install uv using the uv installation page.

  • Install dora-rs

    Install dora-rs using the dora-rs installation page.

  • Start the dora-rs daemon

    Run `dora up` to start the daemon.

  • Clone the repository and create the environment

    Clone this repository and run `uv venv` with Python 3.12 from the repository directory in a console.

  • Configure the left-hand mode

    When building a standalone left hand, keep the same servo-location IDs and select the left hand in the software.

  • Get AmazingHandControl tools

    Get the AmazingHandControl repository. Its Python GUI and CLI tools control fingers independently, monitor servo feedback in real time, and save and replay custom animation positions sequentially.

  • Get SG90 force-control code

    Get the GitHub code for the Amazing Hand with SG90 servos and force-control setup.

  • Set Up Webcam Hand Tracking

    Use the provided hand-tracking project and example programs to map your own hand motion to the robot's finger motion.

  • Install the Basic Demo Programs

    Download the basic demo programs from the GitHub repository and use them with the assembled hand.

  • Load hand simulation and IK node

    Use the included Mujoco model, assets, and Python node that sets the inverse kinematics problem; Mink solves inverse kinematics as a QP problem.

  • Connect and run FD software

    Plug the WaveShare serial bus driver into the computer and run the FD software from Feetech. Select the corresponding COM port and set the baud rate to 1000000.

  • Set Up the Serial Bus Driver

    Follow the linked tutorial to set up the Feetech STS3032-360 serial bus driver.

Calibrate and test

  • Search and set servo IDs

    Click Open and then Search. After the ID1 servo appears, change its ID as needed. Connect both servos to the same serial bus.

  • Run the finger middle-position script

    Run “Hand_FingerMiddlePos.py” and change serial_port to the corresponding port. The default middle position is 0, and the program moves the servos to their middle position.

  • Run the finger test script

    Run “Hand_FingerTest.py” and change serial_port to the corresponding port. Stop the program as soon as the finger reaches the closed position, then check whether the servo horns align with the servos’ middle plane.

  • Fine-tune and save middle positions

    If alignment is incorrect, change the middle position slightly; the value is an angle in degrees. In the example, increase the right servo horn’s (ID1) new middle position by +3°, while the left servo horn (ID2) is correct; repeat the settings to confirm the fine-tuned position and save the values for later use.

  • Calibrate four fingers and servo IDs

    Calibrate each of the four fingers as described previously, with a different middle position for each finger. Every servo must have a unique ID: index finger 1 and 2, middle finger 3 and 4, ring finger 5 and 6, and thumb 7 and 8; change the servo ID being calibrated in the finger test program.

  • Set the servo IDs

    Set the servo IDs by following the tutorial linked in the document. Use the Feetech serial bus link to connect both servos on the same serial bus, then reconnect it to the Arduino in the driving configuration. The pictures identify ID 1 and ID 2.

  • Set position 511 with Feetech software

    Use the Feetech software to set position 511 for each servo.

  • Run the four-finger Arduino test

    Run the Arduino program “4-Fingers Hand_FingerTest.ino”. The default middle position is 511; the program opens and closes the finger, then performs abduction and adduction movements.

  • Check Closed-Finger Servo Alignment

    Stop as soon as the finger reaches the closed position and check whether the servo horns align with the middle plane of the servo. If not, fine-tune the middle position; the raw value is 0.293° per step, with the right servo (ID1) increased to 520 and the left servo (ID2) remaining at 511.

  • Save Servo Middle Values

    Save the calibrated middle values somewhere they can be retrieved easily later.

  • Fine-Tune All Four Fingers

    Perform the previous calibration procedure to set a different middle position for each of the four fingers. Each servo must have a unique ID.

  • Assign Unique Servo IDs

    Use IDs 1 and 2 for the index finger, 3 and 4 for the middle finger, 5 and 6 for the ring finger, and 7 and 8 for the thumb. The servo ID being calibrated can be changed in the finger test program.

  • Choose a Servo Control Method

    Choose one of the two primary methods for controlling the hand's servos over the serial bus. Use the calibration script provided for that method to set up the fingers correctly during assembly.

  • Test One Finger's Movement

    Run AmazingHand_FingerTest.py to test the movement of a single finger. It is useful for debugging during assembly.

  • Set Fingers to Middle Position

    Run AmazingHand_Hand_FingerMiddlePos.py to set the fingers to their neutral, middle position for calibration.

  • Upload the Main Arduino Sketch

    Open Amazing_Hand_Demo.ino in the Arduino IDE, then compile and upload it to the Arduino board. The sketch cycles the hand through the same gestures as the Python version.

  • Upload the Arduino Finger Test

    Open Amazing_Hand-Finger_Test.ino in the Arduino IDE, then compile and upload it to the Arduino board. It tests a single finger and is useful for calibration and debugging hardware connections.

  • Connect Strain Gauges to ADC Pins

    Connect the strain gauges to the ESP32 ADC pins so the firmware can read their resistance changes.

  • Enable All Motor Torque

    Collect the eight servo IDs, enable torque on every servo, and set the goal speed to 6. Wait 0.5 seconds after setting the speed.

  • Disable motor torque before exiting

    When the program exits, set the torque values for all controlled motors to 0, safely disabling torque and terminating the program.

  • Set Motor IDs and Angle Offsets

    Set each motor ID and finger angle offset in r_hand.toml.

  • Change a Motor ID

    Use the change_id tool to change a motor ID.

  • Move a Single Motor

    Use the goto tool to move a single motor to a given position.

  • Get Motor Zeros

    The get_zeros tool sets the motors in compliant mode and writes the TOML file to the console to help set the motor zeros.

  • Set the Hand to Zero

    The set_zeros tool moves the hand to the "zero" position according to the configuration file.

  • Calibrate fingers with Python

    Use the Python example with the Waveshare serial bus driver to calibrate each finger.

  • Calibrate fingers with Arduino

    Use the Arduino example with TTLinker to calibrate each finger.

  • Run the Python demo

    Run the basic Python demo program named “AmazingHand_Demo.py”.

  • Run the Arduino demo

    Run the basic Arduino demo program named “AmazingHand_Demo.ino”.

  • Adapt the hand configuration

    Adapt the `AHControl/config/r_hand.toml` configuration file for the particular hand using the motor and finger naming.

  • Use the AHControl tools

    Use the software tools in the `AHControl` directory to configure the motors.

  • Upload Blink before opening the serial port

    Before opening the COM serial port with Feetech software, upload the Blink example program to the Arduino.

  • Choose inverse kinematics control target

    Choose to control the fingertips position, which is useful for the hand tracking demo, or the distal phalanges orientation.

Data and training

  • Run the Python Control Script

    Run the Python control script on the host computer to receive the strain gauge values over the serial port and control the AmazingHand's grip and gestures with hand movements.

  • Read and Parse ADC Data

    Read a line only when data is available in the ESP32 serial buffer and require the format “value1,value2”. The first value controls Index, Middle, and Ring, while the second controls Thumb.

  • Map ADC to Angle Offsets

    Linearly map the 0–4095 ADC range to the angle range from -30° (open) to +90° (closed). Calculate separate angle offsets for the main three fingers and the Thumb.

  • Send Synchronous Servo Positions

    Build the servo ID and position lists from the finger configuration; use the Thumb offset for Thumb and the main-finger offset for the other three fingers. Each finger’s M1 and M2 move in opposite directions from the zero-degree center.

  • Receive gestures and control fingers

    Receive thumb, index, middle, and ring angles as JSON over WebSocket and linearly map 20–160 degrees to -30–90. Apply opposite offsets to each finger’s two servos, convert the angles to radians, and synchronously write the target positions.

Use it

  • Run the Two-Hand Demo

    Run AmazingHand_Demo_Both.py to control a right hand and a left hand connected to the same serial bus.

  • Stop Safely and Disable Torque

    Press Ctrl+C to exit the real-time control loop. When the program ends, set torque on all servos to 0 and terminate the program.

  • Launch the frontend and control with your hand

    In the file explorer go to the same directory and double-click index.html; it opens in your default browser. The browser will likely ask for permission to use your webcam, so please allow it. Once the page loads you see your camera feed and can control the AmazingHand by moving your hand in front of the camera.

  • Start the web front-end control service

    After initializing the servos, start the WebSocket service on port 8765 at 0.0.0.0 and wait for the web front-end to connect. Keep the program running until the user interrupts it.

  • Run webcam tracking in simulation

    Run the build command once, then run the webcam hand-tracking demo in simulation.

  • Run webcam tracking on real hardware

    Run the build command once, then run the webcam hand-tracking demo with real hardware.

  • Run angle control in simulation

    Run the build command once, then run the simulation example that controls the finger angles.

  • Drive Fingers With Your Hand

    Run the example programs to control finger motion from a webcam-based hand-tracking project.

  • Complete and enjoy

    The assembly is complete.

Common problems

  • CAD files cannot be downloaded or are incomplete. #12 #35
  • The transparent base 3D-printing file is missing. #1
  • BOM parts are unavailable or link to incorrect products. #11 #14
  • Board and servo voltage specifications conflict. #29
  • Simulation startup fails from missing files and invalid YAML configuration. #6 #24
  • Manual servo setup assumes finger IDs are 1 and 2. #8

Parts

  • 8 Feetech SCS0009 servos (two in parallel per finger, differential motion for flexion/extension and abduction/adduction; 5V, 1.89 kg·cm, 300 mA, UART per Seeed's spec table)
  • 16 M2×19 mm ball-joint rods, an M2 threaded rod 300 mm, 8 each of D2×10 and D2×16 pins, 8 6×8 mm bushings (GFM 0608-04), 2.5 mm thermoplastic screws and large M2.5 washers
  • 3D prints: a PLA skeleton (finger frames, proximal and distal phalanges, gimbals, links, hand plate, wrist interface) and TPU shells (Filaflex 82A or eSUN TPE 83A)
  • Control: a Waveshare serial servo driver board, or an Arduino Mega with a Feetech TTL Linker; a 5V/2A external supply
  • The Seeed kit adds a XIAO-compatible driver board, a 12V 3A adapter, eight 3-pin breakout boards with 150 mm leads, black ABS structural parts, a screw pack and a screwdriver

Tools

  • A 3D printer that handles PLA and flexible TPU (a 3D-printing guide PDF is provided)
  • An M2 tap (listed in the complementary BOM) and screwdrivers; the ball-joint rods are adjusted one by one by hand
  • Feetech's debug tool to set servo IDs

Skills

  • Python (rustypot) or Arduino (the SCServo library)
  • Servo ID setup and finger-by-finger calibration with the scripts during assembly
  • Advanced: Rust and dora-rs dataflows, MuJoCo/Mink inverse kinematics

Software

  • PythonExample: AmazingHand_Demo (cycles preset gestures), Demo_Both for two hands on one bus, single-finger test and mid-position calibration scripts
  • ArduinoExample: Amazing_Hand_Demo and a single-finger test
  • Demo/: AHControl (Rust), AHSimulation (MuJoCo + Mink), HandTracking (webcam + MediaPipe)
  • Community: the AmazingHandControl GUI and CLI tools (record and replay poses)

Documents