Here's a video of how it looks for now:

The use of a robot is becoming a daily need, we use them when manufacturing products and items, aiding people with needs, and even enhancing our own weakness. Animatronic hand, a robotic hand that is controlled by a user through gloves that as you bend a finger the sensor detects the angle and sends a signal to the robotic hand. In my project I hope to accomplish the concept of wireless animatronic rt rx based, the application for this robotic hand are countless. A couple of examples would be proving the concept of controlling the robotic hand with a sensor, this control over an animatronic hand would one day replace completely the expensive prosthetic hand system. Is also cool to have it on like the movie Pacific Rim which shows how a giant robots could be controlled by a person’s body movement, for in the animatronic hand comes the ability of manipulate single movement of the fingers; in years to come, we would just have to upgrade the equipment while keeping the concept the same. There are many animatronic hands made, all it requires is a microcontroller, flex sensors, resistors, servos, power source, glove, and a robotic hand frame, however what sets apart this particular animatronic hand, is the distance advantage which can be provided by having the user control the robotic hand wireless.

The total project cost me around 200-300 dollars depending where do you get your parts, so beware of the price before starting. There are 5 steps to build your own animatronic wireless hand:

Step 1 Xbee Configuration

Step 2 PBC Board (optional, but the more you know the more upgrades you can add to your projects!)

Step 3 The Program

Step 4 The Glove

Step 5 The Hand

Step 1: Xbee Configuration

We need to configure the xbee in order for them to

communicate with each other and only with each other under a specific channel, so what will we need.

Components that you can buy in Ebay Amazon Sparkfun or any website selling electronics:

2 Xbee series 1

1 arduino uno

Xbee Arduino shield

The x ctu program

First download the x ctu software online, here’s the link http://www.digi.com/support/productdetail?pid=335...

Select XCTU Next Gen Installer, "Windows x32/x64, Mac or Linux."

Next, we will use the arduino in order to have direct communication between the xbee and XCTU. To do this we will remove the atmega328 from the Arduino (picture 1), you also have the option to buy FTDI FT231X chip. But lets assume we don't have one, so lets go with one the arduino.

After having the atmega328 taken out, connect the Xbee to the Xbee Arduino shield and both components to the Arduino. Connect the Arduino to the computer and open the XCTU software and set up the xbee.

Here’s a link that explains setting it up better:

https://learn.sparkfun.com/tutorials/exploring-xb...

note: remember that one has to be the transmitter and the other the receiver, but not always, in this case if you want to set it that way, remember to keep track of what is what by placing a label to avoid mistakes.

Step 2: PCB Board (Optional)

Like I said this is optional, you could make the connections in a breadboard and it will still work. Why do we want it?, to make the connections easier in the glove, it looks cool and organized instead of a messy breadboard wiring that could come out easily in my opinion.

what will you need?

Plain Board

Sharpie

Etching solution

Some Tools:

Drill

Plastic container

Ruler

Paper

Plastic gloves

In a blank paper with pencil plan the connections and then draw it on the blank board,be as detail as possible so use a ruler and a pencil because the lines that you are drawing will be power conductive so make it symmetric, this is what I draw on mine (Picture 1).

Pass it one last time with the sharpie this time, once the sharpie is dry, wash it gently with water, it should look like this (picture 2).

With gloves in a plastic container submerge the whole board and move it sideways for 1 to 2 minutes (Picture 4). Then take the board out and wash it with cold water. You should have something like this (Picture 3):

You now have made a custom made PCB board, you could alter the design to whatever you want, just make sure the connections don’t change.

In the next step we will wire this PCB for the glove, just follow the diagram and you should have something like (Picture 5 and 6)

Step 3: The Program

For the robotic hand
(Arduino) :

#include

Servo

ServoThumb, ServoIndex,

ServoMiddle, ServoAnnular, ServoPinky;

byte startPackage;

int Thumb = 0;

int Index = 0;

int Middle = 0;

int Annular = 0;

int Pinky = 0;

void setup()

{

Serial.begin(9600);

ServoThumb.attach(9);

delay(300);

ServoIndex.attach(8);

delay(300);

ServoMiddle.attach(7);

delay(300);

ServoAnnular.attach(6);

delay(300);

ServoPinky.attach(5);

delay(300);

Serial.println("Ready to receive.");

}

void loop()

{

if(Serial.available()) {

startPackage = Serial.read();

Thumb = Serial.read();

Index = Serial.read();

Middle = Serial.read();

Annular = Serial.read();

Pinky = Serial.read();

if(startPackage == '<'){

if(Thumb!=255)

ServoThumb.write(Thumb);

if(Index!=255)

ServoIndex.write(Index);

if(Middle!=255)

ServoMiddle.write(Middle);

if(Annular!=255)

ServoAnnular.write(Annular);

if(Pinky!=255)

ServoPinky.write(Pinky);

}

delay(30);

}

For the flex sensor gloves

(lilypad arduino):

int ResThumb = A4; // Variables of the analog read form the flex sensors connected to the analog pins of Arduino LilyPad

int ResIndex = A3;

int ResMiddle = A2;

int ResAnnular = A1;

int ResPinky = A0;

int OpenedThumb =0; // Variables of the values when the hand is completely opened

int OpenedIndex =0; // This is needed for a continuous calibration

int OpenedMiddle =0;

int OpenedAnnular =0;

int OpenedPinky =0;

int ClosedThumb; // Variables of the values when the hand is completely closed

int ClosedIndex; // We can't set it to zero since that the minimum value reached

int ClosedMiddle; // in the analog read never reach zero. We'll assign the value of

int ClosedAnnular; // a first analog read, then the program in the loop will

int ClosedPinky; // automatically assing lower values

int thumb =0; // Variables of the values to send

int index =0;

int middle =0;

int annular =0;

int pinky =0;

void setup()

{

Serial.begin(9600); // Activating serial communication, XBee Series 1 are pre-programmed at 9600 baud/s

pinMode(ResThumb, INPUT); // The variables of the sensor are set as input

pinMode(ResIndex, INPUT);

pinMode(ResMiddle, INPUT);

pinMode(ResAnnular, INPUT);

pinMode(ResPinky, INPUT);

ClosedThumb = analogRead(ResThumb);

ClosedIndex = analogRead(ResIndex);

ClosedMiddle = analogRead(ResMiddle);

ClosedAnnular = analogRead(ResAnnular);

ClosedPinky = analogRead(ResPinky);

}

void loop()

{

thumb = analogRead(ResThumb);

index = analogRead(ResIndex);

middle = analogRead(ResMiddle);

annular = analogRead(ResAnnular);

pinky = analogRead(ResPinky);

if(thumb > OpenedThumb) // Calibration reading and setting the maximum values. This needs you to completely open your hand a few times

OpenedThumb = thumb;

if(index > OpenedIndex)

OpenedIndex = index;

if(middle > OpenedMiddle)

OpenedMiddle = middle;

if(annular > OpenedAnnular)

OpenedAnnular = annular;

if(pinky > OpenedPinky)

OpenedPinky = pinky;

if(thumb < ClosedThumb) // Calibration reading and setting the minimum values. This needs you to completely close your hand a few times

ClosedThumb = thumb;

if(index < ClosedIndex)

ClosedIndex = index;

if(middle < ClosedMiddle)

ClosedMiddle = middle;

if(annular < ClosedAnnular)

ClosedAnnular = annular;

if(pinky < ClosedPinky)

ClosedPinky = pinky;

thumb = map(thumb ,ClosedThumb ,OpenedThumb ,0,180); // The analog read has to be readapted in values between 0 and 180 to be used by the servomotors.

index = map(index ,ClosedIndex ,OpenedIndex ,0,180); // The minimum and maximum values from the calibrations are used to correctly set the analog reads.

middle = map(middle ,ClosedMiddle ,OpenedMiddle ,0,180);

annular = map(annular,ClosedAnnular,OpenedAnnular,0,180);

pinky = map(pinky ,ClosedPinky ,OpenedPinky ,0,180);

Serial.write("<"); // This character represent the beginning of the package of the five values

Serial.write(thumb); // The values are sent via the Tx pin (the digital pin 1)

Serial.write(index);

Serial.write(middle);

Serial.write(annular);

Serial.write(pinky);

delay(30);

}

Step 4: The Glove

This part is really important.

You will need:

5 flex sensors

1 snow glove

5 4.7Kohms

1 Lilypad arduino

1 Lilypad Xbee shield

1 Xbee series 1

1 Lilypad FTDI adapter

Jump wires

Battery holder 4 AAA batteries

Optional:

Velcro

Electric tape

Hot glue

ruler and pencil

Connect the Lilypad FTDI adapter to the lilypad to download the program before you solder the tx and rx to the lilypad xbee shield (Picture 2).

Open the Arduino file, copy the code, make sure you select the right board and usb driver go to tools -> Board -> Lilypad Arduino w / ATmega328

Next, connect the components according to this diagram below.

Important:

The lilypad Arduino should only take between 2.7-5.5V, so I used only 3 AAA batteries, by having the gray cable replace one one AAA(See the diagram on picture 1) we have a total of 4.5 V rather than 6V.

When connecting the Rx and Tx of both, the lilypad Arduino and the Lilypad Xbee shield, they have to be opposite. So connect the RX from one of them to the opposite of the other, and do the same thing for the Tx. Example, lilypad Rx connected to lilypad xbee shield Tx, and lilypad Tx connected to lilypad xbee shield Rx, if connected wrong, the RX and TX wont respond.

Here is where the pcb board will lower the mess of wires(Picture 3).

When soldering the resistors with the analog connections, is important that these don’t make contact with each other.

You will use A0, A1, A2, A3 and A4 from the lilypad Arduino.

Following the diagram above connect your custom pcb according to the connections, it should looks something like (Picture 2)

When is all running, with your snow glove, use hot glue and Velcro to stick them together and then attach the components like so in (Picture 4)

Step 5: The Hand

The hand has to be flexible and be able to close. The design of the hand could be from different materials and different design, as long as the electronics are wired correctly you would only adjust the amount of string between a servo and a finger.

I still have some trouble with my design, but is been good so far.

Components to buy:

5 servo sg90

Fishing line

1 Xbee series 1

1 Arduino uno

1 Sensor/servo Arduino shield

1 9V battery

1 4 AA battery holder (6V total)

4 AA batteries

1 electric tape

Optional:

Velcro

1 Toggle switch

Note: I did my hand with wood, however you have the freedom of choosing the material and design of the hand, there are 3d printed hands or tubes hand.

My animatronic hand :

3 9.5 x 12 cm flat Wood sheet

1 12.7 x 6.5 wood think sheet

1 1 x 1 x 60 cm wood (This is for the finger, this is optional if you want to make the finger fatter then you should go for 2x2 and the length doesn’t matter much, since you will cut them in pieces).

2 shrink of the smallest shrink tubes

Tape

Small hinge the size of 1 to 2 cm square.

9v holder

Hot glue Before you start building the frame of the animatronic hand, make sure your connections work and test it beforehand. First connect the right components color code, so is easy visually.

The first picture is the connections without a sensor/motor Arduino shield, as you can see it will get messy. The xbee connects to the xbee Arduino shield, then both connected, connect to the Arduino.

Note: my xbee Arduino shield came with a switch in the board with the option of, usb and xbee. When is in usb, the xbee wont communicate with the other xbee. So make sure you have it in xbee mode. Also the xbee shield goes first along with the xbee, and then the sensor/servo shield goes on top last.

Once the servos are working correctly, the next step is to build the frame.

To do this you will need to measure exactly how you want your frame to look. I use wood mainly because is fairly easy to manipulate, and hot glue works great.

Notice that I use several sheet of wood to make the base solid:

I use a thick layer and drill holes to fit with the Arduino.

I hot glue one of the 12.7 x 6.5 wood think sheet to several

2 x 2 x 6 wooden sticks to secure the servos

The fingers are easier in my opinion, make 14 small size sticks

As you see on the picture I use tubes shrinks and heat them up to make the tubes extra smalls. There are two tubes, for each finger three on the front and 4 in the back. After taping them with electric tape, use the fishing line and have two strings, one for the front and the other for the back. Both finishing line string should be connected at the tip of the finger (not tie with each other).

Despite all the work, I would’ve prefer to use a 3d printer.

As time passes, we become more aware of things, and we are able to use our intellect to make our life easier. A use of technology is to increment our basic senses, such as the hearing, we’ve been increasing the range of sound to aid people with hearing problems, we can detect different light in the spectrum with the tools of science, making us able to see more than just light reflections. This wireless animatronic hand will help us understand the basic function of electronic components thus increasing our controlling abilities. If I were to use high power torque servos instead of the sg 90 servos, and replacing the fishing line with metal strings, then this hand would have a powerful grip capable of breaking even wood. There are so many possibilities for the concept of controlling a servo, wireless. I hope that the people that attempt this project furthermore their curiosity for electronics, and built something more exiting.

If you have any questions please don't hesitate to ask