LBSv2 Hand (Integration)

The robot hand is finally made!

Now we have to integrate it. 

There was a list of tasks tasks that we had to perform:

1. Mount the hand on Mentor arm. 
2. Find a way to control the servos via the same Arduino Mega used for the Mentor arm.
3. Finally, the software integration with the other sub systems.

Other tasks:

1. Mitigate overshoot

The extra stuff on the hand will be discussed in a later post

      1. Mount the hand on Mentor arm.
Originally, there was a claw at the end of the mentor arm. It was not needed therefore it was removed. Then the hand was mounted at the end of the mentor arm. All that was required was two 4mm holes to fit two sets of screw and nut.

Mounting the hand on the arm

     2. Find a way to control the servos via the Arduino Mega used for the Mentor Arm.
This task puts emphasis on connecting the servos (via wire) to the Arduino Mega found under the Mentor Arm. It was decided to solder all the connections to a 10 way ribbon cable that would weave its way through mentor's skeleton to the Arduino Mega. It was noted that all five servos draw a significant current therefore the Vcc and Gnd line occupies two wires each.

Wires from the servo soldered to a
10 way grey ribbon cable

Ribbon wire touching the gears
but does not interfere

Ribbon goes to the back of the Mentor arm,
where the Arduino Mega sits.

     3. Finally, the software integration with the other sub systems.
To ensure that the hand will work in software, an Arduino code was written to control the position of the fingers via the servos. Check out the entire code at the end of this post. The fingers are individually controlled via the keyboard. When 1, 2, 3, 4, 5 are entered into the serial monitor, the pinky, ring, middle, index, thumb will extend respectively. When q, w, e, r, t are entered into the serial monitor, the pinky, ring, middle, index, thumb will contract respectively.

Every time a command is sent to the Arduino, the respective function is called to change the angle of the servo, as shown below for the Middle finger.

It was found that the servo angle which corresponds to the finger position was:

	Angle
	Extended	Contracted
Thumb	20	120
Index	20	115
Middle	10	125
Ring	10	140
Pinky	25	115

Other tasks:

1. Mitigate Overshoot

The hand is heavy. (300 grams) The mentor arm was not designed to carry an extra 300 grams. As a result the mentor arm overshoots by a couple of degrees before correcting itself via the feedback from the potentiometers. For example, the desired angle is:

Actual angle = desired angle + overshoot angle

There are a few things we could do to mitigate the overshoot:

1. Software solution: One quirk of mapping the hand position from the Leap Motion to the motion of the Arm is that there is an 'exaggeration' of the movement. One centimetre of movement by your hand does not equate to a one centimetre of movement with the arm - it is more like four to five cm. Thus, the overshoot in part had to do with the amount of movement that was exaggerated from the Leap Motion. As such, we decreased the sensitivity of the movement so that it would not move as quickly, and as far. Furthermore, we worked out that different voltages affect the overshoot, and affect the amount that the fingers would move when mapped from the Leap Motion. Thus, we have turned down the voltage to 10V so that it is constant and more consistent in it's movement.

2. Mechanical solution: Mount additional counter weight on the other end of the arm. This has the potential to balance the weight of the hand. The idea came from the existing counter weight on the mentor arm. It was decided that 1kg is the optimum weight, assuming that it would be mounted on the other end (found out with via machine calibrated weights). The design of the counter weight allows it to be shifted closer or further away from the fulcrum. Later it was found that it works best when the weight is positioned closer to the fulcrum. 

Counter weight

Another solution that we have not attempted is the characterisation of the non-linear overshoot behaviour and that way it was possible to map the desired values to the overshoot values. This could be a potential extension to the project but solutions discussed above were enough to mitigate overshoot to a minimum.