Updated:

Drawing 3D Objects With Use of Robotic Arm Essay

Exclusively available on Available only on IvyPanda® Made by Human No AI

Abstract

Robots are becoming more common in industrial settings because their capabilities outweigh human ones. They are accurate, reliable, and able to handle heavy loads, making them reduce the work expected of individuals within a given work setting. They also increase production in areas that perform repetitive jobs, thus increasing the output of a manufacturing company. Programs are used to make robots behave similarly to the human arm. The current project aims to design and develop a robotic arm that draws 3D objects from data input or sensors. The machine is programmed using MATLAB, Arduino IDE, and the DoBot interfaces with the computer through Arduino Mega Board.

Introduction

Three-dimensional printing involves manufacturing materials using additive technology, which helps build given materials by continuously adding one layer to another to form various parts of the whole. It is directly opposite to the type of manufacturing achieved by removing parts from the whole lump. Three-dimensional printing is categorized into five: extrusion, light polymerization, electron beam freeform fabrication, laminated object manufacturing1,2,3, and powder bed.

Fused deposition modeling or FDM is the most used technique in 3D printing and is the method applied in this project. It involves slicing different parts into layers, which are then translated into machine language for the printer to understand. The hot end of the printer melts the material and embeds it onto the surface onto the intended surface. The melted material solidifies, and more layers are added accordingly to produce the final part.

Robotic arms are connected segmented machines controlled by the computer, motors, and hydraulics. Such robots are primarily used in industrial applications where repetitive work requires heavy labor. Such machines can be integrated with various sensors that measure position and velocity and respond appropriately to feedback based on the input received. Other robotic arms may use cameras as their input mode and convert the signals to computer-understandable language. This project uses simple input sensors that detect shapes, distance, and degrees of freedom. The primary objective of this study is to explore robotics by making a machine that can draw a 3D design.

The current project gives critical information that helps to guide designers on ways of developing 3D printing robots. Most research in the past has focused on robots from the perspective of humanoids to enable them to replace people doing repetitive jobs. More studies have helped improve the approaches to robotic developments, making it more straightforward for subsequent developers to get critical insights that improve robotics for better performance. The areas enhanced by studies include programming and debugging methods, which have made the final machines more advanced and ready for the intended use.

The current project used some critical movement theories to help in achieving a perfect combination of the parts of the robotic arm, such that they achieved a perfect motion needed for the combined parts, such as the hand, elbow, and shoulder, with each part moving in any position direction make a perfectly solid object. The research also utilized the Arduino development board to interface the programs written and the physical parts. Arduino was considered for the project because of its ease of programming, which requires basic knowledge of C and C++. The current project uses the Arduino Mega board to translate the program that runs the board’s microcontroller.

Background of the Project

Robotic arms are inevitable in the present world where industries are using complex machines. The mechanization of factories requires machines that work synchronously to help achieve the highest possible production rate. Apart from the need to interface machines for better output, various tasks require heavy lifting, which limits humans’ possibility, hence requiring robots. Moreover, there are instances in which getting specific measures and calculations of materials may be problematic for workers, which can slow the process of resulting in faults in the final products. A 3D robotic arm is designed to determine the various measures of the object to reproduce and the specific amount of material required to make the object. It can also be fed with data and utilized the information to create something incredibly impossible by human hands within the shortest time possible.

Programs used to run robots can be changed from time to time to meet the company’s specific needs. Consequently, the functions of the arms can be changed to fit the required work or environment. For instance, it is possible to make a 3D robotic arm function as a 2D drawing robot, according to the specific needs of the programmer. For instance, a 2D robot uses only length and width to reproduce an object and draw a new one corresponding to the information fed to its terminals. A 3D arm, therefore, uses an additional orientation and depth to introduce the plane that makes the output a solid object. On the other hand, their speeds can also be adjusted to meet the specifications and production rates of the factory. Using the principles of three-dimensional symmetry, the programmer can create a robot that creates the exact material with a specified thickness in various complex parts of the object. For instance, an object with holes within the solid part can effectively be printed with the exact measurements fed into the computer, thus producing a feature-specific output fitting the industrial application.

The current project uses DoBot to produce an industrial-ready robot. The robot is mainly for training, giving learners a practical understanding of robotic arms, from code to specific designs and debugging. The robot operates using simple instructions from the provided interface, depending on the operator’s needs. Since the object uses layers, one can use it for writing and drawing 2D objects as this involves using printing of a single thin ink layer. The project uses the Arduino Mega board as its main component. It acts as the interface for the visible and invisible parts of the robot and has a special memory that stores instructions that keep the robot delivering its intended goals. The development board uses simple programming languages, including C and C++, making it one of the most straightforward approaches to producing non-industrial robots.

The board has input and output pins that help in connecting the computer and the robotic arm, thus facilitating the communication the user feeds to the computer and the response the arm gives in printing the object intended by the user. Thus, the Arduino Mega board used in these cases helps the user to control the DoBot. The project also utilized a secure digital (SD) card to help store the file robot should draw. The Arduino Mega board then reads the information stored in the card and translates that data into a drawing using the robotic arm. In addition, the project used the TOF sensor shown in Figure 1 below to detect the object and save the 3D version of the object on the SD card. The Arduino then translates the saved object into a sequence that DoBot understands for drawing.

TOF sensor
Figure 1. TOF sensor.

Methods

The project involved several steps, including purchasing the items required, iterative design, choosing the best programming language, designing the DoBot control system, assembling and installing the heated bed, and testing all the system parts. The details of each of these steps are provided in the sections below. However, each part of the process was a little more complex than summarized in the sections.

Decision Regarding Components

The initial step involved comprehensive research regarding crucial components required to make a 3D printing robot. Each part required was determined based on the preliminary design and drawing of the parts. The components and their respective costs were determined, including the feasibility of the development.

Iterative Design

The iterative design approach was used to create and customize the components needed for the project. The idea was brainstormed, and feasibility of the project was discussed, and a perfect design was selected. The design was then created using computer-aided design (CAD) software. The components were adjusted to meet the specifications of the final project. The effectiveness of the parts was tested and adjusted appropriately or remade to match all the other components. The design processes included mounting angle, mounting system, idler system, extruder assembly, and driving mechanism.

The decision of the Programming Language

The process involved familiarizing the robot to understand how it works based on the information it receives and the outputs it produces. The process also involved analyzing the pros and cons of the different programming methods that were researched and how they could impact the cost and feasibility of the project. The simplest programming method, which is C, was then used to program the robot as it was the best technique for using the Arduino Mega board shown in Figure 2 below.

The Arduino Mega Board used in the project
Figure 2. The Arduino Mega Board used in the project.

The Robot System Design

The control method for the 3D printer was determined to be the G-code, created using the slicing algorithm. However, since the robot could not execute the code, the solutions for each component were analyzed to understand a better control system fitting the project. When the prototype was completed, the entire system was reexamined to ensure that each component was suitable for its specific purpose and placement. The G-code was then translated through a series of iterations by adding new codes and testing them before adding more features. The program final program was then compiled and simulated, and saved to the SD card, which was mounted on the SD card shield shown in Figure 3 below.

SD card shield
Figure 3. SD card shield.

The extruder control was brainstormed to ensure easy and quick ways to control the temperature of the hot end. The coordinate frame was configured according to the manufacturer’s documentation, and a quick test was performed to ensure everything worked correctly. Finally, the robot’s control system was implemented using smaller subsystems, which ensured a lean approach to design, implementation, and tests of every component before they were combined to form the complete version of the robotic arm. The project utilized the DoBot magician shown in Figure 4 below as the arm of the robot.

The DoBot used in the project
Figure 4. The DoBot used in the project.

Assembly and Installation of the Headed Bed

The project considered using a heated bed because of the tendency of the material used in the printing curling and the need to achieve error-free printing. The heated bed was also designed through an iteration design. All the parts were effectively fitted, and a custom-made design with the required heat distribution was achieved and embedded in the robot. The final connection was achieved by connecting the systems, as shown in Figure 5 below.

Connections of Arduino to DoBot
Figure 5. Connections of Arduino to DoBot.

The software part of the project is also provided below. First, MATLAB was used to run and simulate the project as it provided the interface through which the 3D object was processed. The following code was used in the MATLAB software to process the object the sensor picked.

regionSize=5; %Region size

INPUT = ‘image1.jpg’; %Load image

in_img = imread(INPUT);

in_img = rgb2gray(in_img);

[sizeX,sizeY] = size(in_img); %Check if image is square

if sizeX~=sizeY

disp(‘Input image is not square.’)

disp(‘Please load a square image.’)

return

end

in_img = imresize(in_img,[280 280]); %Resize image

%Show input image

figure(1);

imshow(in_img);

title(‘Input Image’);

figure(2);

halftone_img=floydHalftone(in_img);

imshow(halftone_img);

title(‘Halftone Image’);

%Initialize path arrays

xPath=[0];

yPath=[0];

for j = 1:2*regionSize:size(in_img,2) %Process image via regions using nearest

neighbor search

for k = 1:regionSize:size(in_img,1) %Odd rows

halftone_region = floydHalftone(in_img(j:j+regionSize-1, k:k+regionSize-1));

%Convert region to halftone

[x,y]=find(halftone_region==0); %Find locations of non-zero elements

xPathRegion=ones(size(x)); %Pre-allocate local region arrays for speed

yPathRegion=ones(size(y));

idxNN=knnsearch([x y],[0 0]); % Use NN to top left corner as region path start

if isempty(idxNN) %Error case for purely white regions

xPathRegion=0;

yPathRegion=0;

else

xPathRegion(1)=x(idxNN);

yPathRegion(1)=y(idxNN);

i=2;

while size(x,1)>2

idxNN=knnsearch([x y],[xPathRegion(i-1) yPathRegion(i-1)]); %Find

index of NN

xPathRegion(i)=x(idxNN); %Add visited location to path

yPathRegion(i)=y(idxNN);

x(idxNN)=[]; %Remove visited location from array of unvisited points

y(idxNN)=[];

i=i+1;

end

end

xPathRegion=xPathRegion+j; %Offset local path for global location in image

yPathRegion=yPathRegion+k;

xPath=[xPath xPathRegion’]; %Append neighborhood path to total path

yPath=[yPath yPathRegion’];

figure(3) %Plot current total path as animation

plot(yPath,-xPath,’k’);

title(‘Pen Path’);

axis([0 size(in_img,2) -size(in_img,1) 0]);

drawnow;

end

j = j+regionSize; %Increment vertical counter

for k = size(in_img,1)-1:-regionSize:1 %Even rows

halftone_region = floydHalftone(in_img(j:j+regionSize-1, k-regionSize+2:k));

[x,y]=find(halftone_region==0);

xPathRegion=ones(size(x));

yPathRegion=ones(size(y));

idxNN=knnsearch([x y],[0 size(in_img,1)]); %Use NN to top right corner as

region path start

if isempty(idxNN)

xPathRegion=0;

yPathRegion=0;

else

xPathRegion(1)=x(idxNN);

yPathRegion(1)=y(idxNN);

i=2;

while size(x,1)>2

idxNN=knnsearch([x y],[xPathRegion(i-1) yPathRegion(i-1)]);

xPathRegion(i)=x(idxNN);

yPathRegion(i)=y(idxNN);

x(idxNN)=[];

y(idxNN)=[];

i=i+1;

end

end

xPathRegion=xPathRegion+j;

yPathRegion=k-yPathRegion;

xPath=[xPath xPathRegion’];

yPath=[yPath yPathRegion’];

figure(3)

plot(yPath,-xPath,’k’);

title(‘Pen Path’);

axis([0 size(in_img,2) -size(in_img,1) 0]);

drawnow;

end

end

figure(3); %Plot total path

plot(yPath,-xPath,’k’);

axis([0 size(in_img,2) -size(in_img,1) 0]);

drawnow;

% Calculate relative displacement between neighboring path points for stepper

motor commands and save to text file

xPath=-xPath;

yPath=yPath;

xPathRel=diff(xPath);

yPathRel=diff(yPath);

textFile=fopen(‘drawing.txt’,’w’); %Create new file called drawing.txt

for i=1:1:size(xPathRel,2) %Write alternativing X,Y waypoints on new lines

fprintf(textFile, ‘%dn’, yPathRel(i));

fprintf(textFile, ‘%dn’, xPathRel(i));

end

fclose(textFile); %Close the text file

The Arduino integrated development environment (IDE) was used to write program that helped the Arduino Mega Board to communicate with the DoBot, as shown below.

#include “stdio.h”

#include “Protocol.h”

#include “command.h”

#include “FlexiTimer2.h”

//Set Serial TX&RX Buffer Size

#define SERIAL_TX_BUFFER_SIZE 64

#define SERIAL_RX_BUFFER_SIZE 256

/#define JOG_STICK

EndEffectorParams gEndEffectorParams;

JOGJointParams gJOGJointParams;

JOGCoordinateParams gJOGCoordinateParams;

JOGCommonParams gJOGCommonParams;

JOGCmd gJOGCmd;

PTPCoordinateParams gPTPCoordinateParams;

PTPCommonParams gPTPCommonParams;

PTPCmd gPTPCmd;

uint64_t gQueuedCmdIndex;

void setup() {

Serial.begin(115200);

Serial1.begin(115200);

printf_begin();

//Set Timer Interrupt

FlexiTimer2::set(100,Serialread);

FlexiTimer2::start();}

void Serialread()

{ while(Serial1.available()) {

uint8_t data = Serial1.read();

if (RingBufferIsFull(&gSerialProtocolHandler.rxRawByteQueue) == false) {

RingBufferEnqueue(&gSerialProtocolHandler.rxRawByteQueue, &data); }}}

int Serial_putc( char c, struct __file * )

{ Serial.write( c );

return c;}

void printf_begin(void)

{ fdevopen( &Serial_putc, 0 );}

void InitRAM(void)

{ //Set JOG Model

gJOGJointParams.velocity[0] = 100;

gJOGJointParams.velocity[1] = 100;

gJOGJointParams.velocity[2] = 100;

gJOGJointParams.velocity[3] = 100;

gJOGJointParams.acceleration[0] = 80;

gJOGJointParams.acceleration[1] = 80;

gJOGJointParams.acceleration[2] = 80;

gJOGJointParams.acceleration[3] = 80;

gJOGCoordinateParams.velocity[0] = 100;

gJOGCoordinateParams.velocity[1] = 100;

gJOGCoordinateParams.velocity[2] = 100;

gJOGCoordinateParams.velocity[3] = 100;

gJOGCoordinateParams.acceleration[0] = 80;

gJOGCoordinateParams.acceleration[1] = 80;

gJOGCoordinateParams.acceleration[2] = 80;

gJOGCoordinateParams.acceleration[3] = 80;

gJOGCommonParams.velocityRatio = 50;

gJOGCommonParams.accelerationRatio = 50;

gJOGCmd.cmd = AP_DOWN;

gJOGCmd.isJoint = JOINT_MODEL;

//Set PTP Model

gPTPCoordinateParams.xyzVelocity = 100;

gPTPCoordinateParams.rVelocity = 100;

gPTPCoordinateParams.xyzAcceleration = 80;

gPTPCoordinateParams.rAcceleration = 80;

gPTPCommonParams.velocityRatio = 50;

gPTPCommonParams.accelerationRatio = 50;

gPTPCmd.ptpMode = MOVL_XYZ;

gPTPCmd.x = 200;

gPTPCmd.y = 0;

gPTPCmd.z = 0;

gPTPCmd.r = 0;

gQueuedCmdIndex = 0;}

void loop()

{ InitRAM();

ProtocolInit();

SetJOGJointParams(&gJOGJointParams, true, &gQueuedCmdIndex);

SetJOGCoordinateParams(&gJOGCoordinateParams, true,

&gQueuedCmdIndex);

SetJOGCommonParams(&gJOGCommonParams, true, &gQueuedCmdIndex);

printf(“rn======Enter demo application======rn”);

SetPTPCmd(&gPTPCmd, true, &gQueuedCmdIndex);

for(; 😉

{ static uint32_t timer = millis();

static uint32_t count = 0;

#ifdef JOG_STICK

if(millis() – timer > 20000)

{ timer = millis();

count++;

switch(count){

case 1:

gJOGCmd.cmd = AP_DOWN;

gJOGCmd.isJoint = JOINT_MODEL;

SetJOGCmd(&gJOGCmd, true, &gQueuedCmdIndex);

break;

case 2:

gJOGCmd.cmd = IDEL;

gJOGCmd.isJoint = JOINT_MODEL;

SetJOGCmd(&gJOGCmd, true, &gQueuedCmdIndex);

break;

case 3:

gJOGCmd.cmd = AN_DOWN;

gJOGCmd.isJoint = JOINT_MODEL;

SetJOGCmd(&gJOGCmd, true, &gQueuedCmdIndex);

break;

case 4:

gJOGCmd.cmd = IDEL;

gJOGCmd.isJoint = JOINT_MODEL;

SetJOGCmd(&gJOGCmd, true, &gQueuedCmdIndex);

break;

default:

count = 0;

break } }

#else

if(millis() – timer > 60000)

{ timer = millis();

count++;

if(count & 0x01)

{ gPTPCmd.x += 100;

SetPTPCmd(&gPTPCmd, true, &gQueuedCmdIndex); }

else

{ gPTPCmd.x -= 100;

SetPTPCmd(&gPTPCmd, true, &gQueuedCmdIndex); } }

#endif

ProtocolProcess();}}

Results and Discussion

The project used Arduino Mega Board to interface the computer and the robotic arm. The program was successfully written and downloaded and was simulated without errors. The development board sent the required signal to the DoBot robot, thus successfully reproducing a 3D model based on the program in the Arduino IDE.

Conclusion

The current project has successfully implemented a 3D printing machine. However, the entire work was marred with various issues around technical specifications and interfacing. This made it challenging to complete the entire goal of the project, which was to produce a machine that could draw a 3D object. However, this problem is mainly associated with limited time, given that more simulations will follow to ensure effective debugging of the system to give better outcomes.

The project’s overall objective has been achieved as the robot could draw some simple objects. The main issue that limited the effectiveness of the project was the sensor, revealing the need for a more powerful one, such as a camera, as it would result in better image object processing.In a Word 2013/2016 document, insert a picture.

Reference

Chaudhry, M. Salman and Aleksander Czekanski, 2021. Tool Path Generation for Free Form Surface Slicing In Additive Manufacturing/Fused Filament Fabrication. In ASME International Mechanical Engineering Congress and Exposition (Vol. 85567, p. V02BT02A021). American Society of Mechanical Engineers.

More related papers Related Essay Examples
Cite This paper
You're welcome to use this sample in your assignment. Be sure to cite it correctly

Reference

IvyPanda. (2023, October 2). Drawing 3D Objects With Use of Robotic Arm. https://ivypanda.com/essays/drawing-3d-objects-with-use-of-robotic-arm/

Work Cited

"Drawing 3D Objects With Use of Robotic Arm." IvyPanda, 2 Oct. 2023, ivypanda.com/essays/drawing-3d-objects-with-use-of-robotic-arm/.

References

IvyPanda. (2023) 'Drawing 3D Objects With Use of Robotic Arm'. 2 October.

References

IvyPanda. 2023. "Drawing 3D Objects With Use of Robotic Arm." October 2, 2023. https://ivypanda.com/essays/drawing-3d-objects-with-use-of-robotic-arm/.

1. IvyPanda. "Drawing 3D Objects With Use of Robotic Arm." October 2, 2023. https://ivypanda.com/essays/drawing-3d-objects-with-use-of-robotic-arm/.


Bibliography


IvyPanda. "Drawing 3D Objects With Use of Robotic Arm." October 2, 2023. https://ivypanda.com/essays/drawing-3d-objects-with-use-of-robotic-arm/.

If, for any reason, you believe that this content should not be published on our website, please request its removal.
Updated:
This academic paper example has been carefully picked, checked and refined by our editorial team.
No AI was involved: only quilified experts contributed.
You are free to use it for the following purposes:
  • To find inspiration for your paper and overcome writer’s block
  • As a source of information (ensure proper referencing)
  • As a template for you assignment
1 / 1