Southeastern Louisiana University

Final ReportMarine Debris Cleaner

Ryan Fabre & Brock Dickinson

ET 493

Dr. Fayed

November 27, 2017

Abstract

Ryan Fabre and Brock Dickinson have been assigned to construct a marine debris cleaner

to find a way as to get rid of plastic debris in bodies of water. This initiative took effect in

August of 2017 with simple goals to construct a debris cleaner that could navigate from point a

to b and store trash. We as a team have worked hard conducting research and over the last two

months have been testing individual components using Arduino programming. We will begin

assembly of the debris cleaner on the week of December 3, 2017.

Project Goals

The project goals have been conducted in order of importance. Each goal of the project

has smaller goals that need to be completed before work on the next goal can begin. The first

goal of the project was to find a design that would work the best and be inexpensive. This goal

took weeks of research to determine the best design. Our design used two arms as a retrieval

system. This design was confirmed to be problematic for the scope of this project, which was to

collect debris using the least amount of power as possible. It made the weight of the vessel weigh

more, and it used the power that could be used to

control the boat and give a longer operation time.

Our target time for operating the boat is twenty

minutes. Instead of using two arms we decided to

use one arm that was capable of moving around in a

work area with a radius of 28.5cm and a half

circumference of 180 degrees. We finally decided to

purchase a vessel instead of building one from scratch.

The second goal was to find the best parts that would make the debris cleaner function

and deliver the expected outcome and give the best results. This step also took weeks to try and

decide what parts we would use for the project. We have decided to use an Arduino Braccio as

the robotic arm, a Raspberry Pi 2 as the computer that will run the code from the Arduino ide, an

Arduino Mega 2560 as the micro-controller that will control the servos, the motor, and a power

supply. The next step of the project is to program all the parts that will make the debris cleaner

function. We have successfully managed to start programming the parts to make the debris

cleaner work. We have completed the central parts of the debris cleaner such as the steering

servo and controller. The last step is to assemble all the necessary parts of the marine debris

cleaner and mount them on to the vessel.

Design

The design has been the most time consuming of the debris cleaner. This portion of the

project has taken up the most time because the form of the vessel has to follow functioning

needs. To find the best design, we had to research the best materials for the vessel. The material

we decide to use is made of a hard plastic that will support the excess weight that will be added

to the boat from the other parts. We also had to do research on the hull and mechanisms required.

All of the mechanisms had to be designed under the constraints of money, area, materials, and

energy. We originally planned to buy a vessel. A Volantexrc V792 4 Atomic Brushless RC

Racing Boat RTR - European Plug Yellow, with dimensions of 26.7 x 8.07 x 4.13 inches, with a

weight of 2.7 lbs. With these dimensions and weight, counterweights will have to be used so the

vessel would not sink when added with the weight of the other components. The robotic arm will

go on the front of the vessel and will collect trash and drop it into the middle between two hulls

were it will be collected. The rear end of the boat will have a sail connected to a servo that will

rotate based off of an analog anemometer reading. This will help the vessel and use less power

when moving from one place to another. The inside of the boat will contain the computer and

micro-controller.

Solution Approach

The solution approach used in this project has been subtle. The project has multiple

variables which make it complicated. Due to this complexity, a subtle approach has helped us

carefully plan out the path that is best when comparing the functionality of different parts

together. This approach helps us save time in making critical errors that may cost us time. We

have decided to break each part function of the device up and test each piece then put all the

functions into two separate systems a navigation, and a retrieval system. The retrieval system is

dependent on the navigation system.

Computation

The computation of this project is based on the number of functions that must be

performed or precisely the number of servos for each function. This computation is the central

part of that will make the project functional. The project in total has about 8 Servos which is all

the microcontroller can control. So to increase the functionality of the project we are increasing

the computational power by using a Raspberry Pi 2 with Arduino Mega 2560. The Raspberry Pi

will control the microcontroller. The Raspberry Pi was our initial choice then we decided just to

use an Arduino Microcontroller because it is good to use with real-world applications and they

allow users to run simulations of the code so we can know precisely how a circuit is to run. Since

we would be using multiple servos, this would max the microcontroller out, so instead, we will

be running the Arduino from the Raspberry Pi and downloading the Arduino ide to run code on

the Raspberry Pi. The functions of the project are coded with an order of precedence. The order

in which things are to happen in real life is essential in knowing what calls to make within the

program.

Programming for Navigation:

Control of Servo and Setting Initial Position:

The following code is being used as a test to ensure that we can control the direction

servo using a potentiometer. This is similar to what we will be using to control the vessel, a knob

that controls the rudder of the vessel. The first step of the code will be using the servo library to

control the steering servo as an object. Then, a variable called pot pin will be used to connect the

potentiometer. The variable val will be used to read the variable from the analog pin. The next

block of codes will be used to set up the servo and attach it to pin 13 of the Arduino board. The

next block of codes is the lop that will read the potentiometer value using an analog read

function. The map function will read the potentiometer value, then return it to the servo by

writing to it. This process will continue and will be linked with another script of code, which will

stop the servo if an object is detected.

Figure 1

The following code in figure 2.1 and figure 2.2 used two libraries. The first library is the

servo library that uses the write-read, and attach functions to the servo. The liquid Crystal library

is the code to be used if we wanted to connect an LCD screen for readout distances. The code

begins by creating an object with the steering servo. After that, the pin for the trigger gives a

signal on the ultrasonic sensor, and the echo pin, which gives a return signal of the object in front

of it and it, determines its distance. Both pins are declared as constant integers because they are

always giving feedback. The pins are set to pins nine and ten on the Arduino board. The next

block of code is the setup which uses the serial function to give a virtual readout and sets up

which pins will be the input and the output. The next line will attach the servo to pin 13 on the

Arduino board. The next block of code is the loop which declares duration and distance in

centimeters as a long and an integer. The servo is digitally written to initialize it at a ninety-

degree angle. The trigger pin then goes from a low voltage to a high and back to a low using a

digital write. This process is repeated. The duration is defined as the pulse of whatever the echo

pin gets from the trigger. Distance in centimeters is also defined as the duration divided by two

divided by 29.1. An if statement then checks the distance of the object and if it is less than 5

centimeters then the servo gets a digital write of ninety degrees, but if it is greater than five the

servo gets a digital write of zero meaning that it will continue to run based off of the delay times

in between each pulse. The rest of the code prints out distances.

Figure 2

Figure 3

Circuits

Figure 4: Potentiometer with Servo

Figure 5: PCB of Potentiometer with Servo

Figure 6: Ultrasonic Sensor with Servo

Figure 7: PCB Ultrasonic Sensor with Servo

Picking mechanism

In robotics, inverse kinematics uses the kinematic equations to calculate the joint angles,

so the end-effector reaches the desired position.

Figure 8: Two configurations of a 2R planar manipulator

Solving for the joint angles:

It is possible to calculate theta2 directly by using the arccose function; however, that function is

inaccurate for small angles. By converting further, it is possible to use the atan2 function.

The original nonlinear equations must be rewritten when solving for theta1 (figure 9).

Figure 9

Insert this into the preceding transformations of x and y.

Apply the atan2 function:

The objective of the inverse kinematics is the calculate angles theta0, theta1, theta2 from the

desired position of the end-effector. To calculate theta0, the x,y,z axes have been changed (refer

to Figure 10 and 11).

Figure 10: Side view of robotic arm

Figure 11: Top view of robotic arm

To recalculate the two angles, the x variable is changed to the distance d of the point (x,y) from

the origin. The height z’ is the height above the shoulder joint.

In the previous theta1 and theta2 formulas, change the x value to distance (d) and y value to z’.

By using past calculations, theta0, theta1, and theta2 can be found given a desired coordinate.

An algorithm was written into Matlab to compute the inverse kinematics. Using the

Arduino toolbox for Matlab, the calculated theta values in Matlab can be written to the servos to

reach the desired position. The Matlab code can be viewed at the end of the report.

Developments

The development of this project includes speed control to the high torque motor, the

motor that we ordered to replace the original motor consumed too much power, programming of

a steering servo, and programming of an Arduino Braccio robotic arm. These developments are

still being tested for the best functionality, and that plans are being carried out unto fruition.

Individual Accomplishments

Ryan Fabre has been assigned to develop the navigation system. He has programmed the

initial control of the servo as well as the servos reaction to objects being detected by the

ultrasonic sensor. These accomplishments were possible through research and advising from my

advisor and my team partner.

Brock Dickinson has been assigned the role of programming the picking mechanism. He

has programmed a robotic arm to achieve the correct position, so the end-effector reaches the

given coordinates to grasp an object.

Progress

The progress of the project has not been moving as fast as it should due to early design

decisions. Since the final decisions have been agreed upon a few weeks ago, we have been able

to speed up progress on project goals. The project is starting to take the form that we have been

seeking. The most critical components have been tested to give results. The code is currently in

the process of being linked to run as one. We are working while following the timeline as far as

any changes that have been made. Weekly meetings with our advisor and meetings between the

team itself have resulted in a better view of how we want the project to deliver. We will continue

to progress as a hard-working team effort to make sure that the deliverables for this project are

delivered.

The creation of the Marine Debris cleaner has gone as planned so far. In the upcoming

months, Ryan Fabre and Brock Dickinson will do all within their power to ensure that the project

gives the best results. We want to have the project entirely done with April as a motivator to

ensure that we finish the assigned project promptly.

Matlab Code