DIY DRAWING ROBOT USING ARDUINO

DIYDRAWINGROBOTUSING ARDUINOUNO

By

KritiGoel(2040345)

SairajNatraj(2040366)

ChiragN(2040379)

Undertheguidanceof Prof.JohnsonO.V.

DepartmentofPhysicsandElectronics

Aprojectreportsubmittedinpartialfulfillmentfortheawardofdegreeof B.Sc.(Electronics)ofCHRIST(DeemedtobeUniversity),Bengaluru.

www.christuniversity.in

May2023

Certificate

This is to certify that, the project titled “DIY drawing robot using arduino ” is a bonafide record of the work done by “Chirag N” in partial fulfillment of the requirements for the award of the Degree of Bachelor of Science (Electronics) of CHRIST (Deemed to be University), Bengaluru during the year 2022 - 23.

Head(Electronics)

(Prof.BennySebastian)

ExaminationDate:24thApril,2023

ProjectGuide

(Prof. JohnsonO.V.)

NameoftheStudent:ChiragN

ExaminationCentre:ChristUniversity Class:VISemesterPME

RegisterNo.:2040379

ACKNOWLEDGEMENT

We would like to express our sincere gratitude to all those who contributed to the completionofthisproject.Firstandforemost,wewouldliketoexpressourdeepest gratitude to Dr Fr Joseph C C (Vice Chancellor), Dr. George G Thomas (Dean) and Dr. Manoj B (Head of Department) , CHRIST (Deemed to be University), for providing us with necessary resources and facilities that were instrumental in carryingoutthisproject.

We would like to thankourprojectsupervisorProf.JohnsonO.V.andMissRaksha S, for their valuable guidance, support, and insights throughout the project. Without their expertise and encouragement, this project would not have been possible.

We are also grateful to our team members Kriti, Sairaj and Chirag, who worked tirelessly to meet the project's objectives and deadlines. Each of them brought unique skills and perspectives to the table, and their collaboration was crucial to theproject'ssuccess.

Additionally, we extend our thanks to the participants who took part in our study and generously shared their time and insights with us. Their contributions were essentialtotheproject'sfindings.

Finally, we would like to thank our families and friends for their unwavering support and encouragement throughout this project. Theirloveandencouragement helpedusstaymotivatedduringthechallengingtimes.

Thankyouallforyourcontributionsandsupportinmakingthisprojectareality.

ABSTRACT

This is the report of DIY drawing robot using Arduino Uno. This project involves the design and construction of a drawing robot that can create artworks autonomously using an Arduino microcontroller. The robot consists of a simple mechanical structure with two motors that controlitsmovement,aswellasaservo motor that controls the pen's position.Therobot'smovementsarecontrolledbythe Arduino, which receives instructions from a computer program created using Processing software. The program translates digital images into a series of commands that the Arduino can execute, allowing the robot to create intricate drawings with precision and accuracy. This project combines elements of programming, electronics, and mechanics to create an engaging and interactive projectthatdemonstratesthecapabilitiesofDIYrobotics.

CHAPTER1:INTRODUCTION

A DIYdrawingrobotusingArduinoUnoisaroboticsystemthatisdesignedtodrawpre-defined designs on paper or other surfaces. The robot is controlled by an Arduino Uno microcontroller board, which sends signals to a set of motors that control the movement of the robot's arm and drawingmechanism.

The system is typically composed of several components, including a chassis, motors, gears, a pen holder, and an Arduino Uno board. The chassis serves as the base of the robot, while the motors and gears enable the arm to move in aprecisemanner.Thepenholderholdsthedrawing tool (pen, marker, or brush), and the Arduino Uno board provides the instructions and control signalsthatmovethearmandthedrawingmechanism.

The project is suitable for individuals who are interested in robotics, electronics, and programming, asitinvolvesbuildingarobotfromscratch,programmingtheArduinoUnoboard, and designing a drawing mechanism that can accurately follow a given design. The project provides a fun and challenging platform for learning the basicsofelectronicsandprogramming, aswellasexploringthemechanicsofaroboticarm.

The same principle can be usedinseveralapplications.Forexample,a3Dprinter(whileitisnot strictly a 2D plotter, it can be used tocreate2Dshapesandpatternsinadditiontomorecomplex 3D objects) , laser cutting (it can be used to create intricate 2D designs, and is often used in manufacturing, prototyping, and signage), and a CNC router (it can be used to intricate 2D designs, and is often used in manufacturing, prototyping and signage). These are just a few examples of the many alternatives to a 2D plotter. Thechoiceofthebestalternativewilldepend onthespecificneedsandrequirementsoftheuser.

Overall, the DIY drawing robot using Arduino Uno is an exciting and educational project that combines the fields of robotics, electronics, and programming. It provides an excellent opportunityforindividualstolearnandexperimentwithnewtechnologieswhiledevelopingtheir creativityandproblem-solvingskills.

The DIY drawing robot using Arduino Uno is a project that involves building a robotic system capableofdrawingpre-defineddesignsonpaperorothersurfaces.

The system is composed of various components, including a chassis, motors, gears, a pen holder,andanArduinoUnomicrocontrollerboard.

The project typically involves several steps, including designing and building the chassis, mounting the motors and gears, attaching the pen holder, and programming the Arduino Uno board. The chassis serves as the base of the robot, while the motors and gearsenablethearmto move in a precisemanner Thepenholderholdsthedrawingtool,whichcanbeapen,marker,or brush, and the Arduino Uno board provides the instructions and control signals that move the armandthedrawingmechanism.

To program the Arduino Uno board, individuals can use various coding platforms, such as Arduino IDE orScratch.Theprogramminginvolveswritingcodetocontrolthemovementofthe robotic arm and the drawing mechanism, which can include specifying thedirection,speed,and duration of movement. The system is typically powered by a battery or a power supply, dependingonthespecificdesignandrequirements.

The DIY drawing robot using Arduino Uno project provides a fun and challenging platformfor individuals to learn and experiment with robotics, electronics, and programming. It allows individuals to develop their creativity and problem-solving skills, as well as theirunderstanding ofhowroboticsystemswork.

In summary, the DIY drawing robot using Arduino Uno is a fascinating and educationalproject that combines several fields of technology, providingindividualswithanexcitingopportunityto learnandexplorenewconceptswhilebuildingafunctionalroboticsystem.

CHAPTER2:DETAILSOFCIRCUIT

2.1CIRCUITDIAGRAM

In this circuit diagram, the input device sends instructions or commands to the Arduino microcontroller. The microcontroller processes the input and sends output signals to the motor driver,whichcontrolsthemovementsofthestepperandservomotors.

The stepper motors are used to move the drawing surface in a precise and controlled manner, while the servo motor is used to adjust the position of the penholdertocreatethedesiredshape or line. The pen holder holds the pen or other drawing tool and moves it across the drawing surfacetocreatethedrawing.

The motor driver receives signals from the microcontroller and provides the appropriate power and control signals to the motors. The pen holder and drawing surface can be connected to the stepperandservomotorsthroughbelts,gears,orothermechanicalmechanisms.

Fig1:CircuitDiagram

2.2COMPONENTS

The circuit ofaDIYdrawingrobotusingArduinoUnoinvolvesconnectingvariouscomponents, such as stepper motors, sensors, and power supply, to the Arduino Uno board. Here are some detailsofthecircuitcomponentsandtheirconnections:

1. ARDUINOUNOBOARD

Arduino Uno is a microcontroller board based ontheATmega328Pmicrocontrollerchip. The Arduino Uno board is the main controlleroftheroboticsystem,anditisresponsible for sending signals to the various components. The board has several input and output pins, including analog and digital pins, which are used to connect to the other components. The board is powered by a voltage source, such as a USBcableorapower supply, and it communicates with a computer or other devices using a serial communicationprotocol.

TechnicalSpecifications:

1. Microcontroller:ATmega328P

2. OperatingVoltage:5V

3. InputVoltage(recommended):7-12V

4. InputVoltage(limits):6-20V

5. DigitalI/OPins:14(ofwhich6providePWMoutput)

Fig2:Components

6. PWMDigitalI/OPins:6

7. AnalogInputPins:6

8. DCCurrentperI/OPin:20mA

9. DCCurrentfor3.3VPin:50mA

10.FlashMemory:32KB(ATmega328P)ofwhich0.5KBusedbybootloader

11. SRAM:2KB(ATmega328P)

12.EEPROM:1KB(ATmega328P)

13.ClockSpeed:16MHz

2. ARDUINOSENSORSHIELD

An Arduino sensor shield is a board that isdesignedtobemountedontopofanArduino microcontroller board to provide additional sensor capabilities. The shield typically contains a variety of sensors such as temperature, humidity, light, sound, motion, and many others, as well as additional circuitry to interface the sensors with the Arduino board.

The shield allows the Arduino to read data from the sensors and use that data to control other devices or perform various actions. Arduino sensor shields are available in a wide variety of configurations, with different sensors and features depending on the specific needsoftheproject.

3. MOTORS(Stepper28BYJ-48andServo)

The robot requires at least two stepper motors and one servo motor to control the movement of the pen. These motors will need to be connected to motor drivers that can convert the signals from the Arduino into appropriatepoweranddirectionsignalsforthe motors.

Stepper motors are used to move the robot's arms and pen to draw on a surface. The 28BYJ-48 is a small 5V stepper motor commonly used in hobbyist and DIY electronics projects. It is a 4-phase, 8-step motor that is capable of very precise control using an appropriatecontroller.Herearesomekeyspecifications:

Voltage:5VDC

Current:250mA

Resistance:20ohmsperwinding

Stepangle:5.625degrees/64stepsperrevolution

Holdingtorque:34.3mN.m(approx.48oz.in)

The motor can be controlled using a variety of stepper motor driver boards, such as the popular ULN2003 driver board, which provides four Darlington transistor pairs to drive the motor coils. The motor can be wired in various configurations depending on the driverboardusedandthedesireddirectionandspeedofrotation.

Featuresofmotordriver:

1. Minimum-Maximumoperatingvoltage:8-35V

2. Continuouscurrentperphase:1Amp

3. Maximumcurrentperphase:2Amp

4. Minimum-Maximumlogicvoltage:3-5.5V

5. Microstepresolutions:Full,1/2,1/4,1/8,and1/16

6. Reversevoltageprotection?No

The 28BYJ-48 is often used in small robotics projects, such as for controlling the movementofsmallrobotarmsorforprecisecontrolofsmallCNCmachines.

Fig3:MotorDriverof2BYJ-48

Servo motors are used to move the pen up and down to allow for different drawing heights. A servo motor is a type of rotary actuatorthatiscommonlyusedinroboticsand other applications where precise control of position and velocity is required. Itworksby rotatinganoutputshafttoaspecificanglebasedonacontrolsignal.

Sometechnicalspecificationsofatypicalservomotorinclude:

Torque: This is the rotational force that the servo motor can produce. It is usually measuredinunitssuchasNewton-meters(Nm)orounce-inches(oz-in).

Speed:Thisisthemaximumrotationalspeedoftheservomotor.Itisusuallymeasuredin unitssuchasrevolutionsperminute(RPM)ordegreespersecond(°/s).

Operating Voltage: This is the voltage range over which the servomotorcanoperate.It isusuallymeasuredinvolts(V).

Control Signal: This is the type of signal used to control the servo motor The most common type is a pulse-widthmodulation(PWM)signal,whichisusedtosetthedesired positionoftheoutputshaft.

It's important to choose a servo motor with specifications that matchtherequirementsof your project. Some other factors to consider include the durability and reliability of the motor,aswellastheavailabilityofcompatiblecontrolsystemsandaccessories.

4. MICROSDCARD

A micro SD card can be usedinaDIYdrawingrobotusingArduinotostoreandretrieve drawings or other data related to the robot. Here are some ways a micro SD card canbe usedinthistypeofproject:

1. Storing drawing instructions: One way to use amicroSDcardistostoredrawing instructions or commands that are sent to the Arduino microcontroller. This allows for more complex drawings to be created without overloading the microcontroller's memory. The microcontroller can read the drawing instructions fromtheSDcardandexecutethemtocreatethedrawing.

2. Saving and retrieving drawings: Another use for the micro SD card is to store completed drawings, so they can be retrieved and displayed later. This can be usefulforcreatingaportfolioofdrawingsorsharingdrawingswithothers.

3. Calibration data: The micro SD card can also be usedtostorecalibrationdatafor the robot's motors and sensors. This data can be used to ensure accurate movementsandprecisedrawingplacement.

To use a micro SD card in a DIY drawing robot using Arduino, an SD card module can be connected to the Arduino board. The module provides asimplewaytoreadandwrite data to the SD card. The Arduino code can be programmed to read and write datatothe SD card using the appropriate libraries and functions. With the SD card module and appropriate programming, the DIY drawing robot can store and retrieve drawings, instructions,andcalibrationdatafromthemicroSDcard.

5. PENHOLDER,BELTSANDPULLEYS

A pen holder is used toholdthepenormarkerthatisusedfordrawing.Beltsandpulleys areusedtotransmitthemotionofthesteppermotorstotherobot'sarmsandpen.

6. POWERSUPPLY

An additional 9V power supply is required to power the motors and other electronic componentsoftherobot.

CHAPTER3:WORKINGANDOPERATINGPROCEDURE

3.1BLOCKDIAGRAM

The block diagram shows the main components of the DIY drawing robot and how they are connected. The input device can be a computer, mobile device, or other device that sends commands or instructions to the Arduino microcontroller. The microcontroller processes the input and sends output signals to the motor drivers, which control themovementsofthestepper andservomotors.

The stepper motors are used to move the drawing surface in a precise and controlled manner, while the servo motor is used to adjust the position of the penholdertocreatethedesiredshape or line. The pen holder holds the pen or other drawing tool and moves it across the drawing surfacetocreatethedrawing.

Overall, the block diagram shows how the various components of the DIY drawing robot are interconnectedandworktogethertocreateafunctionaldrawingmachine.

3.2WORKING

The working of a DIY drawing robot using Arduino involves controlling the movements of the stepper and servo motors to move the pen in a precise and coordinated manner to create a drawing. The Arduino microcontroller acts as the brain of the circuit, receiving input from sensorsorotherdevicesandsendingoutputsignalstothemotorstocontroltheirmovements. The circuit consists of several components, including the Arduino microcontroller, stepper motors, servo motor, motor drivers, power supply, and sensors such as limit switches or encoders. The stepper motors are used to move the drawing platform in a linear fashion, while theservomotorisusedtocontrolthepositionofthepen.

The Arduino microcontroller is programmed to receive input from a computer or other device, such as a mobile phone, via a wireless or wired connection. Theinputmayconsistofaseriesof instructions or commands that specify the desired drawing, such as the shape, size,andposition ofthelinesorcurves.

Based on the input, the microcontroller sends output signals to the motor drivers, which in turn control the stepper and servo motors. The stepper motors are driven in a precise and controlled manner to move the drawing platform in the desired direction and distance, while the servo motorisusedtoadjustthepositionofthepentocreatethedesiredshapeorline.

The sensors are used to provide feedback to the microcontroller, allowing it to adjust the movements of the motors as needed to maintain accuracy and precision. For example, limit switches can be used to detect theendofalinearmotion,whileencoderscanbeusedtomeasure thepositionandvelocityofthemotors.

Overall, the principle of the circuit of a DIY drawing robot using Arduino involves using the microcontroller and motor drivers to control themovementsofthestepperandservomotorsina coordinatedandprecisemannertocreateadesireddrawing.

3.3OPERATION:

1. Hardware Setup: The first step is to assemble the drawing robot by connecting the Arduino Uno board to the Arduino Shield, and connecting the MicroSD Card Adapter and 28BYJ Stepper Motor to the Arduino Shield. The wiring diagram for this setup shouldbefollowedcarefullytoensurethatallcomponentsareconnectedcorrectly

2. Programming: The next step is to program the Arduino Uno board using the Arduino software. The program should read the drawinginstructionsfromatextfilestoredonthe MicroSDCardAdapterandcontrolthe28BYJStepperMotorbasedontheseinstructions. Theprogramshouldusethesteppermotorlibrarytocontrolthemotor.

3. Drawing Instructions: Create a text file containing the drawing instructions for therobot to follow. Each line in the text file should represent a single instruction for the robot to execute,suchas"move10stepsforward"or"turn90degreestotheleft".

4. Operating the Robot: To operate the drawing robot, insert the MicroSD Card Adapter with the text file containing the drawinginstructionsintotheMicroSDCardAdapterslot on the robot. Power on the robot and the Arduino Uno board will read the drawing instructions from the text file on the MicroSD Card Adapter. The instructions will be interpreted by the program and the 28BYJ Stepper Motor will be controlled based on theseinstructionstocreatethedesireddrawing.

5. Calibration: Before starting the drawing, it is important to calibrate the robot to ensure that it is accurately translating the drawing instructions to movements of the 28BYJ Stepper Motor This can be done by running a test drawing and comparing it to the intended design. Adjustments can be made to the drawing instructions or motor movementsasnecessarytoachievethedesiredresult.

6. Drawing: Once the robot is calibrated and the desired drawing instructions are loaded onto the MicroSD Card Adapter, the robot is ready to begin creating the drawing. The 28BYJ Stepper Motor will move a pen or other drawing implement across a sheet of paper,followingtheinstructionsfromthetextfiletocreatethedesireddesign.

7. Power Supply: The drawing robot will require a power source to run. This can be achieved usingaUSBcableconnectedtoacomputerorabatterypack.Thepowersupply

should be able to provide enough power to drive the 28BYJ Stepper Motor and other components.

8. Drawing Surface: The drawing robot will require a flat and stable surface to draw on.A piece of paper or a whiteboard can be used as the drawing surface. It is important to ensure that the drawing surface is securely fastened to the tableorworkbenchtoprevent movementduringthedrawingprocess.

9. Pen or Drawing Implement: The drawing robot will require a pen or other drawing implement to create the drawing. The pen can be attached to the 28BYJ Stepper Motor using a suitable mechanism. It isimportanttochooseapenorimplementthatislightand easytomove,tominimizetheloadonthemotor.

10.Debugging: If the robot does not function correctly, it may be necessary to debug the program or the hardware setup. The Arduino software includes a serial monitor that can be used to output debug informationfromtheprogram.Thiscanbehelpfulinidentifying issueswiththeprogramlogicorthecommunicationbetweenthecomponents.

11. Maintenance: Regular maintenance may be required to keep the drawing robot running smoothly. This may involve cleaningandlubricatingthe28BYJStepperMotor,checking thewiringforlooseconnections,andreplacinganyworncomponentsasnecessary.

12.Controlling Speed and Direction: The speed and direction of the 28BYJ Stepper Motor can be controlled by adjusting the delay between each step in the program. Bychanging the delay, it is possible to make the motor move faster or slower, and to change the directionofmovement.

13.Modifying Drawing Instructions: The drawing instructions in the text file can be modified to create different designs or patterns. For example,bychangingthenumberof steps taken by the motor, it is possible to change the size and shape of the drawing. By adding or modifying instructions, it is possible to create more complex designs and patterns.

14.Using Multiple Motors: It is possible to use multiple 28BYJ Stepper Motors to create more complex drawings or to allow for simultaneous drawing on multiplesurfaces.This can be achieved by connecting multiple motors to the Arduino Shield and controlling themusingtheprogram.

15.Using Sensors: Sensors such as light sensors or proximity sensors can be added to the robot to allow it torespondtoitsenvironment.Forexample,alightsensorcanbeusedto detecttheedgesofthedrawingsurfaceandadjustthedrawinginstructionsaccordingly.

16.Adding User Input: It ispossibletoadduserinputtothedrawingrobot,allowingusersto interact with the robot and create custom designs. This can be achieved by adding input components such as buttons or touch screens to the robot and modifying the program to respondtouserinput.

17.Scaling and Rotating Drawings: By modifying theprogramandthedrawinginstructions, it is possible to scale and rotate the drawings produced by the robot. This can be useful for creating larger or smaller versions of the same design, or for producing mirrored or rotated versions Using a CNC Machine:ACNC(ComputerNumericalControl)machine is a type of roboticmachinethatcanbeusedforprecisioncutting,engraving,andmilling tasks. By using a CNC machine instead of a drawing robot, it is possible to create more complexanddetaileddesigns,aswellas3Dobjects.

18.Adding a Servo Motor: In addition to the 28BYJ Stepper Motor, a servo motor can be added tothedrawingrobottocontroladditionalfunctionssuchasliftingandloweringthe pen. By using a servo motor, it is possible to create more precise and controlled movementsofthepen,whichcanbeusefulforcreatingmoredetaileddrawings.

19.Using a Different Drawing Tool: While the drawing robot is typically designed to use a pen as its drawing tool, it is possible to use other drawing tools such as markers or paintbrushes. By modifying the robottoaccommodatedifferenttypesofdrawingtools,it ispossibletocreateawiderrangeofdesignsandpatterns.

20.Using Different Drawing Surfaces: The drawing robot is typically designedtodrawona flat surface such as paper or a whiteboard. However, it is possibletomodifytherobotto draw on other surfaces such as walls or 3D objects. This can be achieved by adding additionalmotorstocontrolthemovementoftherobotinmultipledimensions.

21.Creating Custom Programs: Whiletheexampleprogramprovidedinthepreviousstepsis a good starting point for operating a drawing robot,itmaynotbesuitableforalltypesof drawings or designs. By creating custom programs using the Arduino software, it is possibletotailortherobot'smovementsandinstructionstospecificdesignrequirements.

22.Using Machine Learning: By using machine learning algorithms and techniques, it is possible totrainthedrawingrobottocreatespecifictypesofdesignsortolearnfrompast drawings. Thiscanbeusefulforcreatingmorecomplexandnuanceddrawings,aswellas forautomatingthedesignprocess.

23.PowerSupply:Itisimportanttouseasuitablepowersupplytooperatethedrawingrobot. The Arduino board and motor require a certain amount of voltage andcurrenttooperate effectively. Depending on the number of motors and other components used, a power supplywithsufficientwattagemayberequired.

24.Calibration: The drawing robot may require calibration to ensure that it is drawing accuratelyandconsistently.Thisinvolvesadjustingthemotorstepsandspeeds,aswellas the pen position and lifting mechanism. Calibration may need to be done periodically to ensureoptimalperformance.

25.Safety Considerations: When operating a drawing robot, it is important to take safety precautions to prevent injury ordamagetotheequipment.Thisincludesensuringthatthe robot is securely mounted and that the drawing surface is stable, using appropriate electricalsafetymeasures,andavoidinganymovingpartswhiletherobotisinoperation.

26.Maintenance: Likeanymachine,thedrawingrobotmayrequiremaintenanceovertimeto ensure optimal performance. This may include cleaning and lubricating the motors and other components, replacing worn or damaged parts, and checking for any loose connectionsorotherissues.

27.Design Considerations: When creating designs for the drawing robot, it is important to consider factors such as the size and shape of the drawing surface, the type of drawing tool used, and the complexity of the design. By taking these factors into account, it is possibletocreatedesignsthatareoptimizedfortherobot'scapabilitiesandlimitations.

Fig4:Actualworkingmodelofproject

CHAPTER4:SOFTWARETOOLSANDPROGRAMMING

4.1SOFTWARE

1. LaserGRBL

This software is usedtoconvertimagesintovectordrawingsandgeneratinggcodewhich wouldfurtherbeuploadedtotheCNJCs.

Vector drawing is a type of digital artwork that uses mathematical equations and geometric shapes to create smooth, scalable graphics. Vector graphics are different from raster graphics, which are made up of pixels and can become pixelated or blurry when scaledupordown.

G-code, short for "geometric code," is a programming language used to control CNC (Computer Numerical Control) machines such as 3D printers, CNC routers, and laser cutters. G-code consists of a series of commands that instruct the machine on how to move the cutting tool or laser head, how fasttomove,andhowdeeptocut.Gcodefileis saved in the memory card, Arduino reads the file from the card, and the position coordinates are resolved into the action ofthesteppermotor,pullingtheropetodrivethe pentodraw.(WallDraw.inoprograminthepackagecanperformthisstep).

LaserGRBL is a free, open-source software used to control laser engraving and cutting machines. It is designed to work with a wide range of laser engravers and cutters, andit can generate G-code from vector drawing files such as SVG and DXF. LaserGRBL allows users to adjust laser power, speed, and other settings to achieve precise and consistentresults.

2. XLoader

This software is used to swipe combined bin file into arduino. Open the WallDrawGCode.ino.standard.hex file we provided to you in XLoad, select Uno for Device, COM foryourport,and115200forBaudrate(pleaseinstalltheCh340driverfor unrecognized devices). Finally, click the Upload button, the status bar will show uploadingprompt,closeitaftersuccess.

XLoader is a free software program used to upload firmware or program files to an Arduino board. It is commonly used to load "hex" or "bin" files onto the board. The software has a simple graphical interface and is compatible with a variety of Arduino boards,includingthepopularArduinoUnoandArduinoMega.

To use XLoader, you need to select the appropriate serial port and baud rate for your Arduino board, select the program file you want to upload, and then click the "Upload" button. The program will then be transferred to the Arduino board and canberunonthe board.

Note that XLoader is not typically used to program the Arduino with the Arduino IDE, which is the recommended software for developing and uploading sketches to the Arduino board. Instead, XLoader is useful for updating the firmware on the boardorfor uploadingspecializedprogramsthatmaynotbecompatiblewiththeArduinoIDE.

3. CNCjs

Thissoftwareisusedtouploadgcodeandrunitinarduinotomakepre-defineddrawings. After uploading the program to Arduino, install the CNCjs application on the computer side, select Grbl, the port number will be displayed automatically after searching, select 115200 for baudrate,openitandestablishtheconnection.Afteranormalconnection,the consolewillshowthefollowingcontent.AndthereisanOKprompt.

WecantestitbytypingasimpleGCodeaftertheprompt.

G01x0y0z0//Droppen

G01Z1//Liftpen

IfthetestisOK,wecanopentheGCodefileandstartourdrawing.

CNCjs is a web-based software used to control CNC (Computer Numerical Control) machines such as 3D printers, CNC routers, and laser cutters. CNCjs provides a user-friendly interface for sending G-code commands to the CNC machine, visualizing thetoolpath,andmonitoringthemachine'sstatusinreal-time.

CNCjs canberunonavarietyofplatforms,includingWindows,Linux,andMacOS,and it supports a widerangeofCNCcontrollersandmachines.Thesoftwarealsohasfeatures likejobqueuing,machinemonitoring,andsupportforcustommacrosandplugins.

CNCjs can be used with a variety of hardware platforms, including Raspberry Pi, BeagleBone Black, and other single-board computers. By running CNCjs on a single-boardcomputer,youcancreateastandaloneCNCcontrollerthatcancommunicate withtheCNCmachineoverUSBorserialconnections.

Overall, CNCjs is a versatile and powerful software that can streamline CNC machine operationandenhancetheuserexperienceforbothhobbyistsandprofessionalsalike.

4.2DETAILSOFIDE

The Arduino IDE (Integrated Development Environment) is a software tool used for programming and uploading code to Arduinoboards.Itisanopen-sourceplatform,availablefor freeonvariousoperatingsystemslikeWindows,macOS,andLinux.

To create a DIY drawing robot using Arduino, you would first need to gather the necessary hardware components such as an Arduino board (e.g., Arduino UNO), servo motors, a drawing tool(e.g.,pen),andafewothermaterialslikepaper,tape,andscrews.

Once the robot is assembled, we can use theArduinoIDEtowriteanduploadcodethatcontrols therobot'smovementsanddrawingoperations.Herearethebasicsteps:

1. ConnectyourArduinoboardtoyourcomputerusingaUSBcable.

2. OpentheArduinoIDEandcreateanewsketch(File>New).

3. Write the code (2Stepper.ino) that controls the movements of the robot's servo motors, suchasmovingthepenupanddown,andleftandright.

4. Write the code(Walldrawdemo.ino) that controlsthedrawingoperations,suchasdrawing linesorshapes.

5. UploadthecodetotheArduinoboardbyclickingonthe"Upload"buttonintheIDE.

6. Once the code is uploaded, disconnect the USBcablefromtheboardandpoweritwitha batteryorexternalpowersource.

Hence, by following these steps, by using Arduino IDE we create the working model of DIY DrawingRobot.

5.3PROGRAMCODE

1. 2Stepper.ino

The function of this project is to make the stepper motor work and make a pendulum graph.

#include <AccelStepperh>

#include <MultiStepper.h>

//Wall painting machine without servo test program This program only test 2 stepper motors, draw curve pattern, modify the parameters can change the pattern size and style.

#include <AccelStepperh>

//This lib library file is in the package, you need to copy it to the \libraries folder of arduiino first.

//Method 1: Copy it to My Documents\Arduino\libraries

// Method 2: In the menu of arduino IDE, select Project->Load Libraries->Manage Libraries and search for AccelStepper to install it automatically

#define FULLSTEP 4

#define HALFSTEP 8

//Wiring method

//wiring method of motor1

#define motorPin1 2 // 28BYJ48 pin 1 connect to arduino's 2# port

#define motorPin2 3 // 28BYJ48 pin 2 connects to 3#

#define motorPin3 5 // 28BYJ48 pin 3 connects to 5#! Note that port 4# is reserved for sd card reader

#define motorPin4 6 // 28BYJ48 pin 4 to 6#!

// Motor 2 connection

#define motorPin5 7 // 28BYJ48 pin 1 to 7#

#define motorPin6 8 // 28BYJ48 pin 2 to 8#

#define motorPin7 9 // 28BYJ48 pin 3 to 9#

#define motorPin8 10 // 28BYJ48 pin 4 connect 10#

#define stp1 279 //

#define stp2 673 // Modify this parameter, you can change the size and style of the pattern, the larger the value the larger the pattern, the larger the gap the more complex The pattern is closed after reaching the least common multiple of 2 numbers

AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4); AccelStepper stepper2(HALFSTEP, motorPin5, motorPin7, motorPin6, motorPin8);

void setup() { Serial begin(9600);

stepper1 setMaxSpeed(800 0); //maximum speed, too high torque becomes small, more than 256 easy to lose steps

stepper1.setAcceleration(200.0); //acceleration, try to stabilize the program can be adjusted.

stepper1 setSpeed(50); //speed

// depending on FULLSTEP or HALFSTEP, 1024 or 512 stepper motors turn one week

//set the number of rotation steps of motor1 Adjustable (the larger the number, the larger the graphic size) stepper1.moveTo(stp1);

stepper2 setMaxSpeed(800 0); stepper2.setAcceleration(200.0); stepper2 setSpeed(50);

//same as stepper1 stepper2.moveTo(stp2);

void loop() {

if(stepper1 distanceToGo() == 0)

stepper1 moveTo(-stepper1 currentPosition());

if(stepper2.distanceToGo() == 0)

stepper2 moveTo(-stepper2 currentPosition());

stepper1.run();

stepper2 run();

// This program loops infinitely and never ends

2. WallDrawDemo.ino

Thisisthemainprogramwhichwilldrawafewprogramsfortesting.

#include <TinyStepper 28BYJ 48 h>

#include <Servo.h>

//debug code flags, remove comments, can output debug information (the program will run slowly)

//#define VERBOSE (1)

//debug flag

#define STEPS PER TURN (2048) // stepper motor one week step length 2048 steps turn 360 degrees

#define SPOOL DIAMETER (35) //spool diameter in mm

#define SPOOL CIRC (SPOOL DIAMETER * 3 1416) //Spool circumference 35*3 14=109 956

#define TPS (SPOOL CIRC / STEPS PER TURN) //Stepper motor step distance, minimum resolution

Distance per step the bobbin is pulled 0.053689mm

#define step delay 1 // waiting time for each step of the stepper motor (subtle)

#define TPD 300 //Turn waiting time (milliseconds), due to inertia the pen will continue to move, tentatively wait for the pen to come to a standstill before moving 26

//rotation direction of the two motors 1 forward - 1 reverse //adjust the in/out direction can be reversed vertically image

#define M1 REEL OUT 1 //Release line

#define M1 REEL IN -1 //Reel in line

#define M2 REEL OUT -1 //Release line

#define M2 REEL IN 1 //involved line

static long laststep1, laststep2;

//when the length of the front line records the pen position

#define X SEPARATION 150 //The horizontal distance above the two ropes (mm

#define LIMXMAX ( X SEPARATION*0 5) //x-axis maximum value 0 bit in the center of the drawing board

#define LIMXMIN (-X SEPARATION*0 5) //x-axis minimum

/* Vertical distance parameters: positive values under the drawing board, theoretically as long as the drawing board is large enough can be infinite, negative value area in the pen (before opening) above */

#define LIMYMAX (-100) //y-axis maximum value at the bottom of the drawing board

#define LIMYMIN (100) //y-axis minimum value uppermost of the drawing board The vertical distance from the fixed point of the left and right lines to the pen, try to measure the placement accurately, the error is too large to have distortion

//value shrink the drawing becomes long and thin, the value increases the drawing becomes short and fat

// lift the pen servo angle parameters specific value depends on the placement of the swing arm, need to adjust

#define PEN UP ANGLE 65 //the lift pen

#define PEN DOWN ANGLE 80 // Drop the pen //The above is the parameter to be adjusted

#define PEN DOWN 1 //Pen status Down pen

#define PEN UP 0 //Pen state Raise pen

struct point { float x; float y; float z; };

struct point actuatorPos; // plotter position pen position

static float posx;

static float posy;

static float posz; // pen state

static float feed rate = 0;

// pen state Pen state (pen lift, pen drop).

static int ps;

/* The following are G-code communication parameters */

#define BAUD (115200) // serial port rate, used to transfer G-code or debugging optional 9600, 57600, 115200 or other common rates

#define MAX BUF (64) //Serial buffer size

Servo pen;

TinyStepper 28BYJ 48 m1; //(7,8,9,10); //M1 L stepper motor in1~4 ports corresponding to UNO 7 8 9 10

TinyStepper 28BYJ 48 m2; //(2,3,5,6); //M2 R stepper motor in1~4 ports corresponds to UNO 2 3 5 6

// Forward motion calculation - convert L1, L2 length to XY coordinates

// Use the law of cosines, theta = acos((a*a+b*b-c*c)/(2*a*b));

// find the angle between M1M2 and M1P, where P is the position of the pen

void FK(float l1, float l2,float &x,float &y) {

float a=l1 * TPS;

float b=X SEPARATION;

float c=l2 * TPS;

// Method 1

float theta = acos((a*a + b*b - c*c)/(2 0*a*b));

x = cos(theta)*l1 + LIMXMIN;

y = sin(theta)*l1 + LIMYMIN;

// Method 2

/* float theta = (a*a + b*b - c*c)/(2 0*a*b);

x = theta*l1 + LIMXMIN;

y = sqrt (1 0 - theta * theta ) * l1 + LIMYMIN;*/

//reverse motion - convert XY coordinates to length L1, L2

void IK(float x,float y,long &l1, long &l2) {

float dy = y - LIMYMIN;

float dx = x - LIMXMIN;

l1 = round(sqrt(dx*dx+dy*dy) / TPS);

dx = x - LIMXMAX;

l2 = round(sqrt(dx*dx+dy*dy) / TPS);

// Pen state

void pen state(int pen st) { if(pen st==PEN DOWN) {

ps=PEN DOWN ANGLE;

// Serial println("Pen down");

} else {

ps=PEN UP ANGLE;

// Serial println("Pen up"); }

pen write(ps);

void pen down()

{ if (ps==PEN UP ANGLE) { ps=PEN DOWN ANGLE; pen write(ps); delay(TPD);

} void pen up()

{ if (ps==PEN DOWN ANGLE) {

ps=PEN UP ANGLE; pen write(ps);

// Debug code serial output machine status void where() {

Serial.print("X,Y= ");

Serial print(posx);

Serial print(",");

Serial.print(posy);

Serial print("\t");

Serial print("Lst1,Lst2= ");

Serial print(laststep1); Serial print(",");

Serial println(laststep2); Serial println(""); }

// returns angle of dy/dx as a value from 0 2PI static float atan3(float dy, float dx) { float a = atan2(dy, dx);

if (a < 0) a = (PI * 2 0) + a; return a;

// instantly move the virtual plotter position // does not validate if the move is valid static void teleport(float x, float y) { posx = x; posy = y; long l1,l2; IK(posx, posy, l1, l2);

laststep1 = l1;

laststep2 = l2;

//ref ---- slash program

void moveto(float x,float y) {

#ifdef VERBOSE

Serial println("Jump in line() function");

Serial print("x:");

Serial print(x);

Serial.print(" y:");

Serial println(y);

#endif

long l1,l2; IK(x,y,l1,l2);

long d1 = l1 - laststep1;

long d2 = l2 - laststep2;

#ifdef VERBOSE

Serial print("l1:");

Serial print(l1);

Serial print(" laststep1:");

Serial.print(laststep1);

Serial print(" d1:");

Serial println(d1);

Serial.print("l2:");

Serial print(l2);

Serial print(" laststep2:");

Serial print(laststep2);

Serial print(" d2:");

Serial println(d2);

#endif

long ad1=abs(d1); long ad2=abs(d2);

int dir1=d1>0 ? M1 REEL IN : M1 REEL OUT; int dir2=d2>0 ? M2 REEL IN : M2 REEL OUT; long over=0; long i;

if(ad1>ad2) {

for(i=0;i<ad1;++i) {

m1 moveRelativeInSteps(dir1); over+=ad2;

if(over>=ad1) { over-=ad1;

m2 moveRelativeInSteps(dir2); } delayMicroseconds(step delay);

for(i=0;i<ad2;++i) { m2 moveRelativeInSteps(dir2); over+=ad1; if(over>=ad2) { over-=ad2; m1 moveRelativeInSteps(dir1);

} delayMicroseconds(step delay);

} laststep1=l1; laststep2=l2; posx=x; posy=y;

//long distance movement will take a circular trajectory, so the long line will be cut into a short line to maintain a straight form static void line safe(float x,float y) { // split up long lines to make them straighter? float dx=x-posx; float dy=y-posy; float len=sqrt(dx*dx+dy*dy);

if(len<=TPS) { moveto(x,y); return;

// too long! long pieces=floor(len/TPS); float x0=posx; float y0=posy; float a;

for(long j=0;j<=pieces;++j) { a=(float)j/(float)pieces; moveto((x-x0)*a+x0,(y-y0)*a+y0); } moveto(x,y);

static void help() {

Serial println(F("== Wall Drawing Machine https://github com/shihaipeng03/Walldraw =="));

Serial.println(F(" ")); } void line(float x,float y)

{ line safe(x,y);

// butterfly curve

void butterfly curve(int xx,int yy,int lines,int x scale,int y scale)

//xx,yy butterfly center position, lines number of circles, more complex x scale, y scale xy axis

magnification ratio {

float xa,ya,p,e;

pen up();

moveto(xx,yy + y scale * 0.71828);

pen down();

for(float i=0;i<6.28*lines;i+=3.14/90)

p=pow(sin(i/12),5);

e=pow(2.71828,cos(i));

xa=x scale * sin(i) * (e - 2*cos(4*i) + p);

ya=y scale * cos(i) * (e - 2*cos(4*i) + p);

line safe(xa+xx,ya+yy); }

pen up();

//

Peach heart curve

void heart curve(int xx,int yy,float x scale,float y scale)

//xx,yy the center of the peach heart curve, x scale, y scale the magnification scale of the xy axis

float xa,ya;

pen up();

moveto(xx,yy+y scale * 7);

pen down();

for(float i=0;i<=6 28;i+=3 14/180)

xa=x scale * pow(sin(i),3) * 15;

ya=y scale * (15*cos(i) - 5*cos(2*i) - 2*cos(3*i) - cos(4*i));

line safe(xa+xx,ya+yy);

pen up();

//Box1

void rectangle(float xx,float yy,float dx,float dy,float angle)

{

float six,csx,siy,csy;

dx/=2;

dy/=2;

six = sin(angle/180*3 14) * dx;

csx = cos(angle/180*3 14) * dx;

siy = sin(angle/180*3 14) * dy;

csy = cos(angle/180*3 14) * dy;

pen up();

line safe(csx - siy + xx,six + csy + yy);

pen down();

line safe(xx - csx - siy,csy - six + yy);

line safe(xx - csx + siy,yy - csy - six);

line safe(csx + siy + xx,six - csy + yy);

line safe(csx - siy + xx,six + csy + yy);

pen up();

//box2

void box(float xx,float yy,float dx,float dy)

{

pen up();

line safe(xx , yy);

pen down();

delay(TPD);

line safe(xx + dx, yy);

delay(TPD);

line safe(xx + dx, yy+ dy);

delay(TPD);

line safe(xx , yy + dy);

delay(TPD);

line safe(xx , yy);

pen up();

// circle

void circle(float xx,float yy,float radius x,float radius y)

float rx,ry;

float st= 3 14159 / 90; // circle division accuracy

pen up();

line(xx+radius x,yy);

pen down();

for(float i=0;i<6.28318;i+=st)

rx = cos(i) * radius x;

ry = sin(i) * radius y; line(xx+rx,yy+ry);

pen up();

//circular arc

void arc(float xx,float yy,float radius,float sangle,float eangle)

float rx,ry,i; sangle+=360;

eangle+=360;

sangle=sangle / 180 * PI; //convert to radians 360 degrees = 2Π

eangle=eangle / 180 * PI; float st= 3 14159 / 360; // circle division accuracy

pen up();

line(xx+cos(sangle)*radius,yy+sin(sangle)*radius); pen down(); if (sangle<eangle) { for(i=sangle;i<eangle;i+=st)

rx = cos(i) * radius;

ry = sin(i) * radius; line(xx+rx,yy+ry);

} else { for(i=sangle;i>eangle;i-=st)

rx = cos(i) * radius;

ry = sin(i) * radius; line(xx+rx,yy+ry);

} pen up(); } //star { void star(float xx,float yy,float radius r,int corner)

void setup() {

// put your setup code here, to run once: Serial.begin(BAUD);

m1 connectToPins(7,8,9,10); //M1 L stepper motor in1~4 ports corresponding to UNO 7 8 9 10

m2 connectToPins(2,3,5,6); //M2 R stepper motor in1~4 ports corresponds to UNO 2 3 5 6

m1 setSpeedInStepsPerSecond(10000);

m1 setAccelerationInStepsPerSecondPerSecond(100000);

m2 setSpeedInStepsPerSecond(10000);

m2 setAccelerationInStepsPerSecondPerSecond(100000);

// lift the pen servo pen attach(A0);

ps=PEN UP ANGLE; pen write(ps);

//set the current pen position to 0, 0

teleport(0, 0);

pen up(); Serial println("Test OK!"); }

void loop() {

//Demo program will draw some simple graphics delay, please debug the parameters, the A4 or larger paper, centered on the pen holder before turning on the machine demo3();

//demo2(); //remove the top //also demonstrate another code

moveto(0,0);

void demo2() {

int rd=0; float sa,ea; rd=random(10);

sa=random(0,360);

do {

if (rd >95) rd=100; else rd+=random(8,15);

ea=random(5,15);

int z=map(random(0,2),0,1,-1,1);

ea=sa+ea*z;

Serial println("sa: "+String(sa)+" ea: "+String(ea));

pen down();

line(cos(sa/180*PI)*rd,sin(sa/180*PI)*rd); arc(0,0,rd,sa,ea);

sa=ea;

} while (rd<100); }

void demo1() {

pen up();

box(-45,0,90,90); moveto(-15,0);

pen down();

line(-15,90);

pen up();

moveto(15,90);

pen down();

line(15,0);

pen up();

moveto(-45,30);

pen down(); line(45,30);

pen up();

moveto(45,60);

pen down(); line(-45,60);

pen up();

box(-42 5,62 5,25,25);

circle(0,75,12.5,12.5);

rectangle(30,75,17 7,17 7,45);

rectangle(-30,45,17 7,17 7,45);

box(-12 5,32 5,25,25);

circle(30,45,12 5,12 5);

circle(-30,15,12.5,12.5);

rectangle(0,15,17 7,17 7,45);

box(17 5,2 5,25,25);

// heart curve Parameters (x, y position, x magnification, y magnification)

heart curve(-45,-45,2,2);

//butterfly line Parameters(x,y position, the larger the circle the more complex, x magnification, y magnification)

butterfly curve(45,-55,3,12,12);

}

void demo3(){

while(1){

pen up();

pen down();

CHAPTER7:CONCLUSIONANDFUTURESCOPE

7.1CONCLUSION

In conclusion, people who are interested in robotics, electronics, and programming may find building a DIY drawing robot using an Arduino microcontroller to be a fun and satisfying endeavour. A robotic arm must be put together, motors and actuators must be installed, and the Arduinomustbeprogrammedtooperateboththearmandthedrawingtool.

An Arduino board, servo motors, a robotic arm kit, a sketching tool, and apowersourcearethe essential parts needed forthisproject.Themovementpatternsoftherobotmustalsobedesigned andprogrammed;thiscanbedoneusingprogramminglanguageslikePythonorC. While creating a DIY drawing robot might be entertaining,italsonecessitateshavingaworking understanding of electronics, mechanics, and programming. As a result, it is advised to have some prior experience or to look for advice from online tutorials, forums, or industry professionals.

The robot's movement rangeandaccuracywilldependonthetypeandsizeofthesketchingtool. Although a smaller, lighter tool may enable finer lines and details, it may also restrict the arm's range ofmotionandspeed.Contrarily,alargerandheaviertoolcouldneedstrongermotorsanda moredurableframe,butitmightalsoenablelargerstrokesandmoreexpressivegestures.

The robot'sbrain,theArduinoboard,isinchargeofcommandingthemotorsandcommunicating with the sketching tool. It is crucial to pick a board that works with the project's motors and sensors, as well as the right programminglanguageandsoftwaretools.Thepowersupplyisalso a crucial component, as it provides the necessary voltage and current to the motors and other components. It is important to choose a power supply that is compatible with the voltage and amperagerequirementsoftherobot,andtoensurethatitissafeandreliable.

7.2FUTURESCOPES

The DIY drawing robot project using Arduino has alotofpotentialforfuturedevelopmentsand applications.Herearesomepotentialfuturescopesforthesame:

1. Multi-colored drawing: At the moment, the homemade drawing robot can only draw in one colour, either with a pen or a pencil. A device to change the colour of a single pen could be added to the robot in the future, or it might use numerous pens to support multiplecolours.

2. Integration with AI and Machine Learning: Therobotcouldlearntodrawmorecorrectly and independently by combining AIandmachinelearningtechnologies.Forinstance,the robot may examine adesignorimageandmodifyitsactionstomoreaccuratelyduplicate it.

3. 3D printing capabilities: By altering therobot'sdesign,3Dobjectsmightbeprintedbyit. The Arduino might be programmed to control theextrusionandmovementoftheheadif therobotarmisoutfittedwitha3Dprintingheadoranextruder.

4. Collaboration and remote control: By incorporating remote control features, the robot could be controlled remotely via a web interface or mobile app. This would make it possible for artists to work remotely on projects or allow them to produce art from variouslocations.

5. Art therapy: For those with disabilities or mental health concerns, the DIY sketching robot may be used in art therapy The robot could assist people in creating artwork that they might not be able to do on their own and help them express themselves throughart inanonjudgmentalway.

6. Real-time feedback: The DIY drawing robot might give the user feedback on the drawing'saccuracyandqualityinreal-timebyincludingsensorsandfeedbacksystems.

7. Interactive installations: Homemade sketching robots could be used to make interactive art pieces that involve the audience and react to theirinputsormovements.Forinstance, the robot might respond to crowd motion or vocal ordersbydrawingonasizablecanvas ordisplay.

REFERENCES

1. “Microcontroller Based X-Y Plotter”, International Journal of Advanced Research in Electrical,Electronics and Instrumentation Engineering Vol. 3, Special Issue 3, April 2014, Mrs. R. Dayana, GunaseelanP.

2. “Application with a XY-plotter controlled by PLC used in student laboratory works”,May 2015,MihaiRata andGabrielaRata.

3. “Design and Development ofXY Plotter Mechanical System Design PART 2”, DOI: 10.13140/RG.2.1.3255.8167January2016,WeiMingNgandRossiHamzah.

4. “Microcontroller Based Plotter Machine”, Al-Nahrain Journal for Engineering Sciences (NJES)Vol.21No.3, 0218pp.350–355,30-April-2017,AnasLateefandAmanIsmailNsayef.

5. “Design and Implementation of XY-Plotter”, International Journal of Science, EngineeringandTechnology Research (IJSETR) Volume 7, Issue 7, July 2017, ISSN: 2278 -7798, Mya ThandarKyu, WarWarHtun.

6. “CNClaboratory based scale plotter”,JurajOrvacetal.SlovakUniversityofTechnology.

7. “2D plotter for SCARA”, InternationalJournalforengineeringandinnovativetechnology (IJEIT)volume3,Dr.MShivkumaretal.

8. “G-CODE for CNC”, International Journal for Engineering and Innovative Trends in Computing,T.J.Titusetal.

9. “XY Plotter Drawing Robot Arduino Polargraph”, By MertArduino (/member/MertArduino/)inCircuits (/circuits/)Arduino(/circuits/arduino/projects/)

10.E., & Elecrow &raquo;, M. A. (n.d.). DIY Arduino Drawing Robot. Instructables. https://www.instructables.com/DIY-Arduino-Drawing-Robot/