2D Arduino Plotter
This is a drawing robot that takes a photo or image (this is compatible with most image types but png is recommended) and converts them to X and Y coordinates through 2 sets of code. We developed this as part of a course project in which we were tasked with developing a robot that takes an image file and once input into code, produces a set of coordinates or instructions that can then be sent to an Arduino to draw an image. This is done by checking the brightness of parts of the image to create outlines within the image. These outlines will then become the coordinates for the drawing robot. The original idea came from a 3D printer and how they use stepper motors to move the head of the printer to draw with plastic onto a print bed essentially. So we adapted this idea into 2 dimensions where once a pen was inserted where the print head would be, the robot is then ready to draw.
Supplies
Access to a 3D Printer-Part Files Included
Note: You need TWO of the BaseMount Part
Arduino UNO R4 WiFi [ABX00087] - Renesas RA4M1 / ESP32-S3 - Wi-Fi, Bluetooth, USB-C, CAN, DAC, OP AMP, Qwiic Connector, 12x8 LED Matrix
STEPPERONLINE Stepper Motor Nema 17 Bipolar 40mm 64oz.in(45Ncm) 2A 4 Lead 3D Printer Hobby CNC
Qt. 2
2pcs A4988 Stepstick Stepper Motor Driver Module with Heat Sink for 3D Printer Reprap Suitable for Arduino CNC
Qt. 2
uxcell LM8UU Linear Ball Bearings 8mmx15mmx24mm Carbon Steel for CNC Machine 3D Printer 10pcs
Qt. 1
5 Pack GT2 Pulley 16 Teeth 5mm Bore 16T Timing Belt Pulley Wheel Aluminum for 3D Printer
Qt. 1
uxcell 624ZZ Deep Groove Ball Bearing 4x13x5mm Double Shielded GCr15 Steel Bearings 5-Pack
Qt. 1
WWZMDiB CNC Shield V3 Engraving Machine Expansion Board A4988 Driver Expansion Board for Arduino 3D Printer CNC A4988
Qt. 1
2PCs 8mm x 450mm (.315 x 17.72 inches) Case Hardened Chrome Plated Linear Motion Rod Shaft Guide - Metric h8 Tolerance
Qt. 1
2PCs 8mm x 350mm (.315 x 13.78 inches) Case Hardened Chrome Plated Linear Motion Rod Shaft Guide - Metric h8 Tolerance
Qt. 1
5 Meters GT2 Timing Belt Width 6mm Fit
Qt. 1
AIWAN LEZHI 5 Meters GT2 Timing Belt Width 6mm Fit: Amazon.com: Industrial & Scientific
12V 2A Power Supply-Any Power Supply with 12V will work(Will have to wire to Circuit)
8x11 inch Printer Paper
M3-0.5 x 6mm
Qt. 8 Screws Needed (Link has 100)
Assemble the Stepper Motors Mounts
Take the BaseMotorMount and TopMotorMount pieces, and using the screws, attach a stepper motor to each part. Make sure the motors are centered on each part, and the shaft is in line with the belt windows. Fasten screws with Allen Wrench.
Next, grab the 2 of the Belt Pulley wheel, and fasten to the motor shafts using Allen Wrench. Ensure that the wheel belt is centered in the belt window on each respective part.
Install Bearings
Grab 6 of the Linear Ball Bearings and insert into the two bottom holes on TopBearingBaseMount part, the two upper holes on PenMount part, and the two bottom holes on TopMotorMount. Some of the holes may not be big enough to insert the bearings to. File the holes down, and use rubber mallet to force them in.
Grab 2 of the Ball Bearings and install them in the windows on the BearingBaseMount part, and the TopBearingBaseMount. Center the bearings under the hole of each respective window/part. Next use the bearing locks or any piece of scrap wood/metal to plunge the hole and extend through the bearings hole to secure it.
Rod Assembly
Grab 2 of the 450mm long rods (longest size) and slide them through the linear bearings in the PenMount part. The ends of the two rods should be inserted in the top holes on both the TopBearingBaseMount and the TopMotorMount.
Grab 2 of the shorter 350mm long rods and slide them through the two other pairs of linear bearings on the TopBearingBaseMount, and the TopMotorMount. The ends of the rod on the TopBearingBaseMount should be inserted into the holes on the two BaseMount parts.
Finally use any sort of lubricant on the 4 rods. White Lithium worked great, but you should be able to get by with most lubricants.
Circuit Board Assembly
To assemble the circuit just follow the images above. Note that for a DC power supply, simply wire the power and ground ports from the power supply to the 12V and ground ports on the Arduino.
Assembly
Now assemble the entire plotter. You can mount the plotter to a table if necessary. We used a large section of cardboard or wood for easier transportation. The plotter doesn't draw great on cardboard. We recommend using any thin piece of smooth and flat material for the actual writing surface.
Some pens may be too big to fit in the hole, to get your pen in use a rod filer to size the hole down.
After orientating the assembly like the picture's, tape down the four corner parts that are stationary. Make sure not to tape any of the parts with linear ball bearings.
Once everything is oriented correctly, secure the belts. Cut off two sections of belts that hit around each axis pass. Run the belt through the windows, bearings, and belt pulley wheel. Make the belt short enough so there is plenty of tension on the belt. Fasten the belt together with super glue. Finally fast the belt to one of the side walls of the PenMount part. The other belt section should be fastened to one the outer walls of the TopMotorMount.
Place a piece of paper in the drawing area and secure it with adhesive or thumb tacks.
Software Overview
- First run the image generation python script
- do this as needed until you get a desired result (see notes under first python code for more details)
- Next connect to Arduino and run Arduino code
- this will also allow you to see what port you are connected to and change the baud rate to 115200 (make sure to close serail monitor after changing baud rate)
- run second python code
- this code will make sure that it has connection with the Arduino if you get an error you probably have the port, baud rate, connection to Arduino wrong.
- this code will prompt you to set the pen in the 0,0 location and then type go in the python command window
- sit back and let the robot work.
Image Generation Code(Python)
import cv2
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import math
import os
PAPER_WIDTH_MM = 180 # paper size
PAPER_HEIGHT_MM = 250 # paper size
DPI = 4 # dont touch
STEPS_PER_MM = 6.25 # dont touch
THRESHOLD = 100 # 0 to 255 (how dark do the lines need to be to draw)
EPSILON_RATIO = 0.0001 # smaller number more accurate lines (.1 to .0000000001)
#function to resize image to maximaze size on a peice of paper and find the lines of the image
def process_image_with_edges(image_path):
width_pixels = int(PAPER_WIDTH_MM * DPI)
height_pixels = int(PAPER_HEIGHT_MM * DPI)
image = Image.open(image_path).convert('L')
scale_w = width_pixels / image.width
scale_h = height_pixels / image.height
scale = min(scale_w, scale_h)
new_width = int(image.width * scale)
new_height = int(image.height * scale)
print(f"Scaling image to: {new_width} x {new_height} pixels to fit paper size.")
image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
final_image = Image.new('L', (width_pixels, height_pixels), color=255)
x_offset = (width_pixels - new_width) // 2
y_offset = (height_pixels - new_height) // 2
final_image.paste(image, (x_offset, y_offset))
image_np = np.array(final_image)
_, thresh_image = cv2.threshold(image_np, THRESHOLD, 255, cv2.THRESH_BINARY_INV)
edges = cv2.Canny(thresh_image, 50, 150)
return edges
# function to simplify the complexity of curves and the image
def simplify_contour(contour, epsilon_ratio=EPSILON_RATIO):
epsilon = epsilon_ratio * cv2.arcLength(contour, True)
return cv2.approxPolyDP(contour, epsilon, True)
# find distance between points
def distance(p1, p2):
return math.hypot(p1[0] - p2[0], p1[1] - p2[1])
# find close poitns and connect them so you dont have random lines all over the page
def sort_contours_nearest_neighbor(contours):
sorted_contours = []
if not contours:
return sorted_contours
current = contours.pop(0)
sorted_contours.append(current)
while contours:
last_point = current[-1][0]
next_index = min(range(len(contours)), key=lambda i: distance(last_point, contours[i][0][0]))
current = contours.pop(next_index)
sorted_contours.append(current)
return sorted_contours
# make the lines into a path that the steepers can follow
def convert_contour_to_path(contour):
mm_per_pixel = 1 / DPI
path = []
for point in contour:
x_px, y_px = point[0]
path.append((x_px * mm_per_pixel, y_px * mm_per_pixel))
return path
# conver the parth to how much each steeper should rotate
def convert_path_to_steps(path):
steps_path = []
for x_mm, y_mm in path:
x_steps = round(x_mm * STEPS_PER_MM)
y_steps = round(y_mm * STEPS_PER_MM)
steps_path.append((x_steps, y_steps))
return steps_path
# graph the path so user can see waht it will print befor hand
def visualize_path(path):
x_coords, y_coords = zip(*path)
plt.figure(figsize=(8, 11))
plt.plot(x_coords, y_coords, linewidth=0.5)
plt.gca().invert_yaxis()
plt.title("Final Robot Drawing Path (Outline Only)")
plt.axis('equal')
plt.show()
# actually run all the fiusntions
def main(image_path):
edges = process_image_with_edges(image_path)
contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
print(f"Found {len(contours)} contours.")
simplified = [simplify_contour(c) for c in contours]
sorted_contours = sort_contours_nearest_neighbor(simplified)
full_path = []
for contour in sorted_contours:
path = convert_contour_to_path(contour)
full_path.extend(path)
path_steps = convert_path_to_steps(full_path)
visualize_path(full_path)
output_path = "optimized_outline_drawing_commands.txt"
with open(output_path, "w") as f:
for x, y in path_steps:
f.write(f"{x},{y}\n")
print(f"Commands saved to '{os.path.abspath(output_path)}'")
# path to image file you want to use
main("/Users/rigstrumbull/Downloads/jayhawk.png")
Notes: to use: set the paper width and paper height, then set path to image (last line of code), then run the program and adjust the threshold and epsilon values as you see fit until you get a result you are happy with
Arduino Code
#include <AccelStepper.h>
// define waht is what pin for steepers
#define X_STEP_PIN 2
#define X_DIR_PIN 5
#define Y_STEP_PIN 3
#define Y_DIR_PIN 6
#define ENABLE_PIN 8
AccelStepper stepperX(AccelStepper::DRIVER, X_STEP_PIN, X_DIR_PIN);
AccelStepper stepperY(AccelStepper::DRIVER, Y_STEP_PIN, Y_DIR_PIN);
// define how mcuh each steeper needs to move
#define STEPS_PER_MM 6.25
#define TEST_DISTANCE_MM 100
// set steeper speeds and confimr conenction with python
void setup() {
Serial.begin(115200);
pinMode(ENABLE_PIN, OUTPUT);
digitalWrite(ENABLE_PIN, LOW);
stepperX.setMaxSpeed(2000);
stepperX.setAcceleration(1000);
stepperY.setMaxSpeed(2000);
stepperY.setAcceleration(1000);
stepperY.setPinsInverted(true, false, false);
Serial.println("READY");
}
// get corrdiantes from pyhton and move steepres in
// a way that move the pen
// also a built in test funiton to make sure the steepers are
// coneected and workign
void loop() {
if (Serial.available()) {
String line = Serial.readStringUntil('\n');
line.trim();
if (line == "TESTXY") {
Serial.println("RUNNING TESTXY");
long testSteps = TEST_DISTANCE_MM * STEPS_PER_MM;
stepperY.moveTo(testSteps);
while (stepperY.distanceToGo() != 0) stepperY.run();
delay(1000);
stepperY.moveTo(0);
while (stepperY.distanceToGo() != 0) stepperY.run();
delay(1000);
stepperX.moveTo(testSteps);
while (stepperX.distanceToGo() != 0) stepperX.run();
delay(1000);
stepperX.moveTo(0);
while (stepperX.distanceToGo() != 0) stepperX.run();
Serial.println("OK");
} else {
int commaIndex = line.indexOf(',');
if (commaIndex > 0) {
long x = line.substring(0, commaIndex).toInt();
long y = line.substring(commaIndex + 1).toInt();
stepperX.moveTo(x);
stepperY.moveTo(y);
while (stepperX.distanceToGo() != 0 || stepperY.distanceToGo() != 0) {
stepperX.run();
stepperY.run();
}
Serial.println("OK");
}
}
}
}
Notes: Run arduino code second, make sure you are connected to arduino and have the correct port as well as making sure no serial monitor is open as this will not allow the python script to send code.
Python Arduino Communication Code
import serial
import time
PORT = '/dev/cu.usbmodem101'
BAUD_RATE = 115200
STEP_FILE = "optimized_outline_drawing_commands.txt" # lines
#connect to arduino and get confimation from arduino you are conected
def send_file_to_arduino(step_file_path):
try:
ser = serial.Serial(PORT, BAUD_RATE, timeout=1)
time.sleep(2)
print("Connected to Arduino!")
input("Place pen at (0,0), then type 'go' and press Enter to start drawing: ")
# after user confimars pen in correct spot start reading text file and drawing
with open(step_file_path, "r") as file:
for line in file:
line = line.strip()
if not line:
continue
ser.write((line + '\n').encode())
print(f"Sent: {line}")
# confirm adruino is done seding current instrcuiton befor reading new instructions
while True:
if ser.in_waiting > 0:
response = ser.readline().decode('utf-8').strip()
print(f"Arduino: {response}")
if response == "OK":
break
print("Finished sending all drawing commands!")
except Exception as e:
print(f"Error: {e}")
#print done when done
finally:
if 'ser' in locals() and ser.is_open:
ser.close()
print("DONE")
if __name__ == "__main__":
send_file_to_arduino(STEP_FILE)
Notes: to use: first open arduino ide and upload arduino code to arduino, then confirm the port in this python code, make sure no serial monitor is open in arduino ide and then run this code, confirm pen is in 0,0 location (bottom left), it will confirm connections with arduino and wait to be prompted to start by typing "go" in the command window.