Project showcase
DIY Glove Controlled Robotic Hand

DIY Glove Controlled Robotic Hand © GPL3+

Control a servo motor hand with the power of a glove and DIY flex sensors!

  • 5,728 views
  • 2 comments
  • 31 respects

Components and supplies

Ph a000066 iso (1) ztbmubhmho
Arduino UNO
×1
Project Foam
This can be replaced by any other material that is solid and can be molded into place
×1
Tape
Optional layer to protect the foam/Holds flex sensors in place
×1
String/Fishing Wire
×1
Metal Springs
Thin spring around the length of a finger. Can combine shorter springs together with solder if necessary.
×1
Sg90 servo motor 180 degrees sg90 micro
SG90 Micro-servo motor
×5
12002 04
Breadboard (generic)
×1
11026 02
Jumper wires (generic)
×1
Mfr 25frf52 10k sml
Resistor 10k ohm
×5
Adafruit industries ada830 image 75px
4xAA battery holder
Alternative power supplies possible too
×1
Glove
Glove to control the robotic hand
×1
Paper and Pencil
DIY flex sensor parts
×1
Flexible Plastic Sheet
Allows flex sensor to flex
×1
Zipties or Rubber Bands
Cable organization
×1

Necessary tools and machines

Hy gluegun
Hot glue gun (generic)
4158215
Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires
09507 01
Soldering iron (generic)

Apps and online services

About this project

This project uses budget items and DIY parts to create a fully functional robotic hand that can be controlled by a glove with flex sensors. It is an introduction project to the world of biomechanical engineering and design. Starting from the basic building blocks of foam and string, you will explore how physical mechanics are combined with electronic parts to form an attention grabbing project.

Demo of the completed project

Design

Rudimentary drawings of how the robotic hand and glove controller work. These pictures are not accurate to the final product but provide a basis and explanation of the mechanics behind the project.

Hand Construction

First, create fingers out of foam, springs, tape, and string. Each finger consists of three foam bases (two for the thumb) and a spring embedded through the center of it. String is hot glued to the top foam piece and guided down inside the foam piece. Lastly, tape is used to protect and cover up the foam. I recommend not using insulation foam like I did because it is very difficult to cut into.

It's important to have a section of the spring poking out from underneath the base of the finger. I did not have this for all my fingers so I soldered on another spring to the bottom to increase the length. An alternative method is to use a toothpick as a base, but your hand will not bend on the palm.

Next construct the palm and the arm base. I don't have much documentation of this process, but this should be pretty straightforward. Tracing my hand, I carved a palm like shape to hold all my fingers. Create holes on the top of the palm to hold the fingersThe arm base holds at least 5 servos and an Arduino Uno together. It measures 8x2.5x.5 inches on my project. Make sure the strings are able to be pulled from the base. Use staples on the palm as brackets to guide the strings to servo motors. Create indents and glue down servo motors.

Finger movement demo

Guide the strings through the servo motor arm and hot glue it down when it is taut. Mount the Arduino Uno onto the bottom of the arm and attach a breadboard to the back. Organize wires with rubber bands/zip ties and connect all servo motors to the power rails on the breadboard. Lastly, connect the signal lines on the servo motors to the digital pins on the Arduino board. Use 4AA battery pack to power ONLY the servo motors. Wiring and construction of the hand is done for now. Arduino Uno can be programmed to control the servo motors now.

Glove Construction

The most important part of the glove controller are the flex sensors. Rather than buying 5 sensors for 100 dollars, it's possible to DIY them. This is where you use paper and pencil, flexible plastic, and tape. Follow along with this video to construct the flex sensors. Captions are in English.

Flex Sensor Construction Video

Next, tape down the sensors onto the a spare glove. I had to add another piece of tape on the knuckle, so this image is not the most accurate.

It's important to stay organized, as there are a lot of jumper wires. There is a minimum of 10 wires that need to be attached to the breadboard. Twist wires together to stop them from spreading everywhere. Attach flex sensors according to the picture below. I used five 10kOhm resistors but alternative options work. Take note that this power rail receives power directly from the Arduino pins, not the 6V battery pack.

Coding

In the coding section provided, its important to realize that parameters will be different depending on each flex sensor and servo motor. In order to organize values clearly, I included the flexTest() function to test values for the flex sensors.

For servo motor parameters, I tested the full bend of each finger with the servo motor and decreased the amount of rotation in order to ensure fingers don't extremely overlap with each other. (I have overlapping of the middle and index finger in my demo, but that is due to a loose string on the servo motor that I can't tighten because I ran out of hot glue D:)

Test out the program and change parameters as needed in order to get the best control with the glove. The project is finished now!

Extra Images

Conclusion

This project works OK in my opinion. It is not as refined as I would like, however it does do its job considering mostly everything is handmade. Alternative options like 3D printing or purchasing flex sensor may improve the experience, but they are costly.

Expansions on this project could include muscle control with an EMG sensor. Making the glove controller wireless is possible. Functional wrist and elbow movement would be a challenge too.

Code

Glove Controlled Robotic HandArduino
Code to control the hand and the glove.
Remember to change parameters to be specific to your flex sensors and servos. Use the testFlex() function to determine bounds for when the flex sensor is opened and closed. Input/output pins may vary too.
#include <Servo.h>
//define servo motors 
Servo pinkie, ring, middle, index, thumb;

//define flex sensors on glove (F1 = flex sensor 1)
const int pinkieFlex = A0; //bent - 710, flat - 900 (values vary depending on your own flex sensors))
const int ringFlex = A1; //bent - 920, flat - 965
const int middleFlex = A2; //bent - 966, flat - 993
const int indexFlex = A3; //bent - 808, flat - 870
const int thumbFlex = A4; //bent - 490, flat - 525


void setup(){
  //attach servo motors to digital pins
  pinkie.attach(13);
  ring.attach(12);
  middle.attach(11);
  index.attach(9);
  thumb.attach(10);

  //starting position for all fingers
  pinkie.write(180);
  ring.write(180);
  middle.write(180);
  index.write(180);
  thumb.write(180);
 
  //debug
  Serial.begin(9600);
}

void loop(){
  //testFlex(); //use testFlex to debug Flex sensor values
  //assign fingercontrol function for each finger 
  fingerControl(pinkie, pinkieFlex, 30, 180, 710, 900);
  fingerControl(ring, ringFlex, 0, 180, 935, 965);
  fingerControl(middle, middleFlex, 0, 180, 976, 985);
  fingerControl(index, indexFlex, 30, 180, 850, 920);
  fingerControl(thumb, thumbFlex, 0, 180, 487, 500);
}

void fingerControl(Servo servo, int flex, int s_bent, int s_flat, int f_bent, int f_flat) {
  //use parameters to customize for each servo/flex sensor
    //servo - name of servo (ex. pinkie), flex - name of flex sensor (ex. pinkieFlex)
    //s_bent - servo motor value when finger bent, s_flat - servo motor value when finger flat
    //f_bent - flex sensor value when finger bent, f_flat - flex sensor value when finger flat
  //define flex sesnor and servo position
  int servo_pos;
  int flex_pos;
  flex_pos = analogRead(flex); //read flex sensor value
  //Serial.println(flex_pos); //debug line 
  servo_pos = map(flex_pos, f_bent, f_flat, s_bent, s_flat); //map flex sensor values to servo motors
  servo.write(servo_pos); //write mapped servo value to servo
  delay(100); //delay for efficiency
}

void testFlex(){
  //use serial monitor to calcultate flex sensor bounds - reacts in live time to glove
  int val0 = analogRead(A0);
  Serial.println("");
  Serial.print(" A0: ");
  Serial.print(val0);
  
  int val1 = analogRead(A1);
  Serial.print(" A1: ");
  Serial.print(val1);
  
  int val2 = analogRead(A2);
  Serial.print(" A2: ");
  Serial.print(val2);
  
  int val3 = analogRead(A3);
  Serial.print(" A3: ");
  Serial.print(val3);
  
  int val4 = analogRead(A4);
  Serial.print(" A4: ");
  Serial.print(val4);

  delay(500); //delay for efficiency 
}

Schematics

Circuit Diagram
Circuit itvovy3cgf

Comments

Similar projects you might like

Bracc.ino - Robotic Arm

Project in progress by Basso&Delmoro&Gramaglia

  • 5,890 views
  • 1 comment
  • 24 respects

How to Make a Remote Controlled Robotic Hand with Arduino

Project showcase by Gabry295

  • 63,603 views
  • 6 comments
  • 160 respects

Hand Movement Controlled Robotic Arm

Project tutorial by Roland Pelayo

  • 10,212 views
  • 4 comments
  • 33 respects

DIY Arduino Robot Arm – Controlled by Hand Gestures

Project tutorial by Eben Kouao

  • 15,070 views
  • 9 comments
  • 48 respects

Gesture Controlled Robotic Hand

Project tutorial by Rushabh Jain

  • 5,840 views
  • 2 comments
  • 10 respects

SCARA Arm Controlled by Joystick

by Fil2002 and EnricoTesta2002

  • 3,936 views
  • 1 comment
  • 9 respects
Add projectSign up / Login