Bionic Arm Control Using Flex Sensor

A glove-controlled bionic hand. Five flex sensors sewn onto a wearable glove are read by an Arduino, and each one drives a servo in a 3D-printed hand. The servos pull nylon tendons routed through the fingers, so the printed hand copies whatever the wearer's hand is doing in real time.

Sathvik — CAD, firmware, fabrication, and assembly. Design Project V (MHB4439), B.Tech Mechatronics, Hindustan Institute of Technology and Science, November 2022.

Contents

Path	What's in it
firmware/hand_control_program/	The sketch that actually ran on the hardware in 2022.
firmware/bionic_hand/	A rewrite that fixes the problems described below. Written but not yet flashed to hardware.
tools/flex_calibration/	A little utility sketch for reading raw flex-sensor ranges off each finger. Also untested on hardware.
docs/	Hardware, wiring, calibration, and firmware notes.
hardware/bom.csv	Bill of materials.
images/	CAD screenshots and build photos.

How it works

A flex sensor is just a resistor whose resistance climbs as it bends. An Arduino can't read resistance directly, so each sensor sits in a voltage divider with a fixed resistor, and the junction goes to an analog pin — the Arduino reads a 0–1023 value that tracks how bent the finger is.

That reading gets mapped onto a 0–180° servo angle. The servo horn winds a nylon tendon anchored at the fingertip, which curls the finger; straightening it relaxes the tendon and the joint's own give lets it spring back. Each sensor drives exactly one servo, so all five fingers move on their own.

  Glove (transmitter)                Arduino                 Hand (receiver)
  ┌──────────────────┐         ┌──────────────────┐      ┌──────────────────┐
  │ flex sensor × 5  │ analog  │ analogRead()     │ PWM  │ SG90 servo × 5   │
  │ + divider resistor├────────►│ map() → angle    ├─────►│ → nylon tendon   │
  │                  │  A0–A4  │ constrain()      │      │ → printed finger │
  └──────────────────┘         └──────────────────┘      └──────────────────┘

The "transmitter" glove and "receiver" hand share one Arduino and a bunch of wire between them — nothing is actually transmitted over RF here, that's just how I think about the signal flow.

Hardware

Item	Qty	Notes
Arduino Mega 2560 (an Uno also works)	1	Needs 5 analog inputs and 5 PWM-capable digital pins.
SG90 micro servo	5	~1.8–2.5 kg·cm depending on supply voltage, 0–180°, 9 g.
Flex sensor (2.2")	5	One per finger.
Fixed resistor for divider	5	10 kΩ–47 kΩ; pick to suit your sensor — see docs/wiring.md.
3D-printed hand, forearm, and stand	1 set	ABS, printed in parts and bonded.
Nylon/fishing line	—	Tendons.
5 V supply, ≥3 A	1	Don't power five servos off the Arduino's 5 V pin — see Power.

Full list with rationale: hardware/bom.csv and docs/hardware.md.

Wiring

Flex sensor	Arduino pin	Servo	Arduino pin
Thumb	A0	Thumb	D3
Index	A1	Index	D5
Middle	A2	Middle	D6
Ring	A3	Ring	D9
Little	A4	Little	D10

Those are the pins firmware/bionic_hand/ uses. My original sketch had the servos on D0–D4, which turned out to be a bad idea — more on that below. Divider wiring and grounding are covered in docs/wiring.md.

Power

Each SG90 pulls roughly 100–250 mA while moving and up to ~700 mA when stalled. Five of them stalling at once gets close to 3 A, which is well beyond what the Arduino's onboard regulator or a 9 V battery can supply — try it and you'll get brownouts, twitchy servos, and the Arduino resetting on you.

Run the servos off a dedicated 5 V supply rated for at least 3 A (a UBEC or a bench supply works), and tie its ground to the Arduino's ground so the PWM signals have a shared reference. The Arduino itself is fine staying on USB power.

Getting started

1. Install the Arduino IDE. The Servo library ships with it.
2. Wire up the dividers and servos as above, with the servos on their own 5 V supply and a common ground.
3. Calibrate first. Flash tools/flex_calibration/, open the Serial Monitor at 115200 baud, and flex each finger through its full range a few times. Note the min and max per channel.
4. Put those numbers into firmware/bionic_hand/config.h.
5. Flash firmware/bionic_hand/ and check each finger tracks properly. docs/calibration.md walks through this step by step.

Don't skip calibration — the numbers that work for one glove won't work for another, since the raw range depends on your specific sensors, your divider resistors, and how tightly the sensors are stitched down.

Known issues

My original 2022 sketch has a handful of problems I only really noticed once I sat down to write a cleaner version. I'm leaving the original as-is in firmware/hand_control_program/ as a record of what actually ran, and fixing each of these in firmware/bionic_hand/:

• Servos on D0 and D1. Those are the hardware UART pins the USB connection uses, so driving servos on them fights the serial port — uploads sometimes failed, and serial debugging was out of the question. Fixed by moving every servo to a PWM pin away from the UART.
• Hardcoded 800–900 calibration. map(raw, 800, 900, 0, 180) only worked because it was tuned to one specific glove's readings, and that 100-count window is narrow enough that a little ADC noise swings the servo a surprising amount. Fixed by reading per-finger calibration values out of config.h instead.
• No smoothing. Raw analogRead() noise went straight to the servo, so it jittered even when my hand was still. Fixed with an exponential moving average plus a deadband.
• delay(100) in the loop. That caps updates at 10 Hz, which you can actually see as lag and steppy motion. Fixed with a non-blocking ~50 Hz timer that matches the servo's own refresh rate.
• No input validation. If a sensor came loose, the floating pin would send the servo slamming into an endpoint. Fixed by flagging out-of-range channels and holding the last known good position instead.

Design notes

• CAD was done in Autodesk Fusion 360 (Education License) — the screenshots in images/ are straight from Fusion, dated August 2022. A couple of the older write-ups for this project mention SolidWorks, but that's just an older draft talking about a tool I ended up not using; Fusion is what actually produced this hand.
• The hand is printed in ABS for impact strength (230–260 °C nozzle, 80–130 °C bed). Each finger prints as three separate segments — distal, middle, proximal — bonded together and then tendoned.
• I aimed for affordability here — the commercial bionic arms I looked at for comparison cost a lot more than what's in this parts list.
• Wrist and elbow don't move. All five servos go to fingers; the forearm is just structure and servo housing.
• I'd originally sketched out an accelerometer for wrist/elbow motion as a stretch goal, but never got to it — there's no accelerometer anywhere in this build.

Future scope

• EMG sensors instead of flex sensors, so muscle activity drives the hand directly rather than finger bend.
• Haptic feedback to the glove from fingertip force sensors.
• Actual wrist and elbow actuation.
• A wireless link (nRF24L01 or similar) to separate the glove from the hand — this is really what the industrial/hazardous-environment use cases need.

Gallery

Fusion 360 — forearm and open hand, top view	Fusion 360 — side view, index extended
Fusion 360 — final hand and arm assembly	The build — servos in the forearm, tendons to the fingers

References

Prior work I drew on for this project is listed in docs/references.md.