DIY DRAWING ROBOT USING ARDUINO

DIY DRAWING ROBOT USING ARDUINO UNO By Kriti Goel (2040345) Sairaj Natraj (2040366) Chirag N (2040379)

Under the guidance of Prof. Johnson O.V. Department of Physics and Electronics

A project report submitted in partial fulfillment for the award of degree of B.Sc. (Electronics) of CHRIST (Deemed to be University), Bengaluru. www.christuniversity.in May 2023

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)

Project Guide

(Prof. Benny Sebastian)

(Prof. Johnson O.V.)

Examination Date: 24th April, 2023

Name of the Student: Chirag N

Examination Centre: Christ University

Class: VI Semester PME

Register No.: 2040379

2

ACKNOWLEDGEMENT We would like to express our sincere gratitude to all those who contributed to the completion of this project. First and foremost, we would like to express our deepest 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 carrying out this project.

We would like to thank our project supervisor Prof. Johnson O.V. and Miss Raksha 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 the project's success.

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 essential to the project's findings.

Finally, we would like to thank our families and friends for their unwavering support and encouragement throughout this project. Their love and encouragement helped us stay motivated during the challenging times.

Thank you all for your contributions and support in making this project a reality.

3

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 control its movement, as well as a servo motor that controls the pen's position. The robot's movements are controlled by the 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 project that demonstrates the capabilities of DIY robotics.

4

INDEX

ACKNOWLEDGEMENT ABSTRACT

6

CHAPTER 1. INTRODUCTION CHAPTER 2. DETAILS OF CIRCUIT 2.1 CIRCUIT DIAGRAM 2.2 COMPONENTS

8 9

CHAPTER 3. WORKING 3.1 BLOCK DIAGRAM 3.2 WORKING 3.3 OPERATION 3.4 PROJECT MODEL

14 15 16 20

CHAPTER 5. SOFTWARE TOOLS AND PROGRAMMING 5.1 SOFTWARE 5.2 DETAILS OF IDE 5.3 PROGRAM CODE 5.4 FLOWCHART

21 24 25 37

CHAPTER 6. CONCLUSION 6.1 CONCLUSION 6.2 FUTURE SCOPES

38 39

REFERENCES

40

5

CHAPTER 1: INTRODUCTION A DIY drawing robot using Arduino Uno is a robotic system that is designed to draw pre-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 drawing mechanism.

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 a precise manner. The pen holder holds the drawing tool (pen, marker, or brush), and the Arduino Uno board provides the instructions and control signals that move the arm and the drawing mechanism.

The project is suitable for individuals who are interested in robotics, electronics, and programming, as it involves building a robot from scratch, programming the Arduino Uno board, and designing a drawing mechanism that can accurately follow a given design. The project provides a fun and challenging platform for learning the basics of electronics and programming, as well as exploring the mechanics of a robotic arm.

The same principle can be used in several applications. For example, a 3D printer (while it is not strictly a 2D plotter, it can be used to create 2D shapes and patterns in addition to more complex 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. The choice of the best alternative will depend on the specific needs and requirements of the user.

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 opportunity for individuals to learn and experiment with new technologies while developing their creativity and problem-solving skills.

The DIY drawing robot using Arduino Uno is a project that involves building a robotic system capable of drawing pre-defined designs on paper or other surfaces.

6

The system is composed of various components, including a chassis, motors, gears, a pen holder, and an Arduino Uno microcontroller board.

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 gears enable the arm to move in a precise manner. The pen holder holds the drawing tool, which can be a pen, marker, or brush, and the Arduino Uno board provides the instructions and control signals that move the arm and the drawing mechanism.

To program the Arduino Uno board, individuals can use various coding platforms, such as Arduino IDE or Scratch. The programming involves writing code to control the movement of the robotic arm and the drawing mechanism, which can include specifying the direction, speed, and duration of movement. The system is typically powered by a battery or a power supply, depending on the specific design and requirements.

The DIY drawing robot using Arduino Uno project provides a fun and challenging platform for individuals to learn and experiment with robotics, electronics, and programming. It allows individuals to develop their creativity and problem-solving skills, as well as their understanding of how robotic systems work.

In summary, the DIY drawing robot using Arduino Uno is a fascinating and educational project that combines several fields of technology, providing individuals with an exciting opportunity to learn and explore new concepts while building a functional robotic system.

7

CHAPTER 2: DETAILS OF CIRCUIT 2.1 CIRCUIT DIAGRAM

Fig 1: Circuit Diagram

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, which controls the movements of the stepper and servo motors.

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 pen holder to create the desired shape or line. The pen holder holds the pen or other drawing tool and moves it across the drawing surface to create the drawing.

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 stepper and servo motors through belts, gears, or other mechanical mechanisms.

8

2.2 COMPONENTS

Fig 2: Components

The circuit of a DIY drawing robot using Arduino Uno involves connecting various components, such as stepper motors, sensors, and power supply, to the Arduino Uno board. Here are some details of the circuit components and their connections: 1. ARDUINO UNO BOARD Arduino Uno is a microcontroller board based on the ATmega328P microcontroller chip.

The Arduino Uno board is the main controller of the robotic system, and it is responsible 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 USB cable or a power supply, and it communicates with a computer or other devices using a serial communication protocol.

Technical Specifications: 1. Microcontroller: ATmega328P 2. Operating Voltage: 5V 3. Input Voltage (recommended): 7-12V 4. Input Voltage (limits): 6-20V 5. Digital I/O Pins: 14 (of which 6 provide PWM output) 9

6. PWM Digital I/O Pins: 6 7. Analog Input Pins: 6 8. DC Current per I/O Pin: 20 mA 9. DC Current for 3.3V Pin: 50 mA 10. Flash Memory: 32 KB (ATmega328P) of which 0.5 KB used by bootloader 11. SRAM: 2 KB (ATmega328P) 12. EEPROM: 1 KB (ATmega328P) 13. Clock Speed: 16 MHz 2. ARDUINO SENSOR SHIELD An Arduino sensor shield is a board that is designed to be mounted on top of an Arduino 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 needs of the project.

3. MOTORS (Stepper 28BYJ-48 and Servo) 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 appropriate power and direction signals for the 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 appropriate controller. Here are some key specifications: Voltage: 5V DC

10

Current: 250mA Resistance: 20 ohms per winding Step angle: 5.625 degrees/64 steps per revolution Holding torque: 34.3 mN.m (approx. 48 oz.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 driver board used and the desired direction and speed of rotation.

Features of motor driver: 1. Minimum-Maximum operating voltage: 8-35V 2. Continuous current per phase: 1 Amp 3. Maximum current per phase: 2 Amp 4. Minimum-Maximum logic voltage: 3-5.5V 5. Micro step resolutions: Full, 1/2, 1/4, 1/8, and 1/16 6. Reverse voltage protection? No The 28BYJ-48 is often used in small robotics projects, such as for controlling the movement of small robot arms or for precise control of small CNC machines.

Fig 3: Motor Driver of 2BYJ-48

11

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 actuator that is commonly used in robotics and other applications where precise control of position and velocity is required. It works by rotating an output shaft to a specific angle based on a control signal.

Some technical specifications of a typical servo motor include: Torque: This is the rotational force that the servo motor can produce. It is usually measured in units such as Newton-meters (Nm) or ounce-inches (oz-in).

Speed: This is the maximum rotational speed of the servo motor. It is usually measured in units such as revolutions per minute (RPM) or degrees per second (°/s).

Operating Voltage: This is the voltage range over which the servo motor can operate. It is usually measured in volts (V).

Control Signal: This is the type of signal used to control the servo motor. The most common type is a pulse-width modulation (PWM) signal, which is used to set the desired position of the output shaft.

It's important to choose a servo motor with specifications that match the requirements of your project. Some other factors to consider include the durability and reliability of the motor, as well as the availability of compatible control systems and accessories.

4. MICRO SD CARD A micro SD card can be used in a DIY drawing robot using Arduino to store and retrieve drawings or other data related to the robot. Here are some ways a micro SD card can be used in this type of project: 1. Storing drawing instructions: One way to use a micro SD card is to store drawing 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 from the SD card and execute them to create the drawing.

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 useful for creating a portfolio of drawings or sharing drawings with others.

12

3. Calibration data: The micro SD card can also be used to store calibration data for the robot's motors and sensors. This data can be used to ensure accurate movements and precise drawing placement.

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 a simple way to read and write data to the SD card. The Arduino code can be programmed to read and write data to the 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, and calibration data from the micro SD card.

5. PEN HOLDER, BELTS AND PULLEYS A pen holder is used to hold the pen or marker that is used for drawing. Belts and pulleys are used to transmit the motion of the stepper motors to the robot's arms and pen.

6. POWER SUPPLY An additional 9V power supply is required to power the motors and other electronic components of the robot.

13

CHAPTER 3: WORKING AND OPERATING PROCEDURE 3.1 BLOCK DIAGRAM

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 the movements of the stepper and servo motors.

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 pen holder to create the desired shape or line. The pen holder holds the pen or other drawing tool and moves it across the drawing surface to create the drawing.

Overall, the block diagram shows how the various components of the DIY drawing robot are interconnected and work together to create a functional drawing machine.

14

3.2 WORKING 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 sensors or other devices and sending output signals to the motors to control their movements.

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 the servo motor is used to control the position of the pen.

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. The input may consist of a series of instructions or commands that specify the desired drawing, such as the shape, size, and position of the lines or curves.

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 motor is used to adjust the position of the pen to create the desired shape or line.

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 the end of a linear motion, while encoders can be used to measure the position and velocity of the motors.

Overall, the principle of the circuit of a DIY drawing robot using Arduino involves using the microcontroller and motor drivers to control the movements of the stepper and servo motors in a coordinated and precise manner to create a desired drawing.

15

3.3 OPERATION: 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 should be followed carefully to ensure that all components are connected correctly.

2. Programming: The next step is to program the Arduino Uno board using the Arduino software. The program should read the drawing instructions from a text file stored on the MicroSD Card Adapter and control the 28BYJ Stepper Motor based on these instructions.

The program should use the stepper motor library to control the motor.

3. Drawing Instructions: Create a text file containing the drawing instructions for the robot to follow. Each line in the text file should represent a single instruction for the robot to execute, such as "move 10 steps forward" or "turn 90 degrees to the left".

4. Operating the Robot: To operate the drawing robot, insert the MicroSD Card Adapter with the text file containing the drawing instructions into the MicroSD Card Adapter slot 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 these instructions to create the desired drawing.

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 movements as necessary to achieve the desired result.

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, following the instructions from the text file to create the desired design.

7. Power Supply: The drawing robot will require a power source to run. This can be achieved using a USB cable connected to a computer or a battery pack. The power supply

16

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 table or workbench to prevent movement during the drawing process.

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 is important to choose a pen or implement that is light and easy to move, to minimize the load on the motor.

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 information from the program. This can be helpful in identifying issues with the program logic or the communication between the components.

11. Maintenance: Regular maintenance may be required to keep the drawing robot running smoothly. This may involve cleaning and lubricating the 28BYJ Stepper Motor, checking the wiring for loose connections, and replacing any worn components as necessary.

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. By changing the delay, it is possible to make the motor move faster or slower, and to change the direction of movement.

13. Modifying Drawing Instructions: The drawing instructions in the text file can be modified to create different designs or patterns. For example, by changing the number of 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 multiple surfaces. This can be achieved by connecting multiple motors to the Arduino Shield and controlling them using the program.

17

15. Using Sensors: Sensors such as light sensors or proximity sensors can be added to the robot to allow it to respond to its environment. For example, a light sensor can be used to detect the edges of the drawing surface and adjust the drawing instructions accordingly.

16. Adding User Input: It is possible to add user input to the drawing robot, allowing users to 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 respond to user input.

17. Scaling and Rotating Drawings: By modifying the program and the drawing instructions, 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: A CNC (Computer Numerical Control) machine is a type of robotic machine that can be used for precision cutting, engraving, and milling tasks. By using a CNC machine instead of a drawing robot, it is possible to create more complex and detailed designs, as well as 3D objects.

18. Adding a Servo Motor: In addition to the 28BYJ Stepper Motor, a servo motor can be added to the drawing robot to control additional functions such as lifting and lowering the pen. By using a servo motor, it is possible to create more precise and controlled movements of the pen, which can be useful for creating more detailed drawings.

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 robot to accommodate different types of drawing tools, it is possible to create a wider range of designs and patterns.

20. Using Different Drawing Surfaces: The drawing robot is typically designed to draw on a flat surface such as paper or a whiteboard. However, it is possible to modify the robot to draw on other surfaces such as walls or 3D objects. This can be achieved by adding additional motors to control the movement of the robot in multiple dimensions.

21. Creating Custom Programs: While the example program provided in the previous steps is a good starting point for operating a drawing robot, it may not be suitable for all types of drawings or designs. By creating custom programs using the Arduino software, it is possible to tailor the robot's movements and instructions to specific design requirements.

18

22. Using Machine Learning: By using machine learning algorithms and techniques, it is possible to train the drawing robot to create specific types of designs or to learn from past drawings. This can be useful for creating more complex and nuanced drawings, as well as for automating the design process.

23. Power Supply: It is important to use a suitable power supply to operate the drawing robot.

The Arduino board and motor require a certain amount of voltage and current to operate effectively. Depending on the number of motors and other components used, a power supply with sufficient wattage may be required.

24. Calibration: The drawing robot may require calibration to ensure that it is drawing accurately and consistently. This involves adjusting the motor steps and speeds, as well as the pen position and lifting mechanism. Calibration may need to be done periodically to ensure optimal performance.

25. Safety Considerations: When operating a drawing robot, it is important to take safety precautions to prevent injury or damage to the equipment. This includes ensuring that the robot is securely mounted and that the drawing surface is stable, using appropriate electrical safety measures, and avoiding any moving parts while the robot is in operation.

26. Maintenance: Like any machine, the drawing robot may require maintenance over time to ensure optimal performance. This may include cleaning and lubricating the motors and other components, replacing worn or damaged parts, and checking for any loose connections or other issues.

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 possible to create designs that are optimized for the robot's capabilities and limitations.

19

3.4 PROJECT MODEL

Fig 4: Actual working model of project

20

CHAPTER 4: SOFTWARE TOOLS AND PROGRAMMING 4.1 SOFTWARE 1. LaserGRBL This software is used to convert images into vector drawings and generating gcode which would further be uploaded to the CNJCs. 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 scaled up or down.

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 fast to move, and how deep to cut. Gcode file is saved in the memory card, Arduino reads the file from the card, and the position coordinates are resolved into the action of the stepper motor, pulling the rope to drive the pen to draw. (WallDraw.ino program in the package can perform this step).

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, and it 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 consistent results.

21

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 for your port, and 115200 for Baud rate (please install the Ch340 driver for unrecognized devices). Finally, click the Upload button, the status bar will show uploading prompt, close it after success.

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, including the popular Arduino Uno and Arduino Mega.

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 can be run on the 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 board or for uploading specialized programs that may not be compatible with the Arduino IDE.

22

3. CNCjs This software is used to upload gcode and run it in arduino to make pre-defined drawings.

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 baud rate, open it and establish the connection. After a normal connection, the console will show the following content. And there is an OK prompt.

We can test it by typing a simple GCode after the prompt.

G01 x0y0z0 // Drop pen G01 Z1 //Lift pen If the test is OK, we can open the GCode file and start our drawing.

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 the toolpath, and monitoring the machine's status in real-time.

CNCjs can be run on a variety of platforms, including Windows, Linux, and Mac OS, and it supports a wide range of CNC controllers and machines. The software also has features like job queuing, machine monitoring, and support for custom macros and plugins.

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-board computer, you can create a standalone CNC controller that can communicate with the CNC machine over USB or serial connections.

Overall, CNCjs is a versatile and powerful software that can streamline CNC machine operation and enhance the user experience for both hobbyists and professionals alike.

23

4.2 DETAILS OF IDE The Arduino IDE (Integrated Development Environment) is a software tool used for programming and uploading code to Arduino boards. It is an open-source platform, available for free on various operating systems like Windows, macOS, and Linux.

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), and a few other materials like paper, tape, and screws.

Once the robot is assembled, we can use the Arduino IDE to write and upload code that controls the robot's movements and drawing operations. Here are the basic steps: 1. Connect your Arduino board to your computer using a USB cable.

2. Open the Arduino IDE and create a new sketch (File > New).

3. Write the code (2Stepper.ino) that controls the movements of the robot's servo motors, such as moving the pen up and down, and left and right.

4. Write the code(Walldrawdemo.ino) that controls the drawing operations, such as drawing lines or shapes.

5. Upload the code to the Arduino board by clicking on the "Upload" button in the IDE. 6. Once the code is uploaded, disconnect the USB cable from the board and power it with a battery or external power source.

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

24

5.3 PROGRAM CODE 1. 2Stepper.ino The function of this project is to make the stepper motor work and make a pendulum graph. #include <AccelStepper.h> #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 <AccelStepper.h> //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);

25

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 This is the main program which will draw a few programs for testing. #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 */

27

#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()

28

{ 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; }

29

//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); } } else {

30

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

31

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();

32

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;

33

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

34

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();

35

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(); } }

36

5.4 FLOWCHART OF WORKING

37

CHAPTER 7: CONCLUSION AND FUTURE SCOPE 7.1 CONCLUSION 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 Arduino must be programmed to operate both the arm and the drawing tool.

An Arduino board, servo motors, a robotic arm kit, a sketching tool, and a power source are the essential parts needed for this project. The movement patterns of the robot must also be designed and programmed; this can be done using programming languages like Python or C. While creating a DIY drawing robot might be entertaining, it also necessitates having a working 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 range and accuracy will depend on the type and size of the sketching tool.

Although a smaller, lighter tool may enable finer lines and details, it may also restrict the arm's range of motion and speed. Contrarily, a larger and heavier tool could need stronger motors and a more durable frame, but it might also enable larger strokes and more expressive gestures.

The robot's brain, the Arduino board, is in charge of commanding the motors and communicating 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 programming language and software tools. The power supply is also 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 amperage requirements of the robot, and to ensure that it is safe and reliable.

38

7.2 FUTURE SCOPES The DIY drawing robot project using Arduino has a lot of potential for future developments and applications. Here are some potential future scopes for the same: 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 multiple colours.

2. Integration with AI and Machine Learning: The robot could learn to draw more correctly and independently by combining AI and machine learning technologies. For instance, the robot may examine a design or image and modify its actions to more accurately duplicate it.

3. 3D printing capabilities: By altering the robot's design, 3D objects might be printed by it.

The Arduino might be programmed to control the extrusion and movement of the head if the robot arm is outfitted with a 3D printing head or an extruder.

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 various locations.

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 through art in a nonjudgmental way.

6. Real-time feedback: The DIY drawing robot might give the user feedback on the drawing's accuracy and quality in real-time by including sensors and feedback systems.

7. Interactive installations: Homemade sketching robots could be used to make interactive art pieces that involve the audience and react to their inputs or movements. For instance, the robot might respond to crowd motion or vocal orders by drawing on a sizable canvas or display.

39

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, Gunaseelan P. 2. “Application with a XY-plotter controlled by PLC used in student laboratory works”, May 2015, Mihai Rata and Gabriela Rata.

3. “Design and Development ofXY Plotter Mechanical System Design PART 2”, DOI: 10.13140/RG.2.1.3255.8167January 2016, Wei Ming Ng and Rossi Hamzah.

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

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

6. “CNClaboratory based scale plotter”, Juraj Orvacetal. Slovak University of Technology.

7. “2D plotter for SCARA”, International Journal for engineering and innovative technology (IJEIT) volume 3,Dr. M Shivkumaretal.

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/) in Circuits (/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/

40