A robot arm that draws is one of the most satisfying builds you can make: the output is something you can hang on the wall, and every flaw in your mechanics shows up on the paper where you can see it. It’s also the cleanest way to learn inverse kinematics, because the problem is two-dimensional and the result is visible instantly.
How a drawing arm is laid out
A drawing robot arm doesn’t need six axes. The pen only has to move across a flat sheet and lift between strokes, so the classic layout is:
| Joint | Job | Typical actuator |
|---|---|---|
| Shoulder | Swings the upper arm across the paper | Metal-gear micro servo or stepper |
| Elbow | Swings the forearm, reaching near and far | Metal-gear micro servo or stepper |
| Pen lift | Raises and lowers the pen | SG90 micro servo |
Both arm joints rotate about vertical axes, so the arm sweeps flat over the paper — the same geometry as a SCARA arm, which is why SCARA builds are so often turned into pen plotters. The pen is the end effector; the paper is the workspace.
Three ways to build one
1. The three-servo drawing arm. Two servos for the arm, one for the pen lift, an Arduino and a printed or laser-cut frame. It’s the cheapest and quickest version, and the well-known PlotClock design on Thingiverse — an Arduino and three servos writing the time on a small whiteboard — shows how much a three-servo arm can do.
2. Adapt an arm you already have. Any servo arm kit can hold a pen with a printed holder. Lock the extra joints, use two for positioning and one for the pen lift. Larger arms reach bigger sheets but magnify servo error at the tip.
3. The stepper SCARA plotter. Two NEMA 17 steppers with belt reduction give far cleaner lines than servos, at the cost of drivers, homing switches and more wiring — see the stepper motor guide. This is the version to build when drawing quality is the whole point.
The pen lift
The pen lift decides whether your drawing looks like one continuous scribble or clean, separate strokes. The simplest mechanism is a micro servo that pushes the pen holder up against a light spring or rubber band, so gravity or the spring does the pressing down. Two rules make it work:
- Let the pen float. Mount it in a sleeve that slides freely, so paper that isn’t perfectly flat doesn’t jam the arm or skip the line.
- Wait after lowering. Pause for a moment after the pen goes down before moving, or every stroke starts with a faint tail.
The maths: two-link inverse kinematics
With upper-arm length L1, forearm length L2 and the shoulder at the origin, the
joint angles for a pen position (x, y) are:
#include <Servo.h>
#include <math.h>
const float L1 = 80.0, L2 = 80.0; // link lengths in mm — measure yours
Servo shoulder, elbow, lift;
bool solve(float x, float y, float &a1, float &a2) {
float d2 = x * x + y * y;
float c2 = (d2 - L1 * L1 - L2 * L2) / (2 * L1 * L2);
if (c2 < -1 || c2 > 1) return false; // point out of reach
float t2 = acos(c2); // elbow angle
float t1 = atan2(y, x) - atan2(L2 * sin(t2), L1 + L2 * cos(t2));
a1 = t1 * 180.0 / PI;
a2 = t2 * 180.0 / PI;
return true;
}
void penTo(float x, float y) {
float a1, a2;
if (!solve(x, y, a1, a2)) return;
shoulder.write(constrain(90 + a1, 0, 180)); // offsets depend on how horns are fitted
elbow.write(constrain(a2, 0, 180));
}
void setup() {
shoulder.attach(9); elbow.attach(10); lift.attach(11);
lift.write(60); // pen up
}
void loop() {
// Draw a 40 mm square, interpolating each side so the line stays straight
const float pts[5][2] = {{40,60},{80,60},{80,100},{40,100},{40,60}};
penTo(pts[0][0], pts[0][1]); delay(300);
lift.write(90); delay(200); // pen down
for (int i = 0; i < 4; i++) {
for (int s = 1; s <= 20; s++) {
float t = s / 20.0;
penTo(pts[i][0] + (pts[i+1][0] - pts[i][0]) * t,
pts[i][1] + (pts[i+1][1] - pts[i][1]) * t);
delay(30);
}
}
lift.write(60); delay(200); // pen up
while (true) {}
}Two details matter more than they look. First, interpolate: if you jump straight from
one corner to the next, each joint moves independently and the pen traces an arc, not a
line. Breaking every segment into small steps keeps lines straight. Second, the
angle offsets in penTo() depend on how you fitted the servo horns — calibrate them
by commanding known points and adjusting until the pen lands where it should. The
Arduino code guide covers the servo side in more
depth, and a PCA9685 driver gives finer pulse control
than the Servo library when you want smoother motion.
From image to pen strokes
The arm draws points, so every picture has to become paths first:
- Get vectors. Start from an SVG, or trace a bitmap into paths in Inkscape.
- Simplify and sort. Tools such as vpype can merge short segments, drop tiny details the pen can’t render, and reorder paths so the pen travels less between strokes — which often halves drawing time.
- Export points or G-code, then stream them to the Arduino over serial, converting each point to joint angles on the board (or in a Python script on your computer).
Line art, text and single-line drawings work far better than shaded photographs; hatching fills take a long time with a servo arm.
Getting clean lines from hobby servos
Servo arms draw wobbly lines for predictable reasons, and each has a fix:
- Resolution. A hobby servo moves in steps of roughly a degree; at 150 mm reach that’s a visible jump. Keep links short and work near the middle of the reach.
- Backlash. Gear play lets the pen wander when a joint reverses. Metal-gear servos such as the MG90S have noticeably less slop than plastic SG90s — see servo selection.
- Speed. Fast moves overshoot. Draw slowly and add more interpolation steps.
- Flex. A springy printed link turns into a shaky line. Stiffen it — the reach and payload guide explains why length costs you twice.
- Power. Servos twitch when the supply sags. Give them their own power supply.
Where to go next
Once the square draws cleanly, move on to text and simple line art, then try a stepper build if you want plotter-quality lines. For more build ideas at every level, browse DIY robotic arm projects, and for the full foundations start with how to build a robotic arm.
Frequently asked questions
How does a drawing robot arm work?
A drawing robot arm holds a pen as its end effector and moves it across paper using two arm joints in the horizontal plane, plus a third small servo that lifts the pen between strokes. The controller converts each point of the drawing into the two joint angles that place the pen there — a two-link inverse kinematics calculation — and steps through the points in order.
How many servos does a drawing robot arm need?
Three is the minimum: two for the arm joints that position the pen in the plane, and one to lift and lower the pen. The well-known PlotClock design on Thingiverse works exactly this way: one servo lifts the pen and two move the arm. Stepper-driven drawing arms use two steppers for the arm plus a small servo for the pen.
Why are the lines from my drawing arm wobbly?
Usually one of three things: servo resolution (hobby servos move in steps of roughly a degree, which the arm's length turns into visible jumps), gear backlash letting the pen wander when direction changes, or links long enough to flex. Shorter links, metal-gear servos, drawing slowly, and adding many small intermediate points along each line all make strokes noticeably cleaner.
How do I turn an image into something the robot can draw?
Convert it to vector paths first — trace a bitmap in Inkscape, or start from an SVG — then turn those paths into a list of points or G-code. Tools such as vpype can simplify, sort and reorder SVG paths for plotting so the pen travels less between strokes. Your arm's code then reads the points and converts each one to joint angles.