Project showcase
'Gesture Bot' with Hand Gestures

'Gesture Bot' with Hand Gestures © GPL3+

A simple yet real size robotic hand ready for custom programming.

  • 3,175 views
  • 2 comments
  • 11 respects

Components and supplies

Necessary tools and machines

Apps and online services

About this project

GESTURE BOT

Gesture Bot is a simple yet life-size robotic hand that is able to imitate hand gestures. It can be custom programmed to perform certain hand gestures.

The mechanics of the hand is powered by 10 servos that are used for the hinge points of the fingers and two stepper motors that control the wrist movements and base arm movements. At the heart of the box lies an Arduino Mega which controls all the electronics.

At of yet i am using the serial commands to control the robotic hand, although a lot of more features could be incorporated such as designing a control pad which relays feedback which can be facilitated with the numerous analog pins of the Arduino Mega.

Although all the functions of the hand work well, I do believe the design has some drawbacks in aesthetics and the if the degrees of freedom for movement of hinge points can be increased it would definitely function more like a life like hand.

GESTURE BOT trying to imitate hand gestures

THE BUILD

I have divided the build into four main parts for ease of explanation. The Base, The Arm, The Hand and The Control Box.

THE BASE

The base assembly consists of the top and bottom structures. The top structure houses the Stepper Motor which moves the arm. The top structure is joined to the bottom structure with a plate bolting them together. A 12V rectangular LED set is fixed under the arm on the top structure. The bottom structure provides enough surface area to distribute the weight of the whole hand.

Another 12V LED strip runs along the circumference of the bottom structure. The Base Stepper Motor is connected to the Arm with a coupling flange and the arm is held in position with the bearing fixed from the opposite side. The bearing housing is bolted to the top structure of the base assembly

Finally a push button is fixed to the top structure to act as a kill switch to prevent further movement and then move back a certain amount of steps so that the hand will be in a definite position. A better option be to hook a POT on the shaft of the base stepper motor to get feedback of the current position of the stepper motor, but i have just left it as it is for now.

THE ARM

The arm is 3D printed as one whole piece and has a pocket in the top to fit the wrist stepper motor. The Arm is placed in position with the support from the bearing and the coupling flange connecting the shaft of the base stepper motor to the arm.

After fitting the wrist stepper motor in the arm, it is closed with a lid and the shaft of the wrist stepper motor and its coupling flange is concealed with the collar fixed in position below the hand assembly.

THE HAND

The hand assembly comprises of the hand base structure and the finger assembly. The hand base structure houses the five bottom servos (17g) which hinges the bottom links of the fingers. The finger assembly mainly has a small structures that supports the top servos(4.1g) which provide the top hinge of the fingers.

The servo wires of the servos have been glued with some slack to facilitate the movements of the small hand structures. The joints of the fingers are made with small arms that come with the servo motors.

GESTURE BOT control using serial commands

THE CONTROL BOX

The Control Box houses the two TB6600 Stepper Motor drivers, a breadboard for the connections, a breadboard power supply, and the Arduino Mega micro controller board which controls all the movements of the robotic hand. I know that the TB6600 is a bit of an overkill for the NEMA 17 stepper motor but i had one extra lying around and also it fit well in the control box so i decided to go for it. I guess the control box could be miniaturized in size by replacing one TB6600 with and A4988 driver.

The three on/off switched on the top of the control box switches the 14.8V, 12V, and 7.4 batteries respectively. I have done this mainly because it is easy to test different parts of the hand by cutting power off to the parts that aren't concerned to the test, also i guess this would be a good precaution when playing with high voltage DC power units.

POWER MANAGEMENT

  • 14.8V LIPO/4S/2600mAh Battery- Powers the Base stepper motor.
  • 12V LIPO/3S/2200mAh Battery- Powers the Wrist stepper motor, the rectangular LED set, and the LED strip
  • 7.4v LIPO/2S/800mAh Battery- Powers the five base servos (17g) in the hand assembly.
  • 9V Generic Battery - Powers the Arduino Mega and the five top servos (4.1g) in the hand assembly.

POSSIBLE FUTURE DEVELOPMENTS

  • Gesture Bot could be controlled with bluetooth or wifi via an APP. In addition to this a custom remote control device could be designed to be controlled with the numerous analog pins which haven't been used as of yet.
  • In terms of design i believe there is a lot of room for improvement although there might pose some challenges to find the appropriate hardware to suit a sleek and slender robotic hand. i would love the input from the community on this and welcome any changes you make.

Code

Gesture Bot control via serial commandsArduino
This code is just used to control the hand using keyboard command. It can be modified in the future to work with a blutooth, wifi module and control via an app. A custom remote or perhaps glove could also be used to control but for now i've just tested with the commands sent via computer keyboard.
#include <Servo.h>

Servo servo1;
Servo servo2; 
Servo servo3; 
Servo servo4; 
Servo servo5;
Servo servo7;
Servo servo6;
Servo servo8;
Servo servo9;
Servo servo10;

int servoPosA = 170;
int servoPosB = 160;
int servoPosC = 100;
int servoPosD = 100;
int servoPosE = 120;
int servoPosF = 100;
int servoPosG = 100;
int servoPosH = 100;
int servoPosI = 180;
int servoPosJ = 100;


int led1 = 24; // single led
int led2 = 25; // single led
int ledSet1 = 12; // LED SET
int ledSet2 = 13; // LED SET
int BUTTON = 22;
boolean buttonState = LOW;
int i;


int pulPin1 = 52;
int dirPin1 = 53;
int pulPin2 = 50;
int dirPin2 = 51;

void setup() {
  
  for (int q = 2; q < 14; q++){
  pinMode(q, OUTPUT);
  }
  pinMode(22, INPUT);
  pinMode(24, OUTPUT);
  pinMode(25, OUTPUT);
  for (int w = 50; w < 54; w++){
  pinMode(w, OUTPUT);
  }
  
  servo1.attach(2);
  servo2.attach(3);
  servo3.attach(4);
  servo4.attach(5);
  servo5.attach(6);
  servo7.attach(7);
  servo6.attach(8);
  servo8.attach(9);
  servo9.attach(10);
  servo10.attach(11);

  delay(4000);
  
  /* the following bit of code stops the hand from moving further more when the push button is pressed, once pressed moves to a certail number of steps for its origin*/

 while (buttonState == LOW){
  for (int e = 0; e < 1; e++){
  digitalWrite(dirPin1, HIGH);
  buttonState = digitalRead(BUTTON);
  digitalWrite(pulPin1, HIGH);
  buttonState = digitalRead(BUTTON);
  delayMicroseconds(5000);
  buttonState = digitalRead(BUTTON);
  digitalWrite(pulPin1, LOW);
   buttonState = digitalRead(BUTTON);
  delayMicroseconds(5000);
  buttonState = digitalRead(BUTTON);
  } 
}
if (buttonState == HIGH){
  for (int f = 0; f < 300; f++){
  digitalWrite(dirPin1, LOW);
  digitalWrite(pulPin1, HIGH);
  delayMicroseconds(10000);
  digitalWrite(pulPin1, LOW);
  delayMicroseconds(10000);
  }
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);
  delay(2000);
}
Serial.begin(9600);
Serial.println("Please select a control hinge for the hand from the keypad");
}

void loop() {
servoPosA = constrain(servoPosA, 80, 170);
servoPosB = constrain(servoPosB, 90, 180);
servoPosC = constrain(servoPosC, 100, 150);
servoPosD = constrain(servoPosD, 100, 150);
servoPosE = constrain(servoPosE, 75, 160);
servoPosF = constrain(servoPosF, 100, 150);
servoPosG = constrain(servoPosG, 85, 170);
servoPosH = constrain(servoPosH, 100, 150);
servoPosI = constrain(servoPosI, 10, 180);
servoPosJ = constrain(servoPosJ, 100, 150);



while (Serial.available() > 0){
  
  char hand_move = Serial.read();
  if (hand_move == 'a'){
    Serial.println("Selected finger - LITTLE FINGER_LOWER HINGE_OPEN");
    for(int i = 170; i>80; i--){
    servo1.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == 'z'){
    Serial.println("Selected finger - LITTLE FINGER_LOWER HINGE_CLOSE");
    for(int j = 80; j<170; j++){
    servo1.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
    if (hand_move == 's'){
    Serial.println("Selected finger - RING FINGER_LOWER HINGE_OPEN");
    for(int i = 180; i>90; i--){
    servo2.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == 'x'){
    Serial.println("Selected finger - RING FINGER_LOWER HINGE_CLOSE");
    for(int j = 90; j<180; j++){
    servo2.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
    if (hand_move == 'q'){
    Serial.println("Selected finger - LITTLE FINGER_UPPER HINGE_OPEN");
    for(int i = 150; i>100; i--){
    servo3.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == '1'){
    Serial.println("Selected finger - LITTLE FINGER_UPPER HINGE_CLOSE");
    for(int j = 100; j<150; j++){
    servo3.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
    if (hand_move == 'w'){
    Serial.println("Selected finger - RING FINGER_UPPER HINGE_OPEN");
    for(int i = 150; i>100; i--){
    servo4.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == '2'){
    Serial.println("Selected finger - LITTLE FINGER_LOWER HINGE_CLOSE");
    for(int j = 100; j<150; j++){
    servo4.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
    if (hand_move == 'd'){
    Serial.println("Selected finger - MIDDLE FINGER_LOWER HINGE_OPEN");
    for(int i = 160; i>75; i--){
    servo5.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == 'c'){
    Serial.println("Selected finger - MIDDLE FINGER_LOWER HINGE_CLOSE");
    for(int j = 75; j<160; j++){
    servo5.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
    if (hand_move == 'f'){
    Serial.println("Selected finger - INDEX FINGER_LOWER HINGE_OPEN");
    for(int i = 170; i>85; i--){
    servo6.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == 'v'){
    Serial.println("Selected finger - INDEX FINGER_LOWER HINGE_CLOSE");
    for(int j = 85; j<170; j++){
    servo6.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
    if (hand_move == 'e'){
    Serial.println("Selected finger - MIDDLE FINGER_UPPER HINGE_OPEN");
    for(int i = 150; i>100; i--){
    servo7.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == '3'){
    Serial.println("Selected finger - MIDDLE FINGER_UPPER HINGE_CLOSE");
    for(int j = 100; j<150; j++){
    servo7.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
    if (hand_move == 'r'){
    Serial.println("Selected finger - INDEX FINGER_UPPER HINGE_OPEN");
    for(int i = 150; i>100; i--){
    servo8.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == '4'){
    Serial.println("Selected finger - INDEX FINGER_UPPER HINGE_CLOSE");
    for(int j = 100; j<150; j++){
    servo8.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
    if (hand_move == 'g'){
    Serial.println("Selected finger - THUMB_LOWER HINGE_OPEN");
    for(int i = 180; i>10; i--){
    servo9.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == 'b'){
    Serial.println("Selected finger - THUMB_LOWER HINGE_CLOSE");
    for(int j = 10; j<180; j++){
    servo9.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
    if (hand_move == 't'){
    Serial.println("Selected finger - THUMB_UPPER HINGE_OPEN");
    for(int i = 150; i>100; i--){
    servo10.write(i);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == '5'){
    Serial.println("Selected finger - THUMB_UPPER HINGE_CLOSE");
    for(int j = 100; j<150; j++){
    servo10.write(j);
    delay(25);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
    }
     
  }
  if (hand_move == '-'){
    Serial.println("Selected ELBOW_UP");
    for (int f = 0; f < 50; f++){
    digitalWrite(dirPin1, LOW);
    digitalWrite(pulPin1, HIGH);
    delayMicroseconds(10000);
    digitalWrite(pulPin1, LOW);
    delayMicroseconds(10000);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
     
    }
  }
  if (hand_move == '+'){
    Serial.println("Selected ELBOW_DOWN");
    for (int g = 0; g < 50; g++){
    digitalWrite(dirPin1, HIGH);
    digitalWrite(pulPin1, HIGH);
    delayMicroseconds(10000);
    digitalWrite(pulPin1, LOW);
    delayMicroseconds(10000);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
     
    }
  }
  if (hand_move == '/'){
    Serial.println("Selected WRIST_ANTICLOCKWISE");
    for (int f = 0; f < 200; f++){
    digitalWrite(dirPin2, HIGH);
    digitalWrite(pulPin2, HIGH);
    delayMicroseconds(3000);
    digitalWrite(pulPin2, LOW);
    delayMicroseconds(3000);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
     
    }
  }
   if (hand_move == '*'){
    Serial.println("Selected WRIST_CLOCKWISE");
    for (int g = 0; g < 200; g++){
    digitalWrite(dirPin2, LOW);
    digitalWrite(pulPin2, HIGH);
    delayMicroseconds(3000);
    digitalWrite(pulPin2, LOW);
    delayMicroseconds(3000);
    char stop_sense = Serial.read();
    if (stop_sense == '.'){
      break;
      }
     
    }
  }
  

  
 }

}
Gesture Bot serial command code
This code allows the user to control gesture bot using the serial commands.

Custom parts and enclosures

Gesture Bot design files
These are the CATIA V5 design files for Gesture Bot and the respective repository for it.

Schematics

The Schematic Diagram
Gesture Bot schematic diagram
Gbotfinalschematic y73bjvfewh

Comments

Author

Hannu hell
hannu_hell
  • 2 projects
  • 5 followers

Additional contributors

Published on

September 7, 2018

Members who respect this project

PhotoCarlosjoseDefault

and 8 others

See similar projects
you might like

Similar projects you might like

Arduino Bluetooth Basic Tutorial

by Mayoogh Girish

  • 454,994 views
  • 42 comments
  • 239 respects

Home Automation Using Raspberry Pi 2 And Windows 10 IoT

Project tutorial by Anurag S. Vasanwala

  • 285,519 views
  • 95 comments
  • 671 respects

Security Access Using RFID Reader

by Aritro Mukherjee

  • 229,964 views
  • 38 comments
  • 239 respects

OpenCat

Project in progress by Team Petoi

  • 195,999 views
  • 154 comments
  • 1,363 respects
Add projectSign up / Login