Project showcase
3D-Printed Controllable Hand

3D-Printed Controllable Hand © GPL3+

This is a 3D-Printed hand that is controlled by servos and flex sensors.

  • 2,572 views
  • 0 comments
  • 16 respects

Components and supplies

Necessary tools and machines

3drag
3D Printer (generic)
Sewing Kit

About this project

The inspiration for this project came as I was working my way through an Arduino startup/tutorial kit. I was working on a tutorial that used a flex sensor (a sensor that becomes more resistant as it is bent) to control a Servo. The nice part about the Servo is that it rotates only a specific number of degrees and does not run for a set time; in essence it is incredibly responsive to the movement of the flex sensor.

I showed this to Conner and almost immediately he suggested that we could use that to move something like a finger, and we immediately decided that we would 3D print a type of prosthetic hand. I decided that I could make a cardboard prototype that I could use to explore how we would actually move the real thing. In the mean time, Conner, a wizard with AutoDesk Fusion 360, started designing the real hand that we would print.

Very early, I started using a spool concept with string that wraps around the spool and pulls the finger, as seen in this video. The spool consists of a cardboard circle with thumbtacks (I later used four instead of two) taped onto the Servo.

First ever finger movement using the cardboard prototype

I attached the two free-floating pieces in this video onto one sheet of cardboard. I then rigged up a series of alligator clips and wires to a sensor to simulate a soldered sensor, which we would use in our final product. I taped the sensor to my finger to simulate wearing the glove that we would use in our final product, and this was the result:

Sensor alligator clipped and taped to my finger moving the cardboard prototype

This was a big stepping stone in the way of coding and programming, because this confirmed that indeed this concept was possible. At a similar time, Conner had just finished the first prototype of the palm and the finger. It had a few flaws, but it was a great start.

His next prototype included holes through which the string could be threaded through and connect to the servo in the back. The first green prototype had holes where the Servos could be inset.  We quickly realized that there was a high force of friction and so the next version of the green palm had small attachments that a knitting needle was fed through to that the string could slide over the needle to reduce the force of friction.  

As this was going on, I finished making the cardboard prototype. The final version of this prototype had holes in the back that fed into the Servos, much like our final product would.  The cardboard prototype is not nearly as sleek and easy on the eye; it was more a way to experiment with Servo movement. 

The glove itself has pieces of heat shrink tubing sewed to the glove. The first time we did this was pretty hastily and, as seen in this photo, required a bit of patchwork, but it allowed us to use three fingers on the cardboard prototype.

3 finger movement with the cardboard prototype

So after this exciting breakthrough of having three working fingers, I redid the glove and the stitching to make it more effective, with less patchwork.  At this point, we realized that our idea was going to work.  Conner had created the green prototype of the palm, and we were able to start using that after Conner figured out the fingers.

Conner had been working on ways to make the fingers more effective.  The first fingers bent too far back, and because we wanted to use a spring or rubber band to make the fingers come back into place, if they were able to bend too far back not only would it look unrealistic, but the Servos wouldn't be able to pull the fingers.  He experimented with several different methods, but ultimately settled on a snap-in method with C-clamps to hold each joint in place.  After tweaking the design several times, he was able to come up with a really fantastic design that made sure that the fingers could move easily, but also ensured that they wouldn't bend back too far.

I started soldering the flex sensors to longer wires that could connect into the breadboard.  This was not an easy task, especially as someone who has had very little experience soldering, just because the metal tips of the flex sensor are very small and very thin, providing very little room to work with.  The end result was a longer wire that attached to the flex sensor that could connect to the breadboard.

As seen in these photos, the wiring was a mess (and that was only for two Servos and two flex sensors).  by the time I got four of each working, the wiring was a nightmare.  I wasn't concerned at the beginning, because I was only trying to make the servos move and pull the cardboard fingers, and I wasn't necessarily concerned with how orderly everything was.  

As we were beginning to transition to the 3D-printed hand, I realized that this type of wiring wouldn't work because it is too complicated and too difficult to troubleshoot.  I rewired everything with (mostly) jumper wires, and although there is still a lot happening, the wiring itself is much easier to follow.  

We ended up doing even more rewiring to make all of the wires even longer and allow for a more significant distance between the sensors, the breadboard, and the hand.

As you can see in this photo, Conner created 3D printed spools that sat on top of the Servos where the string would wrap around after passing over the knitting needle.  The other photos are of the green palm with the knitting needles in the front in the back.  In the photo of the front of the palm, you can see one of the spools on the left.  The white palm has the same features.  Also, we used rubber bands to create enough resistance to "snap" the fingers back into place after they were finished being pulled by the Servos.  

Literally five minutes after we got the white hand working, we had to present it.  The presentation went really well, and we had all five fingers working.  We decided to let people play with the sensors and move "their own" fingers.  In hindsight it probably wasn't the best idea simply because many of the sensors were damaged in the process of letting other people who didn't know what they were doing use them.  As you can see in this video, we were only able to have one finger working by the end of the presentation because most of the other sensors were so beat up, which is one problem with using these relatively cheap flex sensors.  

Final model with one finger working 

Code

Code for the HandArduino
This is the code that we used to control the hand using the servos and flex sensors.
#include <Servo.h>  // servo library



Servo servo1;
Servo servo2; 
Servo servo3;
Servo servo4;
Servo servo5;

const int flex = 0;
const int flex2 = 1;
const int flex3 = 2;
const int flex4 = 3;
const int flex5 = 4;


void setup()
{
  

  servo1.attach(9);
  servo2.attach(8);
  servo3.attach(7);
  servo4.attach(6);
  servo5.attach(5);
 
 Serial.begin(9600);

 
 
}


void loop()
{
  int servo1position;
  int servo2position;
  int servo3position;
  int servo4position;
  int servo5position;
  
  int flexposition;
  int flex2position;
  int flex3position;
  int flex4position;
  int flex5position;
  
  flex2position = analogRead(flex2);
  flexposition = analogRead(flex);
  flex3position = analogRead(flex3);
  flex4position = analogRead(flex4);
  flex5position = analogRead(flex5);
  
  servo1position = map(flexposition, 780, 870, 0, 180);
  servo2position = map(flex2position, 795, 885, 180, 0);
  servo3position = map(flex3position, 769, 880, 0, 180);
  servo4position = map(flex4position, 780, 840, 180, 0);
  servo5position = map(flex5position, 755, 855, 180, 0);
  
  servo1position = constrain(servo1position, 0, 180);
  servo2position = constrain(servo2position, 0, 180);
  servo3position = constrain(servo3position, 0, 180);
  servo4position = constrain(servo4position, 0, 180);
  servo5position = constrain(servo5position, 0, 180);
  
  servo1.write(servo1position);
  servo2.write(servo2position);
  servo3.write(servo3position);
  servo4.write(servo4position);
  servo5.write(servo5position);
  
  delay(200);
}

Schematics

Schematic for one flex sensor and one Servo
This diagram shows how to wire the Arduino so that one flex sensor can control a Servo
Schematic

Comments

Similar projects you might like

Animatronic Hand

Project showcase by Team Nuts and Bolts

  • 1,153 views
  • 0 comments
  • 4 respects

How to Make a Remote Controlled Robotic Hand with Arduino

Project showcase by Gabry295

  • 35,368 views
  • 5 comments
  • 110 respects

Tito - Arduino UNO 3D-printed robot

Project tutorial by Camilo Parra Palacio

  • 10,633 views
  • 10 comments
  • 39 respects

3D-Printed EEG-Controlled Prosthetic Arm

Project showcase by Ayush Kapur

  • 6,335 views
  • 1 comment
  • 47 respects

3D-Printed RGB Wallet

Project tutorial by Alex Wulff

  • 1,915 views
  • 0 comments
  • 8 respects

Robotic Arm And 3D Modeling

Project showcase by Samuel Jasmer

  • 4,283 views
  • 3 comments
  • 20 respects
Add projectSign up / Login