Final Blog Post - 1st Prototype Assessment and 2nd Prototype Considerations

1st Prototype

To conclude the 22.201 Mechanical Design Project, we have included a real picture of the final assembly and a video of the project in motion, powered by its accompanying Arduino component:

The completed mechanism assembly

As one can see by the video, the motion is not 1:1 as was the design intent, but the general idea was achieved.

The main areas of assessment are in the mechanism (specifically the design, assembly, and implementation of the knuckle part) and the Arduino component.

The Mechanism

At the time, the design of the knuckle seemed viable. However, it was difficult to achieve a sense of scale for the actual size of the part, which was incredibly small. The part was made to fit a 5/8 inch dowel, and some of its features were extremely small, such as the triangular nubs that prevented rotation past a certain point and the pass-through holes through which fishing line would be run. Several of the 3D-printed parts broke simply because there was enough material for the part to be strong at certain areas (one such example is the loops through which the pivot axis lies).

In terms of the assembly, using several parts such as machine screws, washers, and lock nuts to fasten all of the parts together proved to be tedious and cumbersome. The washers became necessary to prevent translation of knuckle pieces in the case of shear forces, which were due mainly to the elastic band if not aligned exactly along the length of the finger assembly. Because of the washers, the lock nuts could not actually achieve a locked position (which is where the threads of the machine screw reach the nylon in the lock nut and "lock"). All throughout assembly and testing, the nuts would fall off due to the rotation of the knuckle joints.


Close-up of the hardware required for each knuckle

Another major issue encountered was the limited range that the servos could pull the fingers. Pulling the finger from a completely straight position to a completely closed (curled up) position was not fully achievable, even considering that the design was intended to allow for small changes in angular position of the servo to equate to larger changes in the displacement of the string and thus the position of the finger.

The Arduino/Electronics

In terms of the Arduino and the electronics, the servos perform very well on their own in terms of torque, but power consumption between the servos and the radio transmitter and receiver pair became a constant issue. Though we may have been able to bypass the issue using a 4-AA battery pack (hovering around 6V in output voltage), it would seem that further investigation into properly powering the entire system is necessary.

Wiring of the project was also very cumbersome, due to the large amount of wiring needed. Each servo motor and flex sensor requires 3 connections: power, ground, and the signal/data connection. Having 5 of each (although we only reached about 4 of each) would have been very messy. Shown below is just a picture of transmitter and receiver systems, respectively:

The RF transmitter is barely visible through the mess of wires



Jumper wires became cumbersome, in addition to the hookup wire used with the servos

When first hooking up the gloved flex sensors to the RF transmitter breadboard and connecting the RF receiver breadboard to the servo motor, it became apparent that calibration of the flex sensor was needed. The SparkFun guide recommends a flex sensor range of 600-900, but it became apparent in previous tests that 600-900 was not an optimal range, that is, for the flex sensor that was tested. While calibrating multiple flex sensors, we discovered that each flex sensor needed to be calibrated slightly differently i.e. some flex sensors had larger ranges, some had similar ranges but at different minimum and maximum values.

As stated earlier, the motion of the robotic hand in relation to the human-worn control glove was not 1:1. A contributor to this is the radio frequency signal delay, which ranged anywhere from 1-2 seconds when the RF link pair were within 6 inches of each other, and could stretch to 3-4 seconds if the pair were between 6 and 12 inches. Any further than 1 or 2 feet, and the signal was not even received in some cases.

The budget for the entire first prototype, which we estimated to cost about $100, was not exceeded, and if it did, did not exceed by much. The largest cost was the purchase of the servo motors, which were about $60.00 for 5 servos at around $12 each. The remaining cost comprised of miscellaneous hardware and electronics, which included machine screws, wood screws, washers, lock nuts, hook-up wire, 60/40 solder, and lumber.

2nd Prototype

Considerations for the second prototype must correct the issues experienced in the mechanism during physical assembly of the first prototype, specifically for the design of the knuckle, as well as streamlining portions of the Arduino and electronics components. Shown below is one possible second prototype design for the knuckle:

2nd Prototype Knuckle Design Part File



2nd Prototype Knuckle Drawing

We've also included a fly-around video for viewers to more clearly see the new features included in this 2nd prototype design:

In order to avoid printing extremely small details (that is, thin nubs and sections smaller than 0.10 in.), the overall diameter was increased to 3/4-in. to increase to overall size of the individual features. Care was taken to minimize these extremely small features, such as substituting the smaller triangular nubs that prevented rotation past a certain point for a much larger press face. The rings through which the pivot axis and pin will insert have also been increased in thickness. Additionally, we should consider printing the entire hand out of plastic, which explains the extended length of the part (around 1 inch in total length)

Material was cut along the length of the finger on the press face (the fileted, polygonal cuts) in order to minimize volume, but further analysis would be required to see if the strength of the finger is not compromised by such large cuts in volume. In any case, the reduction in volume may not even be necessary.

For ease of manufacturing and assembly, we have maintained the ability to take two identical part copies, turn one 180 degrees, and then fit each part into each other in order to share a pin as a central rotational axis. However, instead of machine screws, lock nuts, and washers used in the first prototype, a better idea may be to explore the use of quick-snap plastic binding posts, which can be found in various sizes at McMaster-Carr:

Plastic Binding Posts (Removable)

Reducing the number of pieces of hardware required for assembly wills save both time and money, considering that plastic was chosen, as well as the choice of removable caps in case of mistakes. However, this cost may be offset by the added cost of printing much larger plastic parts using the 3D printer.

The second prototype knuckle design should (hopefully) fix several of the aforementioned issues in the first prototype, but is certain to carry its own unique and unpredictable issues.

Another consideration would be a laser-cut plate that would act as mounting points for the servos, assuming we utilize machine screws to fasten the servos to the plate. Shown below is a quick rendering of the motors used in our project (Parallax Standard Servo for purchasing), the to-be-laser-cut mounting plate, and the assembly, which requires both of the aforementioned parts:

Parallax Standard Servo

Laser-cut Servo Mount Idea

Servo Mount Drawing

Possible Idea for Servo Mount Assembly

It may also pay to consider mounting the servos sideways (which would then require a mounting plate modified from the one shown above) and attaching some sort of adapter that increases the lever arm of the servo. This could solve the issue of the servos that control the fingers not pulling the strings far enough. Exact measurements of the 4-point servo arm on the Parallax standard servos would be necessary for good attachment points. Shown below is a rough draft (dimensions not to scale) of a possible servo adapter, which would be mounted to the servo arm with small machine screws or perhaps binding posts:



Possible idea for a servo adapter which would lengthen the lever arm of the servo

In order to mitigate the amount of wiring necessary on the receiver end, it may prove useful to invest in a blank printed circuit board, which we could solder many of the more permanent electrical configurations. This would certainly save time when testing and calibrating the system, at the small cost of a few dollars and some labor. An option that could be paired with a blank PCB could be an Arduino servo shield, such as the one from Adafruit industries that accepts up to 12 servo motors, and plugs right into the pins of the Arduino. In any case, reducing the amount of temporary wiring would be greatly beneficial to the second prototype.

Adafruit 16-Channel 12-bit PWM/Servo Shield

For the RF transmitter end, which is essentially the control glove, several ideas could be implemented. Flex sensors are very fragile; too much flex at the base (where the connection prongs jut out) could damage the flex sensor. This was an issue after soldering the hookup wire, which was very stiff compared to jumper cables, when the flex sensors would bend and twist in awkward positions if the control glove was not oriented in some optimal direction. One alternative would be to substitute flex sensors for either rotary or linear potentiometers:

10K Ohm Rotary Potentiometer for $0.95
Slide Potentiometer for $2.50

Of course, this would require a re-design of the control glove. Originally, the idea to have the user able to wear the entire transmission end (control glove, Arduino, breadboard/PCB, transmitter, and power source) was discarded. However, in combination with aforementioned options to clean up the wiring situation, it could prove better. Several mounts would have to be designed and 3D-printed, but essentially, the user could wear a control glove and some sort of plate (strapped to the wrist like a watch) that would somehow hold the arduino, breadboard/PCB, and power supply. Depending on whether we decide to stay with flex sensors or explore the option of rotary/linear potentiometers, it may change how we determine how much a finger is bent. One such idea could be similar to a portion of an exoskeleton hand, which would involve not sensing how much a finger bends via flex sensors, but having the user pull or bend some larger mechanism that then changes the position of fingers, which may work using springs, several 3D printed parts, or more cables.

Implementing these new ideas would certainly cost more, but the end goal of a robotic hand that copies the exact motions of a human hand would be more closely achieved.

Week of Dec 9

Meetings

Dec 10

Members present: Kendrick, Dat, Usama, Steven

Today we began the final assembly of the mechanism in combination with the Arduino. Much of the time was spent calibrating the flex sensors (each one had a different range) to the position of the servo motors. We did, however, finish calibration and were able to record a few videos of the control glove and robotic hand working in tandem, if only for a few runs.

Dec 9

Members present: Usama, Dat, Kendrick, Steven

While Usama continued working on the Arduino code, Kendrick, Steven, and Dat continued physical assembly of the physical arm and fingers. Assembling the mechanism became very tedious and difficult due to the all of the small pieces of hardware required to fasten each of the parts together. A few parts also broke during both transportation and assembly. These two major issues, the strength of the parts and the amount of hardware required for assembly, are important considerations to note for the second prototype, which this project requires groups to think about, but does not require groups to pursue (since the semester is quickly coming to a close).

The rest of the week will be dedicated to finishing the assembly, evaluate the first prototype, and prepare for the presentation on Friday.



Usama:
Time spent: 12 - 14 hrs.

This week consisted of the largest amount of code development thus far. Having isolated many of the initial issues with the RF circuitry, it was time to begin coding for the final system. This involved the development of two separate codes, one for the transmitting arduino and the other for the receiving arduino.

Having learned from the previous week, I began by compiling code to effectively transmit data to power the movement of a single finger, i.e. a single servo motor. This approach allowed me to initially isolate and debug any and all transmitter / receiver issues. Once I had done this, I moved towards moving more than one finger, finding new obstacles along the way. It turned out that the process was far more challenging than I had initially expected.

For the transmitter, I began by performing an analogread and then converting the integers into a character array. I then transmitted this array to the receiver and decoded it there. I maintained serial prints on both sides of the system to monitor how the data was being sent and received, and whether or not the initial and final values were consistent with one another.

The system was relatively simple to code for one analog input and one output, given that the data needed only to be converted directly. I used the iota function to turn the integers into an array, and then on the other hand mapped that array into a corresponding integer array using the atoi function. This data then was directly output to the servo as a servo write where the data was mapped based on the pulse width modulation of the servo motor.

Because I did not have access to a fully assembled hand initially, I used a flex sensor and a potentiometer for the analog inputs on the transmitter end and a servo motor and an LED light to monitor the receiving end outputs. The LED light was programmed to turn on if the potentiometer exceeded a value of 510, thus allowing me to monitor the precision of the transmitter and receiver.

At this point, I reached a roadblock in the code. After exploring several methods, I used the Arduino Cookbook resource to find the best way to combine the two analog reads into one array. Using the string concatenate function, I was able to map multiple integer values into the same string array. I transmitted this array but I ran into issues on the other side when I tried to decompose the array into multiple integer values.

This issue plagued me for the better part of four hours, wherein I tried several ways to decompose the received array. I looked into pulling the strings apart based on a delimiter character and did not have success in this direction. Given a lack of basic knowledge in terms of computing function and coding basics, I found myself particularly stranded by the differences in how integers, characters, and bytes are processed and also by the differences in pointers and arrays, and how they interact with one another.

Ultimately, I reached out to Professor Sullivan for some insight, and with his assistance, devised a separate way of approaching the problem. I continued to combine the values into one array on the transmitter end, but on the receiver end utilized mathematical calculations to break down the large digit number into several smaller numbers. Rather than decomposing the array and assigning specific digits to variables, I treated the received message as one large number and used basic mathematical operations, such as division, to modify the numbers. I then assigned those values to separate variables and those variables became the variables that would control the servo writes.

Having done this, all that remained was transferring this foundational code to the actual Master Hand system. Dat and I collaborated for the better part of four hours in addition to the time I have listed for all the prior work, and we were able to systematically work through a finger at a time, isolating calibration issues along the way. Once we had properly calibrated the system, we were able to record several videos to document the progress we had made.

The main issues in calibrating the hand to the glove resided in how each finger was rigged to its corresponding servo. Once we had determined the unique ranges of each flex sensor being used, we were able to map those values to the corresponding servo.


*** [Insert Code] ***

Week of Dec 2

Meetings

Dec 5

Members present: Steven, Dat

With the deadline extended to the Friday of next week, we have time to spare. The assembly/construction tasks of the mechanism have been divided between the group members. Each of the knuckle pieces are now attached to dowels, and the palm is now attached to the rest of the arm, which now has the servo motors mounted as well. The plan is to finish the assembly during what would normally be the scheduled lab time (Mondays 2-4), and then use the rest of the week to troubleshoot and adjust the code and mechanism where necessary.

Initial thoughts on a possible second prototype are already underway. Although a second prototype will not be built for this project, exploration of that option and issues we would address and fix will be discussed in later blog posts.

The same tasks remain that were mentioned for the December 3rd meeting: finish the code, finish assembling the mechanism, and then begin tweaking the project so that it actually works.

Dec 3

Members present: Usama, Dat, Kendrick

Although previously we had strived for a Wednesday project completion in order to present at the Dean's event, this deadline proved to be too tight. Our group opted to drop this deadline to give us more time to complete the major components of assembling the mechanism and finalizing the Arduino portions.

All that is left to be done is to assemble the mechanism, finish the code, and then we should be able to begin troubleshooting.

Shown below is the progress on the physical assembly so far:

Completely sewn glove. All that is left is to attach flex sensors

Mechanism assembly so far

Close-up of hardware used to attach the joints: #6 panhead machine screw, two washers, and a lock nut


Additionally, we have been experiencing some issues with the RF transmitter/receiver pair. It was discovered today that the range is extremely limited, somewhere around the order of a few inches actually. However, after some extensive internet research, it was discovered that using some wire, antennae could be fashioned and attached to both the transmitter and receiver. The range was then increased to perhaps a few feet, which is probably more than was required. Hookup wire was soldered to slots labelled "ANT" onto both the transmitter and receiver. This should overcome one of the last two large hurdles left in the Arduino component of the project, the last one being the issue of transmitting an array of servo positions.

Weekly Progress

Dat
Time spent: 4-5 hours
I spent most of the Thanksgiving break beginning assembly of the mechanism, which included modifying the plastic printed parts, cutting the dowels, drilling the dowels, and then attaching everything. These were all time-consuming endeavors.

I also soldered small antannae to the RF transmitter and receiver. They should work from a reasonable distance from now on.

      

The final assembly has been posted and I attached a basic animation of the finger motion as well as a collapsing assembly for viewing.

I've also started working on the Project Summary report, which will accompany the project when we present it to the public next Friday during finals week. Related to this report is thinking about next steps in this project if we were to continue such as a second prototype and new designs for 3D-printed parts.

Kendrick
Time spent: 3 hours
This week I went out and purchased some of the materials that will be used in the design. I went to Lowe's and purchased 10 small eye screws that will be used to orient the fishing line that will pull the fingers of the hand. I also cut approximately 20 ft of very thin fishing line, which will be used like muscles. They will be tied onto the servos and used to pull the fingers against the elastic band and form a grip. I'm concerned that the fishing line will end up cutting through the very thin circle of acrylic that will be used to pull on the knuckles. Hopefully this won't hold true.


Steven
Time spent: 3-4
Physical arm

After cutting out the wire guide I finally glued all of the individual pieces together. This part was originally going to be made out of acrylic but we decided to make it out of wood instead.

 In addition I attached all of the servos to the base as well as finishing the construction of the individual finger parts. The joints may create a problem due to the fact that the joint parts keep breaking; some redesigning may be necessary. Also, there may be an issue with the wires that run to the servos running into each other.

Usama
Time spent: 8 - 9  hrs.

By the beginning of this week, I had received the RF Transmitter / Receiver pair in the mail and I began to build a circuit to incorporate these into the system. Having borrowed Kendrick's Arduino kit, I worked with two computers to simultaneously assemble the transmitter and receiver complex.

I ran into several issues as I developed this code. Several of these were due to the exploratory nature of this undertaking, where I had accumulated some knowledge but did not know first hand what the challenges would entail.

Initially, as I hooked up the transmitter and the receiver, I initially tried to send analog values across the channel but realized quickly that this was too advanced an approach for an initial test. As I pared down the code, I researched online to find several resources that were of great help. From these resources, I found the VirtualWire library which I downloaded and imported into Arduino to help run the RF Transmitter and Receiver. Early on, I realized, however, that the library resource I had downloaded was not entirely compatible and found another through the Arduino forums that provided me with a more complete library.

Nextly, I found code that allowed me to map the data on the receiver end, using a for loop and a character array that would copy the message array after each iteration of the loop. The loop itself would run based on the received message length, which was called for by a virtualwire function. I made sure to add in Serial commands to each end of the code to track whether or not the receiver and the transmitter were actually outputting the correct data. This was primarily to debug any issues that would crop up.

Having compiled this code, I tried to send a preset message across but continued having issues. After numerous trial and error approaches, I began to realize that the remaining problems were actually not a product of my code, but rather, my hardware. For one thing, given the nature of the breadboards provided with the SIK, as well as the high rate of usage over the course of the semester, there were many instances where a wire would be loose within its socket and as such, the circuit would not function. I ended up having to try a series of slots and combinations of wires until I could maintain the circuit without having to hold any wires down.

Finally, the largest issue, once these were isolated, was that of the transmitters themselves. Because neither the transmitter or receiver contained an antenna, when there was any distance greater than 1.5cm between the two components or anything in between them, the signals would not transmit and as such the system would not be complete. After having isolated this issue, I was able to determine that we would need to solder antennae to the components. I handed over the components to Dat who then proceed to solder antennae to each of them.

Furthermore, as I had initially been a bit more ambitious in my attempts to run the RF system, I had also connected the flex sensor and the servo motor to their respective ends of the system, the transmitting and receiving arduinos. It became apparent that the servo motor drew too much power from the arduino and it in turn limited the functionality of the receiver. The arduino, with both connected, could only process data at a much slower rate, due to the draw of the motor.

The other issue that arose with the servo motor was a conflict between the servo.h library and the VirtualWire.h library. It turned out that both libraries utilized the same timer and as such, I found a Servotimer2.h library through the Arduino forums online. This new library used a different timer but also came with a couple of other challenges of its own. Firstly, the servotimer2.cpp file needed to be edited to allow for complete compatibility with the newer version of the arduino software. After finding these edits and putting them into the code, I needed to make adjustments to the servo writing and mapping. It turned out that the servotimer2.h, because it used a different timer, required for all servo write values to be expressed in terms of pulse width modulation, and thus in terms of microseconds, not degrees. While in retrospect this didn't add any severe level of complexity, it was an additonal complexity nonetheless.

We tested the arduino circuits again the following day and found that the reliability and distance of their communications had expanded considerably. When we connected the motor, once again, the same issue resurfaced and the basic communications were slowed considerably due to the drain of the motor. We concluded that we would need to find a third power source to run the motors for the final system.


*** Arduino Code ***

Final Assembly and Animations

Below you will find the final assembly, as well as a link to all of the required files. The Arduino board and breadboard were found using GrabCAD, which is a website where users share their CAD models from a variety of programs. Additionally, an animation of a collapsing assembly (components flying into place) as well as the motion of one finger have been rendered for viewing below.

The hand

Parallax Servo mounting recessions

Close-up of finger assembly

Team Master Hand Assembly .zip

 

GrabCAD links to the SolidWorks parts:

 

MicroBreadboard Files

 

Arduino Files

 

 

 

Assembly Collapse:

 

 

 

Finger Motion

Mechanism Assembly

 

Over Thanksgiving break, initial assembly of the mechanism began. Shown below is one of 30 of the 3D-printed parts picked up last week:

Penny for size reference

Near the bottom of the part is a small nub; this was intended to be a pass through for fishing line that would ultimately connect to the servo motors. However, in the SolidWorks part file, this hole had filets added to it, and this may have caused too much material to fill inside of the hole. Essentially, there was no hole through which fishing line could be fed. The part had to be modified, and by that, I mean I had to find a random nail on the ground and twist away at the nub until a hole appeared. The end product is shown below:

Making that tiny hole with this nail was a tedious and tiring process

 After all of the 3D-printed parts were fixed, I had the dowel pieces cut and pre-drilled to allow for the insertion of #4 1/2-in wood screws, which would attach to the 3D-printed part as shown below:

 

 

It's a very time consuming process to assemble each of these, so it will have to be finished over the course of the week of December 2nd.





Week of Thanksgiving

Meetings

Nov 26

Members present: Kendrick, Dat, Usama, Steven

The plastic parts were printed and allowed to sit in the chemical bath overnight in order for the support material to separate from the actual part. There was not much to do, since Parallax servos are still shipping. The assembly of the physical hand will be occuring over the weekend once all the parts and hardware can be cut and drilled.


Nov 25 (during lab session)

By this time, most of the physical and mechanical aspects of the project were completed. The arm was constructed over the weekend by Steven, complete with recessions for the servo motors. Professor Sullivan also allowed us to have the final design of our knuckle printed. We had 30 printed at about 1.5 cubic inches of material, and perhaps about 1 cubic inch of support material. The machine said it would take about 4-5 hours.

A rough version of the glove was also presented. It had one flex sensor attached to one finger on the glove and some hookup wire soldered to the flex sensor leads. Conceptually this should work for the rest of the fingers, so sometime over the weekend, more flex sensors will be attached.

The RF transmitter and receiver arrived in the mail, and progress was made to at least get a successful transmission to happen. During the end of this project, the focus will be shifting to the programming and Arduino aspect.

Weekly Progress

Dat Le
Time spent: 5 hours

Over the weekend, I determined that the best way to have the flex sensors attach to the glove was by inserting into a "slot." I achieved the slot by sewing a stitch into the top portion of the finger of the glove. This keeps the flex sensor aligned with the finger, but allows it to move back and forth along the length of the finger (very slightly) to allow for bending.

I also purchased some hookup wire from Radioshack and was able to solder it to the leads of the flex sensor. I tested it by stripping the wire ends and plugging it into the breadboard and it works fine. With long lengths of hookup wire, we will no longer need to worry about mounting an entire Arduino and breadboard onto the control glove.


Kendrick Lo
Time spent: 1 hour
I looked into getting a nice power source for the arduinos and managed to find a good plug in source that was compatible. It will only be able to power one arduino, which wont be that great since we are using multiple.


Steven Passios
Time spent: 1-1.5 Hrs

Over this week I created the Solid-works representation of our project. It appears to work as intended but the motion study didn't.

If all goes well, according to the 3D model we should be able to place both the arduino and the breadboard onto the back of the base of the assembly. This will save us space as well as helping to balance the assembly which I believe may be front heavy..


Usama Saadat
Time spent: 4 - 5 hrs.

Having ordered the RF transmitter and receiver last week, I began this week by assembling a mock circuit with the parts already included in the sparkfun inventor's kit. I used this system as a first draft to test some of the basic code and to familiarize myself with the basic format of the functions I'd be utilizing.

The circuit that I created consisted of a flex sensor and a servo motor connected to the same Arduino. The flex sensor was connected to an analog input and this data was then mapped and output to the servo motor. While the overall circuit was very simple, the prototype did allow for me to determine a basic format and flow that I will likely transpose to later drafts of the code.

*** [insert code] ***


In addition to this, I spent some time brainstorming the ways in which the RF transmitter / receiver would transmit the data. Having realized that the code would be a bit more involved than I initially imagined, given that the RF transmitter / receiver would only be able to transmit data in terms of character arrays, I would likely need to find a way to convert the integer values into an array and to decompose that array on the receiver end.

Having analyzed the relative complexity of this endeavor, I also decided to abandon the idea of the preset remote controller, given that creating a quality wireless dynamic control would likely be a greater priority than having a redundant remote control.

Preliminary tests of Parallax Servos and Glove-Mounted Flex Sensors

5 Parallax standard servos arrived today in the mail. They are quite large compared to the servos that came with the Sparkfun kit:

Left: Parallax servo; Right: SparkFun servo

The servo is both larger and stronger, with a torque about 2 to 3 times that of the SparkFun servo, so it should meet our needs nicely.

http://parallax.com/product/900-00005

I began to hook it up to the breadboard to begin testing them but ran into a bit of a snag. For whatever reason, the servos weren't working. I had the 5V and GND from the Arduino hooked up into the positive and negative rails of the breadboard, respectively. Then I attached the red, white, and black leads of the servo (just like the ones in the Sparkfun kits) to the power rail, ground rail, and digital PWM pin-out.

Next I tried plugging the servo directly into the 5V and GND pin of the Arduino. This worked! However, the problem it posed was that only one Arduino could power one servo motor at a time.

I spent the next hour or so troubleshooting and scouring the internet for answers. No luck. At last, I tried using hookup wire instead of the breadboard wires that came with the Sparkfun kit. This finally worked. I was even able to run two servos at once from the same power/ground rail with more hookup wire.

After this debacle, I wrote some quick code to test out the flex sensor's ability to rotate the servo when mounted on the glove. The servos get jittery once more than one servo is powered and grounded to the same rail, but overall, they are able to run independently. One discovery I made was that the 600-900 analog value for the flex sensors that was recommended in the SIK Guide code isn't far too much. What ended up happening was that the flex sensor was only bouncing between 690 and 800, which when mapped to a servo's angle position of 0 to 180, would only give me from about 70 to 110. I wanted full rotation, so what I did instead was have the "map" function convert flex sensor values from around 675 to 800 to the servo angles of 0 to 180. This way, I got a much broader angular range for the servo. I've included the code to show what I mean:


Perhaps more quality flex sensors would utilize the entire 600 to 900 range, but that's not the case with these flex sensors. Adjusting the range to 675 to 800 will allow for much greater range of motion for the servo. The video shown below uses this updated range for the flex sensor mapping to the servo angle, in addition to using the flex sensor on the glove mount for one servo.

Of course, this is with the flex sensor and the servo attached to the same breadboard and Arduino. Our challenge arises in separating this system into two by utilizing the RF transmitter and receiver, which is the last big challenge for this project.

-Dat

The Physical Arm

Steven Passios
Work Time: 6 hrs

Assembling The Physical Arm
After the final design of the arm was completed I immediately started cutting out the pieces. I did not have all of the tools I would like but managed to recreate the part by cutting the piece into smaller sections and then gluing them to the base.

The Arm

Upper Arm

2D Drawing

Steven Passios

Work time: 45 min

The Upper Arm

Over the weekend I made a few adjustments to the arm section of the project. It now has all of the slots for the servo motors as well as the spaces for the arduino board and the wire guide which will be added later.

The Glove

Over the weekend, I sewed a "slot" for the flex sensor to sit when mounted onto the glove. I also soldered some hookup wire to the leads of the flex sensor that will attach to a breadboard away from the glove since mounting a breadboard and Arduino onto the glove would be difficult and cumbersome to both assemble and to wear. Additionally, I used heat shrink tube to help to strengthen the area where the hookup wire was soldered to the flex sensor, since the weight of the wires due to its length actually put a lot of stress on this portion of the flex sensor. Usually, it's recommended that the bottom of the flex sensor does not bend; otherwise you risk damaging the sensor.

Flex-sensor mounted onto the index finger of the glove. Note the blue heat-shrink tubing and the red and black hookup wire leads

- Dat

Week of Nov 18

Meetings

Nov 21

Members present: Dat, Kendrick

A lot was discussed today in a very short amount of time. We finally decided that the servo motors provided in the Sparkfun kit would not be adequate for this project. Although they possess the necessary torque, their range of motion is limited at best. Standard Parallax servos were chosen as good servos to use in this project.

Further work on the Arduino control system was made. Specifically, the RF transmitter/receiver were ordered and the VirtualWire library was explored. VirtualWire would allow us to transmit an array from the transmitter to the receiver. That array could contain the servo angles. As such, we require two Arduinos, one for the robotic hand and one for the human hand.

For next week, the final assembly of the project will be put together. Once the plastic parts have been sent out to be printed, the focus can shift more towards the Arduino system and logistics in terms of how all the electronics will be hooked up.


Nov 19

Members present: Steven, Usama, Kendrick, Dat

Code was quickly written to test and observe the flex sensor as an analog control for the servo motors. There was the issue of whether the servos would be able to rotate enough (the Sparkfun servo range is several degrees less than 0 to 180) and if the $8 Sparkfun flex sensors would suffice. These issues were put on hold for the time being.

The RF transmitter and receiver will be purchased later during the week to be able to test out their capabilities and finalize the Arduino code.

Professor Sullivan gave us the opportunity to have our "knuckle" design printed during the Monday lab session. We were able to obtain them the next day. It only comprises of about 0.04 to 0.09 cubic inches of material, depending on sparse low or sparse high density printing. Some modifications will have to be made before we send a final design to be mass-printed. Shown below is the part that was printed:

Weekly Progress

Dat
Time spent: 4 hours

Redesign of knuckle to allow for use of #4-1/2 inch wood screws to connect to a dowel and #6-3/4 inch panhead machine screw as a pin. Also added a pass through hole for fishing line, which will connect to the last phalange of a given finger and the servo motor, thus closing the finger.

Knuckle5 Part File

Knuckle5 Drawing File

This is the final design for the part, since we would like to have it printed and assembled as quickly as possible.

I also explored the VirtualWire library for Arduino:

VirtualWire Library download and tutorial

Using a pair of RF links (transmitter and receiver at 433 Hz), we can send an array of characters. Essentially we can read in the value from the flex sensor, map that to an array with angle values for the servo motors (0-180), and then convert to characters for wireless transmission via the Arduino function "iota." The code is relatively simple, but will require some experimenting and troubleshooting to get the result that this project requires.

Kendrick
Time spent: 3 hrs

I performed the torque test the past weekend and now have a large DeWalt mechanic's glove. After performing the test, I decided that, while the servos are sufficiently strong to hold the strings and finger, that they are heavily limited with respect to their range of motion. They hardly provide a large enough range to allow the fingers to to clench, so we came to a group decision to order new servos (Parallax standard servos).

I also created the full assembly for a single finger.

Finger Assembly

 

The assembly is made of 3 pairs of knuckles (After the adjusstments were made), 6 single knuckles in total, and three 5/8 inch dowels.

Steven
Time spent:

Usama
Time spent: 5 hrs

Having begun an initial inquiry into the approach I would take with coding the Master Hand, I pursued a pseudocode template and began to explore my options for designing the remote control circuitry and code.

*** [Insert Code] ***


Having designed a systematic flowchart, I then began to explore what options I had for designing the dynamic glove control. Having discussed the ideas with the group, it seemed that there was a great deal of interest in pursuing a wireless option. Having consulted a few external sources, including our T.A. from the Design Lab, Christy, we determined that the Infrared Remote option was going to be complicated enough that it would not be a wise pursuit given our time frame.

As such, I began to explore the RF Transmitter / Receiver route. After browsing through several types, which had differing frequency ranges from 315 to 433 MHz, I settled on a basic 433 MHz RF transmitter / receiver pair and ordered it off of Amazon.com. This particular pair was included in several online tutorials and generally seemed to have good reviews, in spite of its relatively inexpensive price point at approximately five dollars a pair.

I placed the order for the RF Transmitter / Receiver and then conducted some preliminary exploration of the potential code I would need to run the RF Transmitter / Receiver complex. After discussing with Dat what our options were, it became apparent that both of us had discovered the same library for use with the wireless radio communication hardware. The Virtualwire library was an opensource library that contained the code required to run the RF off of the Arduino.

For the week, this seemed like an adequate point to have reached, and I began to plan how I would approach building the code next.

Summary of Mechanism Description and the Arduino Code

Shown above is an initial concept sketch of the overall layout of the design project our group has chosen.

Mechanism: Glove-Controlled "Hand"

The idea involves creating a rough 1:1 scale model of a human hand that is controlled via an Arduino interface and a control glove. The fingers of the hand will be attached by string or thread to several servo motors. By changing the position of the servo motors, the opening and closing motion of the hand can be replicated. The position of the servos will be controlled using flex sensors mounted to a glove which can be worn by a human user. Opening and closing the fingers of the glove will subsequently open and close the fingers of the Arduino hand. This creates a "shadowing" or "copy-cat" effect.

String/cord/thread/wire will also be used on the backside of the hand to maintain an open palm position. It will have to be elastic, so that the hand springs back to an open palm whenever a user is not interfacing with the Arduino hand.

The components of the Arduino hand that must be designed and fabricated are the phalangeal joints, or "knuckles," of the hand that join the individual lengths of a given finger together. The goal is to have it reflect the limitations of human hand movement i.e. they can't bend too far backwards or fold too far inwards on themselves.

Arduino Component:

The Arduino board will take the analog input of the flex sensors and map them to angular position of the servo motors. We would also like to incorporate a set of either IR or RF emitters/receivers for the analog control glove to communicate to the servo motors remotely.

Week of Nov 11

Meetings:

Nov 14

Members present: Usama, Steven, Dat

We discussed two different design options for the knuckle. The new design will build off of the advantages of both by incorporating a "fork" that will help to align the tension strings that will ultimately keep the Arduino hand in an open palm position when not being interfaced by the analog input. The existing design will have to be updated to accommodate this combination.

The Arduino code was also discussed. In general, mapping the flex sensors to the servos will be a relatively simple task. The difficulty arises in how we will decide to have the glove interact with the servos from a distance, perhaps remotely i.e. how we decide to connect the electronics to the mechanism. More research is required.

We also discussed the issue of power consumption, since we will need five servos running independently at one time. We aren't sure of whether this is an issue of voltage or current draw. In any case, this has been put on the backburner, and can be worried about later.

For this upcoming weekend, research on IR or RF transmitters and receivers will need to begin, as well as ideas on the control glove and mounting the Arduino and flex sensors. We will also have to determine how far we go with the thumb design (how intricate will it's motion be?).

Nov 12

Members present: Kendrick, Dat

Today we discussed the design of the knuckles, as well as the overall design of the entire assembly, which included choosing materials, costs, etc. One concern was whether the stock servo motors that came with the SparkFun kit would have enough torque to control the fingers. Kendrick will determine if these servos provide enough torque and get back to the rest of the group.

Weekly Progress:

Dat

Time spent: 4-5 hours

I made some initial designs of the knuckle and eventually came upon a design that would accomplish everything we needed it to do in terms of replicating a real human hand's opening and closing motion. It took some time to determine how excess material could be shaved off the part, since we are only given 4 cubic inches of material to work with. Show below is the part and its dimensions.

Knuckle Part File

Knuckle Drawing File

This part was designed with the intention of taking two identical pieces, rotating them 180 degrees so that they face each other, and then insert a pin to connect them. The part is made to sit flush against the end of a 5/8 inch dowel, and attach by using a countersunk wood screw, perhaps around the size of #4 and 1/2 inch depth. 

The group discussed the issue of aligning the tension strings along the length of the fingers whenever the fingers would close. This design did not take that into account, but we did come up with the idea of adding a sort of "fork" that would be at the top of this component. Whenever the hand closes, the fork is lifted, and the string will stay aligned. Further implementation of this concept in combination with the above design will be required this weekend.

I also spent time determining the best materials to use. In general, the fingers will be something along the lines of 1/2 inch to 3/4 inch wooden dowels, cut down to size. 5/8 inch is about the diameter of my fingers, so that is how I designed the knuckles. I also found some elastic band at a JoAnn Fabrics. It's much more springy than elastic thread, but not as strong as elastic cord. It's a good in-between stretchiness that I believe will work when keeping the hand open when not being controlled. It should also be weak enough for some servo motors to pull against when closing the fingers.

The wooden dowels, the elastic bands, and wood that will be the palm and forehand will be the cheapest materials, probably all under $20. I would guess that the electronics (more flex sensors and servos if it so happens that we need them) will be the most expensive. We estimated that the whole project could cost around $100.

Kendrick:

Time spent: 2 hrs

I looked into what type of glove should be used. It was decided that a standard glove would by insufficient and too weak, whereas a mechanic's glove would be stronger and better. I got yellow and black DeWalt's mechanical glove that will be used for the hand. Our group also wanted to find out if the servos provided in the SIK would be sufficient enough to use with the strings, in terms of strength. I will perform a torque test on the servos and decide whether or not they will work.

Steven:

Time spent: 2-2.5 hrs

Over the weekend I looked into possible configurations for the control glove as well as possible ways to mount the thumb to the base piece. The most prominent thing we need to decide for that is if we want the thumb to have full range of motion or if it should only be able to bend inwards. 

Usama

Time spent: 2 hrs

After the initial meeting, it was determined that I would effectively be in charge of the Arduino code which would interface and run the Master Hand system. As such, I began by brainstorming and imagining various ways in which I could approach the task, thinking of what some of my potential options might be for assembling the code.

Our initial discussions had entertained the idea of a remote control with presets for the hand configuration as well as having the human interfaced glove which would allow for active participation and an analog input that would be more dynamic. After some thought, I determined that I would pursue the dynamic hand code more aggressively and see if there was any time left to add an additional remote control for preset figures.

In terms of the dynamic glove input, I categorized and wrote out a brief outline that detailed some initial thoughts:


     Glove:

• Five Sensor Variables 
• Five Servo State Variables
• Five Servo Value Variables
• Map each of these separately.
• How will we communicate glove to hand? Wired or wireless?

     Remote:

• Maintain each servo variable (independent of functions) 
• Map each servo according to sub function? 
• Each servo controlled by if function of buttonstates? 

      ** Also need RF Transmit Code


Based off of this template, I began to explore a pseudocode that would provide a template that I could further pursue in building the code for the Master Hand system.

Week of Nov 4

Nov 7

Members present: Dat, Steven, Usama

Today we weighed the decision of the project idea heavily upon two options, the glove-controlled hand and the "useless" machine. Although the useless machine was funny and had many possibilities for variation, the decision ultimately fell upon choosing the glove-controlled hand because the concept was a bit challenging and overall, would be cooler than a useless machine.

The idea is as such: A glove would house flex sensors (the analog input) which would control some servo motors. These servo motors would then control the movement of "fingers," thus producing a hand-shadowing sort of mechanism. Plastic-printed "knuckles" or "phalangeal joints" would attach the phalanges of the fingers together. The possibility of incorporating an IR remote was also mentioned, but requires further research.

This upcoming weekend is going to be dedicated to writing "pseudocode," or the general flow of the code that would be required for this mechanism, as well as design of the plastic-printed knuckles. Design of the overall layout of servos and the mechanism will also begin this weekend.

-Dat

Nov 5

Members present: Dat, Kendrick, Steven

During this meeting, the group brainstormed various ideas for the design project (see list below). We also set up a dummy g-mail account (22201.804.dksu@gmail.com), organized the Google drive to use for file exchange, and set up this Blogger account (http://22201804dksu.blogspot.com/). The name of the blog and the name of the group are temporary until we think of something good.

Possible Ideas for the Project:

- Glove-controlled animatronic hand

- "Useless machine"

- Sumo robot

- Wii-controlled rubber-band cannon

-Dat