CET4811_FINAL_LAB

Final Lab: Gripperbot
1
NEW YORK CITY COLLEGE OF TECHNOLOGY
Final Project:Gripperbot
Group Members: Clara Irizarry, Anton Scott
Class: CET 4811 – Computer Controlled System Design II
Semester: Fall 2014
Professor: Prof. Zia
Date: 11/30/2014

2
Table of Contents
I. Project Summary………………………….pg. 3
II. Project Management Plan………………...pg. 4
III. Mechanical Design……………...………..pgs. 5-6
IV. Electrical Design………………………....pgs. 7-8
V. Software Design……………………...…..pgs. 8-10
VI. Appendix………………………...………pgs. 11-14
VII. References…………………………...…..pgs. 15-18

3
Project Summary
Forour project, we decided to explore the relationship between Arduino and
robotics. We decided to create a robotarm that can grab objects and move via
wireless communication with remote inputs, which will also be programmed via
Arduino. This project is known as a Gripperbot. The Gripperbotis a rolling robotic
arm that one can controlwith arm-mounted Arduinos equipped with Wii
Nunchuks, and a wireless card for communicating with the robot. The roller that
the arm is connected to packs an Arduino also, along with a Bricktronics Shield
and Bricktronics Motor Controller.
The conceptof this project is that there are a variety of motors working
together to create motion. There are two on the base of the robot, which help with
moving the arm around, and then there are 4 on the turret, which operate the
spinner, the elbow, the wrist and the gripper. The bracers that are worn translate
motion and button inputs into speeds for specific motors. This communication is
done wirelessly, using XBee Wireless Adapters. All of the XBee nodes broadcast
to each other. The base and the turret receive all messages, and only act on the
ones intended for motors that they control. The turret uses the Bricktronics Motor
Controller, which is pre-programmed with a set of commands for up to 5 motors.
The base has an Arduino, a XBee Adapter with shield, and a Bricktronics Shield,
which host the left and right motors of the base, controlling the wheels. All of this
is powered up by 6-AA battery packs.
The arm portion of the robothas a Brocktronics Motor Board equipped with
a XBee. Power Functions motors are plugged into the Motor Board through Molex
connectors and the Mindstorms motors are plugged in via Mindstorms wires. All of
this runs on 6-AA batteries.

4
Project Management Plan

5
Mechanical Design
-Lego NXT Servo Motor
NXT motor
This motor is specific to the NXT set (2006).
Includes a rotation encoder, returning to the NXT
the position of the shaft with 1° resolution. Because
of the special connector of this motor (non-standard
phone plug type), a cable adapter is required to drive
this motor with regular 9V sources. Not
recommended for use with a RCX which can't
deliver the high current that this motor can consume.
Slow rotation speed, minimizing the need of external
gear train.
NXT
Torque
Rotation
speed
Current
Mechanical
power
Electrical
power
Efficiency
4.5 V 16.7 N.cm 33 rpm 0.6 A 0.58 W 2.7 W 21.4 %
7 V 16.7 N.cm 82 rpm 0.55 A 1.44 W 3.85 W 37.3 %
9 V 16.7 N.cm 117 rpm 0.55 A 2.03 W 4.95 W 41 %
12 V 16.7 N.cm 177 rpm 0.58 A 3.10 W 6.96 W 44.5 %

6
-Nintendo Wii Nunchuck

8
-Wii Nunchuck I2C Breakout Adapter Board

9
Electrical Design

10
Software Design
To allow the Gripperbotto respond to mechanical movements, we had to use a
software program that will use programming language to synchronize into the
Arduino microcontroller board to respond to certain coding. The Arduino Software
integrated development environment (IDE) is what we need to create three codes
that will achieve this.
-The Base of the Gripperbot Source Code and Flowcharts
#include <Wire.h>
#include <Bricktronics.h>
Bricktronics brick = Bricktronics();
Motor r = Motor(&brick, 1);
Motor l = Motor(&brick, 2);
void setup()
{
Serial.begin(9600);
brick.begin();
r.begin();
l.begin();
}
void process_incoming_command(char cmd, char arg0)
{
int speed = 0;
switch (cmd)
{
case '6':
case 6:
speed = arg0*2;
l.set_speed(speed);

11
break;
case '7':
case 7:
speed = arg0*2;
r.set_speed(speed);
break;
default:
break;
}
}
void loop() {
while (Serial.available() < 3)
{
//Do nothing while we wait for a full command to come in.
}
char start = Serial.read();
if (start != '*')
{
return;
}
char cmd = Serial.read();
char arg0 = Serial.read();
process_incoming_command(cmd, arg0);
}

14
-The Left Bracer of the Gripperbot Source Code and Flowcharts
#include <Wire.h>
#include <ArduinoNunchuk.h>
ArduinoNunchuk nunchuk = ArduinoNunchuk();
#define NUM_OF_READINGS 10
char pitch_index = 0;
int pitch_readings[NUM_OF_READINGS];
int pitch_total = 0;
void setup()
{
Serial.begin(9600);
init_nunchuk_connections();
delay(100);
nunchuk.init();
for (int i = 0; i < NUM_OF_READINGS; i++)
{
pitch_readings[i] = 0;
}
}
void loop()
{
nunchuk.update();
handle_left_tank_tread(nunchuk.accelY);
delay(50);
}
void init_nunchuk_connections()
{
pinMode(A2, OUTPUT);
digitalWrite(A2, LOW);
digitalWrite(A3, HIGH);
}
int average_accel_pitch(int raw_pitch)
{

15
pitch_total -= pitch_readings[pitch_index];
pitch_readings[pitch_index] = raw_pitch;
pitch_total += pitch_readings[pitch_index];
pitch_index += 1;
if (pitch_index >= NUM_OF_READINGS)
{
pitch_index = 0;
}
return pitch_total / NUM_OF_READINGS;
}
int last_left_speed = 0;
void handle_left_tank_tread(int raw_accel_pitch)
{
int avg_pitch = average_accel_pitch(raw_accel_pitch);
#define PITCH_CENTER 550
#define MAX_PITCH PITCH_CENTER+150
#define MIN_PITCH PITCH_CENTER-150
#define MAX_FORWARD 127
#define MAX_BACKWARD -128
avg_pitch = constrain(avg_pitch, MIN_PITCH, MAX_PITCH);
int left_speed = map(avg_pitch, MIN_PITCH, MAX_PITCH, MAX_BACKWARD,
MAX_FORWARD);
left_speed = constrain(left_speed, MAX_BACKWARD, MAX_FORWARD);
if (left_speed != last_left_speed)
{
last_left_speed = left_speed;
Serial.write('*');
Serial.write(6);
char out = left_speed;
Serial.write(out);
}
}

18
-The Right Bracer of the Gripperbot Source Code and Flowcharts
#include <Wire.h>
#include <ArduinoNunchuk.h>
ArduinoNunchuk nunchuk = ArduinoNunchuk();
#define NUM_OF_READINGS 10
char roll_index = 0;
int roll_readings[NUM_OF_READINGS];
int roll_total = 0;
char pitch_index = 0;
int pitch_readings[NUM_OF_READINGS];
int pitch_total = 0;
void setup()
{
Serial.begin(9600);
init_nunchuk_connections();
delay(100);
nunchuk.init();
for (int i = 0; i < NUM_OF_READINGS; i++)
{
roll_readings[i] = 0;
pitch_readings[i] = 0;
}
}
void loop()
{
nunchuk.update();
handle_right_tank_tread(nunchuk.accelY);
handle_wrist(nunchuk.accelX);
handle_spin(nunchuk.analogX);
handle_elbow(nunchuk.analogY);
handle_grip(nunchuk.zButton, nunchuk.cButton);
delay(50);
}

19
void init_nunchuk_connections()
{
digitalWrite(A2, LOW);
digitalWrite(A3, HIGH);
}
int average_accel_pitch(int raw_pitch)
{
pitch_total -= pitch_readings[pitch_index];
pitch_readings[pitch_index] = raw_pitch;
pitch_total += pitch_readings[pitch_index];
pitch_index += 1;
if (pitch_index >= NUM_OF_READINGS)
{
pitch_index = 0;
}
return pitch_total / NUM_OF_READINGS;
}
int average_accel_roll(int raw_roll)
{
roll_total -= roll_readings[roll_index];
roll_readings[roll_index] = raw_roll;
roll_total += roll_readings[roll_index];
roll_index += 1;
if (roll_index >= NUM_OF_READINGS)
{
roll_index = 0;
}
return roll_total / NUM_OF_READINGS;
}
int last_right_speed = 0;

20
void handle_right_tank_tread(int raw_accel_pitch)
{
int avg_pitch = average_accel_pitch(raw_accel_pitch);
#define PITCH_CENTER 550
#define MAX_PITCH PITCH_CENTER+150
#define MIN_PITCH PITCH_CENTER-150
#define MAX_FORWARD 127
#define MAX_BACKWARD -128
avg_pitch = constrain(avg_pitch, MIN_PITCH, MAX_PITCH);
int right_speed = map(avg_pitch, MIN_PITCH, MAX_PITCH, MAX_BACKWARD,
MAX_FORWARD);
right_speed = constrain(right_speed, MAX_BACKWARD, MAX_FORWARD);
if (right_speed != last_right_speed)
{
last_right_speed = right_speed;
Serial.write('*');
Serial.write(7);
char out = right_speed;
Serial.write(out);
}
}
int last_spin_speed = 0;
void handle_spin(int joy_x)
{
#define JOY_X_CENTER 129
#define MAX_JOY_X JOY_X_CENTER+101
#define MIN_JOY_X JOY_X_CENTER-97
#define MAX_RIGHT_SPIN 127
#define MAX_LEFT_SPIN -128

21
joy_x = constrain(joy_x, MIN_JOY_X, MAX_JOY_X);
int spin_speed = map(joy_x, MIN_JOY_X, MAX_JOY_X, MAX_LEFT_SPIN,
MAX_RIGHT_SPIN);
spin_speed = constrain(spin_speed, MAX_LEFT_SPIN, MAX_RIGHT_SPIN);
if (spin_speed != last_spin_speed)
{
last_spin_speed = spin_speed;
Serial.write('*');
Serial.write(1);
char out = spin_speed;
Serial.write(out);
}
}
int last_elbow_speed = 0;
void handle_elbow(int joy_y)
{
#define JOY_Y_CENTER 126
#define MAX_JOY_Y JOY_Y_CENTER+86
#define MIN_JOY_Y JOY_Y_CENTER-98
#define MAX_UP_ELBOW 127
#define MAX_DOWN_ELBOW -128
joy_y = constrain(joy_y, MIN_JOY_Y, MAX_JOY_Y);
int elbow_speed = map(joy_y, MIN_JOY_Y, MAX_JOY_Y, MAX_UP_ELBOW,
MAX_DOWN_ELBOW);
elbow_speed = constrain(elbow_speed, MAX_DOWN_ELBOW, MAX_UP_ELBOW);
if (elbow_speed != last_elbow_speed)
{
last_elbow_speed = elbow_speed;
Serial.write('*');
Serial.write(2);
char out = elbow_speed;
Serial.write(out);
}
}

22
int last_wrist_speed = 0;
void handle_wrist(int raw_accel_roll)
{
int avg_roll = average_accel_roll(raw_accel_roll);
#define ROLL_CENTER 560
#define MAX_ROLL ROLL_CENTER+220
#define MIN_ROLL ROLL_CENTER-220
#define MAX_RIGHT_WRIST 127
#define MAX_LEFT_WRIST -128
avg_roll = constrain(avg_roll, MIN_ROLL, MAX_ROLL);
int wrist_speed = map(avg_roll, MIN_ROLL, MAX_ROLL, MAX_LEFT_WRIST,
MAX_RIGHT_WRIST);
wrist_speed = constrain(wrist_speed, MAX_LEFT_WRIST, MAX_RIGHT_WRIST);
if (wrist_speed != last_wrist_speed)
{
last_wrist_speed = wrist_speed;
Serial.write('*');
Serial.write(3);
char out = wrist_speed;
Serial.write(out);
}
}
char last_cmd = 0;
void handle_grip(boolean z, boolean c)
{
#define GRIP_OUT_SPEED 100
#define GRIP_IN_SPEED -100
if (z == c)
{
if (last_cmd != 0)
{
last_cmd = 0;
Serial.write('*');
Serial.write(4);

23
Serial.write((unsigned byte) 0);
}
} else if (z) //out
{
if (last_cmd != 'z')
{
last_cmd = 'z';
Serial.write('*');
Serial.write(4);
Serial.write(GRIP_OUT_SPEED);
}
} else if (c) //in
{
if (last_cmd != 'c')
{
last_cmd = 'c';
Serial.write('*');
Serial.write(4);
Serial.write(GRIP_IN_SPEED);
}
}
}

26
Appendix
-Lego NXT Servo Motor Graphs

27
-Arduino Uno Microcontroller Board Datasheet

29
-Arduino Mega

31
-Xbee Wireless RF Module Adapters

35
-Xbee Shield V1.4

38
-Bricktronics Shield

39
-Bricktronics Megashield

41
References
-http://code2flow.com/ code2flow:Online interactive code to flowchart
converter(Demo)
-Visustin V7: Flow chart generator software (Demo)
- http://mindstormsnxt.blogspot.com/2006/08/closer-look-at-nxt-motors.html
-http://www.eurobricks.com/forum/index.php?showtopic=72666
- http://brittonkerin.com/annotateduino/annotatable_uno.html
- http://www.philohome.com/motors/motorcomp.htm
-http://www.digi.com/products/wireless-wired-embedded-solutions/zigbee-rf-
modules/zigbee-mesh-module/xbee-zb-module#specs
-http://www.digi.com/products/wireless-wired-embedded-solutions/zigbee-rf-
modules/point-multipoint-rfmodules/xbee-series1-module#specs
-http://www.dfrobot.com/index.php?route=product/product&product_id=61
-http://www.wayneandlayne.com/bricktronics/
-http://arduino-info.wikispaces.com/MegaQuickRef
-http://atmega32-avr.com/wp-
content/uploads/2012/06/arduino_mega_2560_schematic.gif

42
-http://www.robotshop.com/media/files/PDF/inex-zx-nunchuck-datasheet.pdf

CET4811_FINAL_LAB

More Related Content

What's hot

Similar to CET4811_FINAL_LAB

CET4811_FINAL_LAB