1

TECHNICAL PROJECT FINAL REPORT FOR ET 494 SENIOR DESIGN II

Industrializing the Robotic Arm

Southeastern Louisiana University

Department of Computer Sciences and Industrial Technology

BY: Michael Hernandez, Peter DiMarco, Jordan Martin

ET 494 SENIOR DESIGN II-INTERIM REPORT

Spring 2018

Instructor: Dr. Cris Koutsougeras

Advisor: Dr. Mohammad Saadeh

2

ABSTRACT:

This project is a continuation of our previous senior project under the supervision of Dr.

Saadeh and Dr. Koutsougeras. The goal of this project is to operate a simple pick and place

system using a programmable logic controller with the assistance of a microcontroller. This

process is achieved through servo motors controlling the motion of robotic arms that objects and

move them along a path. Our project will mimic a simple pick and place system that can show

how a typical manufacturing system operates.

3

INTRODUCTION:

In almost every manufacturing process in an industry, the typical workforce includes

robotics. The most common type is the articulated robotic arm which includes rotation at the

joints and is usually arranged in a chain to reach into difficult places. Robots are essential for

smooth and efficient operation in a specific process. They are mostly controlled by PLC which

allow for ladder logic programming or microcontrollers that can be programmed for certain

tasks. A microcontroller is a small computer on a single integrated circuit that can provide

control to a robotic arm or any other manufacturing equipment with appropriate coding. Some

examples of applications that use microcontrollers are: instrumentation, high-precision assembly,

sensing, order picking, and many more. For this project, we will include a PLC component that

will control the entire process for the system and an Arduino component that will separately

control the motions for each function of the project.

4

SETUP:

The design of the project exhibits a typical industrial pick and place manufacturing

system. Mainly, it is desired to have all functions running at the same time using a single code

that can scale the movements for all components in the system to work simultaneously (Figure

1).

Figure 1- Process Flow Chart

It begins by placing a block on the second conveyor belt and the belt will move it towards

the second robotic arm. That arm will move from its home position to the first position at the tray

5

and pick up the block from the tray. It will move to the second position by the first conveyor belt

and then place the block on it and return to its home position. The block will move along the

first conveyor belt, land on the rotating platform and rotate towards the first robotic arm. The

first robotic arm will be at its home position awaiting an instruction to move to the block on the

rotating platform. It will then receive a signal to move to the first position where the block is on

the rotating platform. It will pick the block and move to the second position where the second

conveyor belt will be positioned. It will place the block on the second conveyor belt and the belt

will move towards the second robotic arm. This series of events will mimic a simple pick and

place system that is seen in a manufacturing plant, but a scaled down version that will run on a

single microcontroller and PLC for triggering each movement (Figure 2).

Figure 2- Process Flow Design

6

MATERIALS:

The project includes two robotic arms, two conveyor belts, and a rotating platform, all

programmed by a C/C++ code written in the open source Arduino IDE and a simple ladder logic

program written in the ClickPLC software. A previous introduction to the project included a

ClickPLC and for functions to run smoothly, we decided to bring back the ClickPLC. The PLC

will be used to control the Arduino’s actions based on where objects are in the system. The PLC

will receive a sensor signal telling where and object is and will transmit that signal to the

Arduino telling it what to move next based on the PLC ladder logic code. The robotic arms will

work in conjunction with two conveyor belts and a rotating platform to move objects from one

belt to another, mimicking a simple pick and place manufacturing system. This process will

ultimately run on the Arduino with the PLC controlling what happens next based on the process

flow chart (Figure 1). The robotic arms (Figure 3 and 4) are constructed using aluminum C-

channels, pattern brackets, servo gearboxes, and linear actuators that are controlled using the

Arduino PWM output pins.

7

Figure 3- Robotic Arm 1

8

Figure 4- Robotic Arm 2

The servos (Figure 5) used to control the robotic arms are the Hitec HS785-HB. These

servos offer high torque for stability when moving, and they provide continuous rotation which

allows us to have freedom of movement for each arm.

9

Figure 5- Hitec HS785-HB Servo

The rotating platform (Figure 6) utilizes a basic DC servo motor (Figure 7) including an

on-board encoder that will send and receive position signals to the system controller.

Figure 6- Rotating Platform Figure 7- DC Motor

10

The conveyor belts used in the project were adopted from previous projects and are

controlled using stepper motors. Stepper motors are DC motors that achieve accurate motions

based on a sequence of coordinated and minute step motions. Prior knowledge of the number of

steps needed to obtain a full rotation is important to achieve precise positioning and speed

control of the motor. The first conveyor belt (Figure 8) is powered by a NEMA 17 stepper motor

with a built-in gearbox (Figure 9).

Figure 8- Conveyor Belt 1

Figure 9- NEMA 17 Stepper Motor

This stepper motor will drive the conveyor belt at a low speed but high torque which can

allow for heavier objects to be transported on the belt if needed. The second conveyor belt

Gearbox

11

(Figure 10) was adopted from a previous senior design project and uses a larger and more

powerful stepper motor.

Figure 10- Conveyor Belt 2

The NEMA 34 stepper motor (Figure 11) is used for this conveyor belt and offers a

generous amount of torque and can be adjusted for motor current and steps per revolution. These

adjustments can make the motor operate in a smoother motion while still offering enough power

which is beneficial for our project as we will most likely not use the full power of this stepper

motor.

12

Figure 11- NEMA 34 Stepper Motor

Stepper motors need plenty of power to operate. A microcontroller that will be used to

program a stepper motor needs to use a shield to protect itself from back electromotive force.

The stepper driver is a messenger that receives a signal from the Arduino and drives the stepper

based on the pulse signal that is received. The driver also protects the low voltage Arduino from

back electromotive force coming from the stepper motor that can cause critical damage to the

Arduino. A wiring schematic (Figure 12 and 13) shows how we wired each servo for the two

robotic arms.

13

Figure 12- Robotic Arm Wiring

Figure 13- Robotic Arm Schematic

DELIVERABLES:

Date Objective Who

Jan.-Mar.

90%

Re-code the Arduino to

control the two arms

Michael, Jordan, Peter

Mar.-Apr.

40%

Introduce the stepper motor

and platform to the code

Michael, Peter

Apr.-May

30%

Combine the arms, conveyor

belt, and platform to one code

Michael, Jordan, Peter

14

REMAINING TIMELINE:

Date Objective

Late AprilFinalize robotic arm and conveyor belts on

Arduino

April - May 10Implement ClickPLC with Arduino code to

control parallel actions

COST:

The cost for this semester will be at minimum because most of the materials are

accounted for and already purchased. Changes in the design forced a new problem with the

microcontroller and how it will handle every PWM signal. The previous microcontroller used

was an Arduino UNO which had a total of thirteen digital pins, six of those pins are assigned a

PWM output. The project uses a total of eight servo motors and would not be able to run on the

UNO because of the lack of pins needed. The next viable option would be purchasing a

microcontroller with more PWM output, and the Arduino Mega was a clear winner for the

project. The Mega has more flash memory allowing it to store more code and it has nine more

digital PWM output pins which cover the need for this design. The new implementation used for

the project will include a ClickPLC to provide parallel control and synchronization of events.

These tasks are not readily available if we only use the Arduino. The ClickPLC used will include

a power supply, CPU, and voltage output module. The ClickPLC was used in a previous project

and will not include any other expenses for the project.

15

PROGRESS AND ISSUES:

This project was initially only going to run on the Arduino MEGA because the ClickPLC

would not be able to fully control the robotic arms. The servos need precise signals and timing to

move to certain locations and the ClickPLC would not be able to provide these signals. It was

decided to introduce the ClickPLC again to the project, but only for semi controlling the actions.

The ClickPLC communicates to the Arduino where the objects are and when to move the robotic

arms and conveyor belts. This process works by connecting an output signal from the PLC to an

input on the Arduino. The ladder logic for testing the signals is shown below (Figure 14).

Figure 14- PLC Ladder Logic

The PLC will receive a signal from sensors (Figure 15 and Figure 16) connected to

conveyor belt 2. Those sensors will trigger outputs (Y101 and Y102) that are connected to the

Arduino that will tell the conveyor belt which direction to travel.

16

Figure 15- Right Belt 2 Sensor Figure 16- Left Belt 2 Sensor

When the second conveyor belt reaches the right position, it will trigger the sensor in the PLC

ladder logic to tell the Arduino to stop the belt. After a small delay, the Arduino will tell the first

robotic arm to move to the set position by the second conveyor belt to pick up the block. The

sensors allow the Arduino to know where the second conveyor belt is and which robotic arm to

move. The process will utilize the PLC only to control sensors that tell when the Arduino can

activate certain functions. These specific functions that move the conveyor belts and robotic

arms are programmed on the Arduino, allowing us to have a microcontroller for precise

applications and still being able to include an industrial control process with a programmable

logic controller.

17

RAW CODE:

#include <Servo.h>#include <Stepper.h>Servo servo1;Servo servo2;Servo servo3;Servo servo4;

int pb1=0;int pb2=0;int new_servoArray1;int new_servoArray2;int new_servoArray3;int new_servoArray4;int val1;int val2;int val3;int val4;int check1=0;int last1=0;int last2=0;int check2=0;int last3=0;int last4=0;int i=0;int j=0;int inc;int inc2;int flag=0;int flag2=0;int dir = 1; // 1 for ascending, -1 for descendingint del = 1;//int dir2 = 1; // 1 for ascending, -1 for descendingint del2 = 1;int enablePin=8;int directionPin=9;int pulsePin=10;int PBPIN1 = 22;int PBPIN2 = 24;

int servoArray1[][10]={{178,178,178,178,178,178,178,178,178,178}, {178,178,180,182,184,184,186,188,188,190},

18

{190,183,176,169,162,155,148,141,138,135}, {135,140,145,150,155,160,165,170,175,178}};int servoArray2[][10]={{180,180,180,180,180,180,180,180,180,180}, {180,171,162,153,144,135,126,117,109,105}, {105,124,143,162,181,200,219,238,257,263}, {263,253,243,233,223,212,202,195,187,180}};int servoArray3[][10]={{180,180,180,180,180,180,180,180,180,180}, {180,169,158,147,146,135,124,113,102,95}, {95,110,125,140,155,165,180,195,210,215}, {215,211,207,203,199,195,191,187,183,180}};int servoArray4[][10]={{180,180,180,180,180,180,180,180,180,180}, {180,198,216,234,252,270,288,306,318,325}, {325,303,279,255,231,207,183,159,135,130}, {130,136,142,148,154,160,166,172,178,180}};

void setup() {

Serial.begin(9600);servo1.attach(3);servo2.attach(5);servo3.attach(10);servo4.attach(11);servo1.write(servoArray1[1][1]);servo2.write(servoArray2[1][1]);servo3.write(servoArray3[1][1]);servo4.write(servoArray4[1][1]);pinMode (pulsePin, OUTPUT);pinMode (directionPin, OUTPUT);pinMode (enablePin, OUTPUT);}

void loop() {

ARM1TRAJECTORY();ARM2TRAJECTORY();

}

void ARM1TRAJECTORY(){pb1=digitalRead(PBPIN1); // push button read from pin 22

if((pb1==1||check1==1)&& flag==0){delay(20);}

19

pb1=digitalRead(PBPIN1); if((pb1==1||check1==1)&& flag==0){ check1=pb1; }

if(check1==1){ //delay(50); i=i+del; flag = 1; }

//delay(500);

if (i>=0 && i<=3 && flag==1){for(inc=0;inc<10;inc++){new_servoArray1 = servoArray1[i][inc];new_servoArray2 = servoArray2[i][inc];val1 = map(new_servoArray1,0,360,600,1755);val2 = map(new_servoArray2,0,360,600,1740);servo1.write(val1);servo2.write(val2);Serial.println("servo1: ");Serial.println(new_servoArray1);Serial.println("servo2: ");Serial.println(new_servoArray2);delay(50);

}

if (i==3){del = -2*dir;}else if (i==1){del = dir;}

flag = 0;check1 = 0;

}Serial.println("i = ");Serial.println(i);Serial.println("inc = ");Serial.println(inc);}

20

void ARM2TRAJECTORY(){pb2 = digitalRead(PBPIN2); // push button read from pin 24

if((pb2==1||check2==1)&& flag2==0){delay(20);}

pb2 = digitalRead(PBPIN2); if((pb2==1||check2==1)&& flag2==0){ check2=pb2; } if(check2==1){ //delay(50); j=j+del2; flag2 = 1; }

if (j>=0 && j<=3 && flag==1){for(inc2=0;inc2<10;inc2++){new_servoArray3 = servoArray3[j][inc2];new_servoArray4 = servoArray4[j][inc2];val3 = map(new_servoArray3,0,360,600,1755);val4 = map(new_servoArray4,0,360,600,1740);servo3.write(val3);servo4.write(val4);Serial.println("servo3: ");Serial.println(new_servoArray3);Serial.println("servo4: ");Serial.println(new_servoArray4);delay(50);

}

if (j==3){del2 = -2*dir;}else if (j==1){del2 = dir;}

flag2 = 0;check2 = 0;

}Serial.println("j = ");Serial.println(j);

21

Serial.println("inc2 = ");Serial.println(inc2);}

22