Drawbot is a machine that draws on a whiteboard.

horizontal car, front view

Having grown tired of drawing on whiteboards manually, Greg and I decided to design and build a two-axis whiteboard plotter.

The design files for the laser-cut parts, the code for the Arduino firmware, and the code for the front-end interface is available on Github. More photos are on Flickr. .

Below are notes on the process, starting with the first prototype.

Our main goals were really to have fun and learn. But we had some other, informal goals.

  • Experiment with laser-cut construction, partly because I had access to a laser cutter through Parsons and mostly because laser cutting is great.
  • Use parts that are easily sourced and fairly low-cost, in case others want to build one too. The total for parts is around $225.
  • Use electronics and parts that can be easily sourced from retailers like Adafruit and Sparkfun.
  • Stick with a two-axis x/y design, instead of something like this or this.
  • Design something to draw large enough to fill most of one of the rolling whiteboards at our office (about 6" by 4"), and that could conceivably scale much larger.
  • Build front-end software that could read vector files and control the Drawbot
  • Document the process, in case others might find it interesting.
horizontal car, rear view.
horizontal car, rear view
horizontal car, front view
bottom idler
3D printed pen mount
bot drawing by Audrey Yeo
bot drawing by Vanshika Swaika

Prototype One

For our first prototype, we used a 10-24 lead screw for the horizontal and vertical carriages. The top of the whiteboard served as the rail for the horizontal carriage. This worked somewhat, but the carraige rocked back and forth. Worse, we didn't have a vertical rail at all. Instead the marker rode only on the threaded rod, and pushed against the whiteboard to keep from rotating. Between a slight bend in the threaded rod and the weak heatshrink-tube connection to the motor, the vertical car wobbled, rocked, and slid like crazy. This was improved somewhat by rigging a yardstick as a stabalizing vertical rail.

The laser cut peices for this prototype were much more complicated than in later designs, using drawn t-slot joints (instructable).

We used an Arduino with the Adafruit Motorshield v1.2 to drive the motors. At this point Drawings were hardcoded on the Arduino.

For a first prototype, we were pretty happy with how well it actually drew. Given the rickety carraiges, its kind of suprising it drew at all.

Greg Schomburg peeks over the top of the white board.
The first prototype used a threaded-rod screw-drive for the vertical carriage.<br/>A very slow, wobbly start.
The motor mount for the horizontal screw-drive. We moved to much simpler designs in later revisions.
First prototype for the horizontal carriage: another complicated box pushed along the top of the board by a screw-drive.
Greg attaching the horizontal car.
First prototype drawings. "Hello World" in hard-coded moves on the Arduino, no diagonals.

Prototype Two

The two largest problems with the first prototype were rigidity and speed. The leadscrew drew at a crazy high resolution of 4800 steps per inch, but a rate of about 30 seconds per inch. We abandoned the leadscrew for a rack and pinion system for both the horizontal and vertical car. This brought the resolution down to about 100 steps per inch, and the speed up to about one inch per second.To improve rigidity, the horizontal carriage rolls on bearings along an OpenBeam rail.

We moved the electronics to the horizontal car, and dramatically simplified the laser-cut construction. The stepper motor drives a gear along an laser-cut acrylic gear-track attached to the back of the open beam. The laser-cut gear is simply presure fit to stepper's D-shaft, this has been surprisingly reliable.

The vertical carriage rides on two pan-head M3 screws slotted into the OpenBeam. The screws are adjusted so the carriage can slide but doesn't wobble too much. We tried a small, light stepper first, and then a more powerful but heaveir one. The steppers partially, but struggled moving up and occassionally stalled and missed steps. WD-40 helped quite a bit but vertical motion was still not reliable enough.

The first prototype couldn't lift the pen at all. For the second prototype, mounted the pen to a micro-servo.

For this round we started building the front-end control software with Processing. The version had no GUI, but was able to send a series of hand coded instructions to the Arduino, or to parse an .svg using the geomerative library.

Greg Schomburg and I working on the drawbot
Horizontal carriage designed to ride on an Openbeam rail.
Openbeam aluminum extrusions and some laser-cut acrylic gears.
Rack and pinion vertical carriage design.
Test drawing using poster design by Piotr Szyhalski
The second prototype of the Drawbot. Moving the electronics to the carraige simplified cable management.
Horizontal carriage designed to ride on an Openbeam rail.
Second prototype test drawings.

Prototype Three

To improve the reliablity of the vertical motion, we switched the rack and pinion drive system on the vertical carriage with a timing belt. This reduced the weight of the car, and let us move the vertical stepper onto the horizontal car. The vertical car now travels in the slots of two OpenBeam extrusions. The servo is mounted in an assembly of stacked acrylic.

This version still uses a rack and pinion for the horizontal drive. The car is a little longer to leave room for the dual vertical beams and vertical stepper.

This version uses a 3D-printed pen-mount made with a Printrbot Simple.

With this revision, the hardware is starting to work pretty well, and we are beginning to focus on the software. The software now has a GUI that allows you to load and view an .svg file and preview the generated instructions that will be sent to the Arduino firmware. The software also plans accelerations to slow the motion around tight corners. Without accelration, the lines become wavy due to springyness in the the structure.

Type tests
Tests at different speeds and acceleration settings
A photo of Greg's face, auto-traced in Adobe Illustrator and plotted with the Drawbot
Close up of drawing made by the thrid prototype Drawbot using a finepoint wet-erase marker.
Third prototype Drawbot tests
The vertical car uses stacked construction, and a 3D-Printed marker mount.

Prototype Four

Directly attaching the pen to the micro-servo works pretty well, but the movement control is a little coarse. The pen lowers and lifts quickly and requires carefull setup. For this prototype we tried moving the micro-servo to the bottom of the vertical arm and using a cam to lift the whole arm away from the board. The pen was was mounted solidly to the vertical car.

The cam translates a wider servo motion into a smaller movement of the arm and the pen moves straight back and forth. This did help with coarse movement and the stray marks, but made setup much more difficult and touchy. This approach also involved twisting the horizontal car on its tracks, which just doesn't feel right. We decided the micro-servo pen mount worked better on ballance.

Using a servo driven cam on the bottom of the vertical arm.
With this design the car didn't need a servo, because the whole arm was lifted.
The cam version's vertical car with a marker installed.

The Software

To drive the Drawbot, Greg and I built an application in Processing. This application can load .svg files, turn them into a series of short commands, and pass the commands to the Drawbot.

The first versions of this software drew the .svg shapes in the order they were found in the file. Unfortunately, unless the files were properly arranged this would lead the the Drawbot spending most of its time with the pen up, traveling across the board to make a small mark. This version of the software reorders the paths to reduce travel times.

The software also looks for sharp turns in the paths, which lead to quick accelerations and shakey lines. The software reduces speeds around such corners, and speeds things up on straightaways.

Two libraries were of great help: Geomerative to load the .svgs, and ControlP5 for the interface.