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