Modular Robotic Hand & Arm (With Extended Range of Motion) (3D Printed)

Hello everyone! This is my prototype hand and arm prosthesis that I have been designing for several months now. It is still a bit of a work in progress, and [[since I'm finishing up with college classes for the semester]] I haven't yet had time to develop its full functionality. Aside from being essentially fully 3D-printable (with the exceptions of the electronics and actuation wires), it is designed to be capable of all the motions of a healthy human hand and arm up through the elbow (which I am currently designing). It also supports additional motion capabilities that most robotic hands do not have: it can bend and straighten all the fingers independently, but it can (will be able to) also point them at different angles while straight - I'm still getting the code worked out for this. It can (will be able to) also spread apart the fingers, a movement I have only seen on 1 other robotic humanoid hand (although I still haven't gotten it to do a proper Vulcan greeting). In the long term I plan on building a motion control glove and continue construction up to at least the shoulder, and possibly make a control system utilizing a Kinect or Leap Motion. For now, though, it can perform most hand motions by manually entering commands to run preset motions or to control each servo individually.

My main goal is to have it mimic the motion of a human hand and arm as closely as possible, so each joint is placed as close as I could get it to its location on an actual human (me). After plenty of redesigning I managed to fit all the finger control servos into an area just slightly larger than my palm - the thumb takes a bit more space on the side and the part all the fingers attach to extends a little to far from the palm. The fingers all spread away from the middle one, and the thumb rotate about 2 axes in a manner similar to the human thumb, although the axes are at slightly different angles. The wrist rotates about both axes and is attached a bit farther back than a human hand for the up and down motion, but is about in the right spot for side-to-side twisting. The whole thing can twist at the base of the arm, which is a couple inches away from where the elbow joint will be.

The entire arm was drawn and rendered in Inventor Fusion and printed on a Solidoodle 2. The final parts cost is somewhere around $100, although I spent more on development and shipping. I've been working on this (part-)part-time for several months, most of which has been the design process. Your results may vary but it will probably take significantly less time to build your own than to design it from scratch.

One unique aspect of this arm is that it is constructed in modules, so that parts can be modified as necessary to change the desired size of the arm. A spacer could be added to make it longer, or the wrist could be replaced entirely without needing to redesign the hand. Once the entire arm is complete, this would also allow for attaching application-specific tools to the elbow joint or elsewhere.

UPDATE 6/5: Making some progress on the elbow joint! It will probably need to be redesigned still but I've added a couple renders of my latest version in steps 2 and 16 (conclusion).

UPDATE 5/16: Added a video and updated the program for the Wave function (no quantum physics involved, sadly). The program also contains an unfinished gesture that sort of works, but I figured it would be nice to at least be able to wave your robotic hand. Note that the function does not clear (coast) all the servos when the waving is finished... yet.

So, you want to build one? Go on to the next step and get started!

Due to me having limited access to tools early on, I actually managed to complete most of this project using only my 3D printer (obviously), a pliers, a carpenter's knife and a Phillips screwdriver. Of course, that was certainly not ideal and I did end up using more tools to finish it, so the tools you'll need are:

• 3D printer or access to one
• Several screwdrivers, both flathead and Phillips and both large ones and precision ones
• Pliers, both large and needle-nose
• Carpenter's Knife
• Dremel/Rotary Tool and kit
• Drill and bits from 1/32 to 1/4
• Digital Multimeter (DMM)

As for parts, you'll need:

• All 3D printed .stl files
• 6x32 bolts: 12 1" and two 1.5" and nuts
• 1 Wood screw, long enough and small enough diameter to be used as a servo arm attachment on the full-size servo
• 15 Micro Servos (TowerPro, etc.) and arms + mounting screws
• 1 High Torque Full-size servo
• Arduino Uno or similar 5V, pinout-compatible, same PCB shape development board
  • I actually tried controlling the hand with an official Uno and a Chinese clone, and the clone didn't have as many problems with current spikes as the official. Odd, but that's what worked for me...
• Sparkfun TLC5940 PWM Shield (or equivalent - Adafruit might sell one but I don't think it's a shield)
• Micro USB Breakout board
• Straight headers and Angled 3-pin headers
• Several wires
• Capacitor - I used a 220uF electrolytic, but other sizes down to at least 47 uF should work as well
• Phone Charger Battery Pack - should provide at least 1A output and preferably support several Watts
• Steel Wire, ~10 lb strength
• Assorted Rubber Bands - for easy removal of parts, and tensioning

The servos can be found on eBay for ~$2 apiece. You'll probably want extras since I burnt out a couple experimenting with positioning, and while they are strong enough to move this thing around, they are still cheap mechanically as well as monetarily. As a general rule, try to avoid moving or holding the servos past their mechanical limits, as they do heat up rather quickly.

The shield is designed for LEDs but also works for servos - this is specified on the product page, so you shouldn't have to worry about burning it out. The voltage regulator does heat up a bit when more than ~10 servos are active at a time or if several are trying to move/hold past their limits, but the TLC5940 itself doesn't get too warm.

The capacitor is to protect against current surges when the external power supply is first switched on; without it, the Arduino can sometimes reset when the battery pack is activated. Even with the capacitor I still have had some issues with the Arduino resetting, which I'll discuss in the electrical part of the guide.

I had a little trouble finding a battery pack that would work since even the majority of the 16 servos moving or holding at the same time draws up to around 0.25A with the default shield current supply setting, but even then most of my battery packs rated at 1A still shut down from current protection when I tried to use them. If you get a big 10Ah or larger pack on Amazon or eBay, etc. you probably won't need to worry about this.

For the wire, I originally tried a much more flexible material that didn't work well in compression. I also tried a 25 lb wire, which was far too strong for the servos to move repeatably. The 10 lb wire seems to be working quite well, although you could maybe use a weaker wire if 10 doesn't work for you.

And finally, the 3D printed parts take a considerable amount of time to fabricate, and although I did reprint most of them, you should still plan on at least 20 hours of print time. Some of them have tighter tolerances as well, so you'll want to be able to print good circles and avoid the bottom layers peeling up. I used a higher end printer for the smaller precision parts, but for the larger ones I used my own machine, which has trouble doing perfect circles and still suffers from the layer peeling issue (no heated bed). If you use a printer that doesn't have these problems, you should be able to get a much higher-quality finished product.

Most of the parts can be printed regardless of the quality of your printer, however some structural or load-bearing parts need to be made with more care. One issue I'm still dealing with is the friction between the joints of the finger segments - there needs to be clearance there to avoid friction, so if you get support material inside the finger joint connections make sure to smooth it out before assembly. You will need to print out 7 of the Pointer 1 parts, 2 of the Pointer 2 and 5 Pointer 3.

The Joint Pins for the finger segments all need to be very cylindrical to reduce friction, but strength is not as important - I've actually had several break in the fingers without causing too much trouble. You'll need at least 14 of these parts, but they're easy to print together and would not take long individually.

In the current design, the Forearm-to-Elbow Connector Rod is responsible for supporting a great deal of the load of the arm when it is being held horizontally, and should be printed horizontally on the print bed for more strength. This will probably end up being redesigned to not hang so much weight on the rod and servo.

If you have problems with parts peeling up off the print bed (like I do), be careful to place the part on the bed in such a way that essential components such as bolt holes and hooks won't be affected by the peeling - you can see my Arduino compartment is only connected by two of the four bolts on both sides, and there was significant peeling on some of the wrist components. It's not a big deal if it happens, but it does make assembly a bit harder.

NOTE: I didn't realize until a couple days before I published this Instructable that the carpal bones are actually the ones in the back of the palm, and the metacarpals are the ones that constitute the palm, so my naming convention is anatomically incorrect. So, medical students, no need to mention it - I'll get it right with the rest of the arm!

ALSO NOTE: If I included any part files that don't match up with my printed ones please let me know - I have several redesigns of most of them and with .stl's it's a little more difficult to identify the correct one.

One nice benefit of this prosthesis being modular is that if you only want to build the hand down through the palm or wrist, you can do so without needing to substitute different parts, and can add on to it later. I've written this Instructable in Parts so that you don't need to sift through the whole guide if you only want to build the hand and wrist, for example. This first part will detail how to build the hand.

Each of the fingers is constructed in essentially the same way, so I only have photos of the pointer finger assembly. If it's still unclear I can get more pictures of the other ones, but it's basically the same process. Also, when printing the CAD files, all 5 fingers use the same "Pointer 1" piece, the pointer and small fingers both use the same "Pointer 2" as their second segments, and the middle and ring fingers all use the same "Middle 2" part for their seconds. All 5 fingers use the same "Pointer 3" part for the third/final segment. To make that easier, here's a list:

• Pointer: 1,2,3
• Middle: 2,2,3
• Ring: 2,2,3
• Small: 1,2,3
• Thumb: 1,3

Each finger (except the thumb, covered separately) requires 3 Joint Pin parts to connect the segments (2nd picture). You can substitute a short 1/8" bolt here, but these 3D printed pins work just fine. As previously mentioned, it is very important that there is as little friction as possible in the joints - they should move freely by hand (that is, manually - no pun intended) within their ranges of motion. To ensure this, make sure the joint pins are as cylindrical as possible and there is clearance between the connecting surfaces of the segments. You'll probably find it easier to fit the pins in if you drill out the holes to 1/8", unless your printer has exceptional circular tolerances.

Make sure to use the correct parts for each finger, otherwise it might look rather deformed and not move properly. Once you have assembled the 3D printed parts, slide the servos into the slots in the carpal (the larger piece) in the same manner as the last picture in this step. The servos must be arranged properly or else the fingers won't fit together well in the palm, if at all.

Before attaching the wires and servo arms, the finger should be in the correct orientation: curl it inwards as far as it will allow when attaching the top wire, and straighten it when attaching the bottom wire. This will ensure that both servos can rotate through as much of their range of motion as possible.

In the pictures I already had the correct length of wire required, but when you're pulling it off a spool it helps to thread it through the loops on the fingers from the back of the first segment up through to the third, then twist it into a good hook (needle nose pliers!) that won't come undone and won't give much when being pulled or pushed. Once you get it tied off at the end of the finger, let out enough to reach the servo arm and then enough extra to hook it through the arm. You can always cut any extra off the wire, which is much easier than threading a new one.

NOTE: I tried printing a carpal piece for the pointer with loops on the top and bottom to see if this would help with the range of motion. The top part helped a little, but the bottom ended up restricting the motion of that servo, so overall it's probably not worth threading through those loops.

Attaching the single arms to the servos gets a little tricky, and I spent quite a bit of time reorienting the arms to get them to move within the correct range of motion. To make it easier to calibrate later, you can wait to screw the arms to the servos until after running the setup program to move all the arms to their starting angles; otherwise, a good place to start would be attaching each arm to the servo such that when the servo is at 0 degrees it is pointing directly to either the front or back of the palm.

The thumb is assembled in mostly the same way as the other fingers with some additional parts for the additional rotation axes. Follow the previous step to assemble the finger portion, then insert the Thumb Lever 2 part into the slot on the carpal. I had some issues with tolerances on my prints, so it doesn't quite fit in as far as it should or come out very easily. Insert a single servo arm into the slot on the bottom of the Lever and make sure the channel on top lines up with the hole in the centre of the servo connection cylinder.

For the intermediate lever assembly, attach a servo to the Thumb Lever 1 part as shown in the picture, and screw down at least 1 of the sides. Insert a single servo arm into the slot on the side and then either attach it by a screw or glue it in place. There is a channel through the other side of the servo arm compartment to allow access to the screw attaching it to the servo, so make sure the channel lines up with the hole in the centre of the servo arm.

On the Carpal Junction, insert another servo into the side compartment as shown in the picture, making sure to first thread the wires through the hole in the side. In my assembly I had already fitted the servo in place pretty tightly, so I didn't want to risk damaging it or the wires by pulling it all the way out (tolerances!). Attach the servo arm in the channel of the Thumb Lever 1 to this servo, such that 0 degrees is at the angle shown in the final picture. Finally, attach the servo arm in the Thumb Lever 2 to the servo in the Lever 1 as shown in the first picture - the angle should be such that the orientation in the first picture is almost at the maximum angle of the Lever 2 servo. Again, it's much easier to calibrate these servos by running the setup sketch and then attaching the arms.

Each of the fingers connects to its corresponding bolt hole in the Carpal Junction. If you're just building the hand, 1" long 1/8" bolts (6x32) work just fine, but if you're planning on building the wrist you'll want to use 1.5" bolts for the pointer and small finger connections.

A note about threading: For these connections as well as most of the other bolt connections on the arm, I recommend at least one of the two connecting parts should have a threaded hole. This way if the nuts come loose nothing will fall off (right away at least). When printed, the holes on most if not all of the parts are just small enough so that you thread them by driving a bolt through it. Alternatively you can drill out a hole to allow for easier assembly, but be aware that once you drill out a hole to a larger size you won't be able to thread it again, at least not as effectively as before. The two places I'd actually recommend drilling are in the fingers and in the side-to-side wrist bolt hole on the Carpal Junction, which helps reduce friction in those joints.

Moving on, if either the finger or the corresponding bolt hole on the Junction is threaded, make sure to place the parts as close together as possible before screwing the bolt through, as shown in the 2nd picture, otherwise you will probably need to either restart or wreck the threads on the finger to get the bolt all the way through. Tighten them as necessary, but leave a little slack to allow them to spread apart from the spread servo.

Also, to keep the fingers from spreading out too much on their own, you can stretch some rubber bands around the hand to keep it together. This is especially important for the thumb, which (in the current design) is still a bit loose.

This feature is still in development, although I do have most of the design work done for the levers between the fingers - the yellowish parts in the second picture are my first attempt, but they ended up failing due to structural weaknesses (thin walls). There are still some considerations to make for these parts when building the rest of the hand, however.

If you're building the wrist as well, make sure you put the connection bolt through the hole at the bottom of the Carpal Junction before fitting the spread servo in place. NOTE: The CAD file may or may not contain this hole, so you might need to drill it out manually - placement isn't an issue as long as the head can sit low enough inside the servo compartment. It's even easier if you wait to fit this servo in place until you've attached the wrist.

And that's it for the hand portion! Awesome job! If you're good with what you've got so far you can skip to Part 3 for the wiring, otherwise keep reading for how to build the wrist.

The wrist is much simpler than the fingers and palm, and is much easier to put together - there are only 2 parts, 2 servos and 2 wires. I originally designed a direct-drive setup with the tilt servo, but ended up burning it out when trying to tilt the hand up (moral: don't use direct-drive to lift stuff with low-torque motors). The new model is designed to fit together in several different orientations so that it can be used on a right hand as well (foreshadowing!). The arrangement in the third picture is the one I used, though, and works best so far.

To connect the parts, insert a bolt through the side of each part corresponding to the fourth picture, then bring the two parts together and finish screwing the bolts into the other part (5th picture). It's much easier to assemble if you use the alignment trick from the step on attaching the fingers to the Carpal Junction.

The servos should drop right into place on the wrist parts, although, again, I had issues with tolerances that made fitting them into place difficult. As mentioned earlier, affixing the servo arms is much easier after running the calibration sketch, but the default angle on the up and down tilt servo (somewhere around 90 degrees) should be similar to that of the 4th picture - this allows the wrist to tilt down farther than it can tilt up, just like a real human hand does (comfortably, anyways). Be careful not to angle it too far back, or it can bind up when tilting upwards. Finally, it's probably easier to cut the wires on the servo arms after attaching the wrist to the hand - the important thing is that they should be able to reliably move the hand.

The Wrist Forward Connector attaches to the Carpal Junction on the palm side of the hand via the bolt underneath the spread servo. Again, the alignment trick is very helpful here if the hole on the Junction is threaded as well as the hole on the Forward Connector (which should be threaded either way).

The wires from the side-to-side rotation servo should loop around the 1.5" long bolts holding the pointer and small fingers to the Junction, with a nut above and below the loop. Make sure that the servo is capable of rotating the hand through a sufficiently large angle before cutting the wires.

That's it for the wrist! Nice work! Now on to Part 3 for the controller compartment.

If you are simply wanting to be able to control your hand from a computer, this portion is not really necessary except as filler space to the Forearm to Elbow Connector; however, it is a great way to make the whole thing more self-contained and allow for better wire management. I actually did not do as much work on the design of this part, so it could probably be modified to fit more components more effectively, or hold a battery pack in place better. But it works, with the exception of some of the bolt holes on mine being rendered useless from the bottom layers of the print peeling up off the bed.

The compartment is the only part you need to print here, but make sure the sides that attach to the rest of the arm turn out well - if you don't have a heated bed, I'd recommend printing it with one of these sides face-down on the bed. It will probably peel up, but all the bolt holes should still be accessible. The way I printed mine led to 2 of the holes being shifted upwards out of range of the other connected parts.

NOTE: Make sure that you connect the compartment to the rest of the arm before inserting the Arduino and shield! Use the alignment trick from earlier!

Now comes the electrical engineering part of this project. This shield is capable of supplying up to 120 mA to 16 LEDs or servos, which can be drawn either from the Arduino or an external supply; however, a built-in resistor sets the current to 17.8 mA per channel, which works fine (and is changeable). Of course, the Arduino can only source 200 mA, which is less than the 17.8x16=284.8 mA required for maximum power with all channels active. Even though you probably will only rarely have most or all of the servos powered at once, and even though they don't normally draw the full 17.8 mA, they will draw more current than usual if held or moved past their limits, which can happen when moving or calibrating. Therefore, an external source is the best way to go as far as a power supply for the hand.

To start, assemble the shield as shown in the second picture. The angled headers should face away from the voltage regulator, while the other top pins are nonessential - the 2 lone pins are for changing the max current output using a resistor, and the other 7 are for connecting another PWM chip without needing more pins from the Arduino. For the external VIN it's probably OK to simply solder in the USB breakout board to the board, but as I was testing different supply methods I added a screw terminal instead. Include a capacitor to reduce any current spikes to the Arduino caused by turning the power supply on. And of course, solder in all the pins on the bottom to plug into the Arduino.

The shield is capable of powering the Arduino from the external source when the Vcc select switch is in the VIN position, but I've found that the Arduino usually needs to be powered separately at least to turn it on, after which the shield should be able to maintain a sufficient power supply. Depending on your battery pack, you may want to try switching the Vcc select switch between VIN and 5V (direct from the Arduino), as I had a few that powered the arm better that way (although the regulator did heat up quite a bit - probably not the best idea).

Due to a small design flaw (tolerances!), there is only a small amount of space between the edges of the Arduino board and the sides of the compartment walls, which is taken up by the heads of the bolts attaching the compartment to the rest of the arm. Thus it is still possible to fit the board into the compartment as-is, but it is rather tight; if you need, sanding down the heads of the connector bolts would probably solve the problem. After you get the board into the compartment, you can either screw it down with bolts or sit it on the mounting pegs and hold it down with rubber bands for ease of removal - since I'm still developing this part, I went with the latter option. The shield should then fit right on top.

The placement of the battery pack will largely depend on your specific charger, but with the current design it works to simply hold it to the palm side of the compartment with the Arduino rubber bands. I might end up adding another part designed to hold a specific battery pack, but it's not top-priority for now; anyways, battery packs come in many different sizes and it wouldn't really be practical for an Instructable.

This step is crucial to correct operation of the arm, and to prevent you from needing to rewrite code unnecessarily. The servos must be connected to the shield in the order shown in the first picture (#15 is for the Forearm Twist servo in the next Part of the Instructable). There shouldn't be any issue of wire length, but to be safe you can position the hand in such a way that all the servos will be as far away from the controller as possible before plugging them in. If you're going for good wire management you can also try to bring all the wires between the thumb and wrist as shown in the 2nd picture.

And you're all set to start moving your arm around! Great job! If you want to go one step further (metaphorically speaking) you can build the Forearm to Elbow Connector in Part 4 of this Instructable to allow your arm to twist, and to make sure you're up to speed when I finish the elbow.

This is the farthest I've gotten on the arm at this point, and the last assembly you'll need to give your arm all the motion capabilities of a human arm up to the elbow. I'll probably end up redesigning some of this portion of the arm as it has some structural weakness - a lot of the weight is put on the shaft of the (relatively expensive) servo, and the rest is on the small FTOEC rod. In the meantime, though, this version still works, although I ran into some issues with the FTOEC rod fitting together with the twist servo holder.

IMPORTANT: The FTOEC rod is a structural component, and should be printed horizontally on the print bed to give it the highest strength along the direction it will be bending in. Also, despite the fillet on the transition from the large to smaller radii causing some issues with the rod's revolution about the servo, it is a structural design element and should remain on the part, even though it does cause some trouble with twisting (more on that next step).

Start by fitting the servo into the holder part, making sure to thread the wire through the small hole in the bottom, then use some of the mounting screws to fasten them together. Be careful about using the screws on the side close to the arc: it is a bit hard to tell from the pictures, but the 3rd photo shows a bit how the FTOEC rod can get stuck on the screw holding the servo in place, preventing the servo from turning, which draws more current and can cause the Arduino to reset.

To insert the FTOEC rod through the arc, push it through with the lip along the arc and then twist it back out once it's on the other side. The rod needs to be able to travel through the arc as the servo turns, so position the servo arm such that at one end of its range of motion the rod is at the same end of the arc. Afterwards, position the servo arm such that the Elbow Connector fits with the FTOEC rod on the bottom (opposite from the side indicated with an arrow in the pictures) and screw the plate to the servo through the servo arm.

This part is rather difficult to describe verbally, so hopefully the pictures and annotations make more sense. The goal is for the rod to be able to move through the arc from one end to another while the servo turns, with the rod always on the bottom of the arm. My original design had the rod on top (in tension rather than compression), and it still might be possible to reorient the parts to do so, but I accidentally drew the parts such that the rod would swing around the other side of the servo in that configuration. Anyways, this part is likely to be redesigned in the near future, so it's not a final design.

AND THAT'S IT FOR HARDWARE! AWESOME!!! Now all that's left is to program it! *gulp* Although I can't do anything too fancy with it yet, I do have a good start on a code that will allow you to program in motions and control the arm fairly easily. On to the next step!

The essential part of any Arduino project... other than the Arduino, of course. This setup code will allow you to perform a number of operations with the hand. When powered up, it will first return all the fingers as well as the wrist and forearm twist servos to a default position, which can be configured in the array at the top. By using the Serial monitor you can control any servo individually by specifying a servo and an angle to set it to, which is incredibly helpful for calibration. You can also use the curlPosition function to curl each finger (including the thumb) by a specified percentage. There are still some bugs with this one, namely that the ring finger will straighten at 100% curl and curl at 0%. You can tweak this function by changing the limit arrays at the top of the code. And finally, I included a curl test sequence that you can use for a quick synchronized motion test. There are more notes in the code to provide better context.

Also included with this Instructable is a calibration table for default, max and min positions for all the servos, as well as directions for curling and uncurling all the fingers. Do note that these values are for my specific hand and might be different for yours, but they should give you a good place to start. Also this document was from before I implemented the spread function, thus there is no data for that servo. If you have any comments, questions, concerns, or suggestions about the code please let me know! I'm still actively working on this project (as of May 2016) and I'd be glad to get some feedback, particularly on the coding and electrical portions.

This was and is definitely my most in-depth engineering project to date, and I've learned a TON about design and controls. If there's one thing I've especially been made aware of, it's that TOLERANCES ARE ESSENTIAL to design, especially with a low-accuracy manufacturing device like my 3D printer. Most of my parts were designed to be fit together exactly, with little to no clearances or room for error, which ended up causing a lot of headache and required a lot of Dremeling to resolve.

I am still actively working on this project and will post updates as I finish them. I'm hoping to get more coherent motion out of the whole hand and am also in the process of developing a modular elbow joint. I already have most of the parts necessary for the upper arm + elbow, so I just need to finish the design and print them out. Also, my printer has recently been experiencing some technical difficulties with large objects, so there might be some delays due to that. [[With school finishing up for the semester, though,]] I'll have much more time to work on this project, so hopefully I'll have another update [[within the month]].

So the morals of the story are,

• Remember to consider manufacturing tolerances in your designs
• Get a heated bed for your 3D Printer if you don't have one
• Don't use direct-drive to lift stuff with low-torque motors
• Start on a big project while you still have plenty time before the end of the semester
• Learn from your mistakes - just about every part on this arm was printed at least twice and redesigned at least once!

If you have any questions I'd love to hear them and do my best to answer. Thank you very much for reading, and stay tuned for the continuation!