Introduction: EtchABot: a Versatile CNC Etch a Sketch

About: Mom, maker, tinkerer, technophile.

The EtchABot uses an Arduino to turn an Etch A Sketch into a self-erasing CNC (Computer Numerical Control) drawing machine. It's far from the first motorized Etch A Sketch on the internet. Other projects have used stepper motors to turn Etch A Sketches into simple CNC machines that can draw portraits, patterns and even tell digital time.

What’s original about the EtchABot is its easy-to-build frame and the Arduino library provided to control it. There is no glue, cutting, drilling or soldering required. Anyone with a basic knowledge of breadboard wiring and Arduino programming can construct and run it. It's also very versatile. The example sketches allow you to run EtchABot with a variety of functions - as an analog clock, Spirograph, joystick controlled doodler and image replicating CNC drawing machine. Using the EtchABot Arduino library, you can program it with other functionality too.

I really do hope that people will be able to build and program their own EtchABots, which is why this Instructable has gotten so long and detailed (sorry!) I've gotten a lot of ideas from reading about other people's projects, so I hope that you'll find some inspiration, or at least something interesting to look at in this Instructable. Enjoy!

Adapted from my blog posts:

Step 1: Getting Started

You can build an EtchABot with either the pocket size (small) or the travel size (medium) Etch A Sketch. The only mechanical difference between the two versions is the size and scaling of the wooden frame. The pocket size frame is somewhat more stable and easier to rotate due to its lighter weight. Otherwise, the assembly instructions are identical. The image above also shows that you can personalize your EtchABot with 1" round Avery labels or by etching your name/logo on the wooden frame.

Once you pick a size, you can get the design files and code from I'm linking to GitHub rather than including the files because EtchABot is a work in progress, and that's where you'll find the most up-to-date files.

This is a long Instructable, so here is a table of contents if you'd like to skip to a topic:

  1. Components: Step 2
  2. Assembly: Steps 3 - 15
  3. Arduino library: Step 17
  4. Analog clock software: Step 22
  5. Spirograph software: Step 23
  6. Joystick control software: Step 24
  7. Image software: Step 25

Step 2: Components

  1. Etch a Sketch, Pocket(shown) or Travel size x 1 [Ohio Art]

  2. 28BYJ-48 stepper motors x 3 [EBay]

  3. ULN2003 stepper motor drivers x 3 (these often come pre-packaged with the 28BYJ-48 stepper motors)

  4. Laser cut wooden parts from 1/8" MDF or similar wood. Be sure to cut the right size parts for the Etch A Sketch you are using (Pocket or Travel size). Design files at

  5. Screws and Nuts [McMaster-Carr]
    • M3 12mm Machine Screws x 10
    • M3 10mm Machine Screws x 16
    • M3 Hex Nuts x 26
    • M4 16mm Machine Screw x 1
    • M4 8mm Machine Screws x 6
    • M4 Hex Nuts x 7
  6. 5mm to 5mm Flexible shaft couplers x 2 [EBay] Get the kind that tightens with 4 set screws. You will need a 2mm allen key to tighten the set screws in the metal shaft couplers

  7. Arduino Uno x 1 [Arduino], and USB cable to connect it to your computer for programming

  8. Breadboard wires – Male to Female x 18 and Male to Male x 5 (approx) [EBay]. The 10 cm length look neater when they’re all wired up, but you can use any length

  9. 6V 1A power adapter x 1 [EBay]

  10. Barrel jack to breadboard connector x 1 [Sparkfun]

  11. Breadboard compatible slide switch x 1 [Sparkfun] (optional, but it makes turning the EtchABot on/off much easier than disconnecting the power cable each time)

  12. Optional components
    DS3231 Real Time Clock x 1 [EBay] with LIR2032 Button Cell Battery x 1[EBay] – These keep real time when you run the analog clock Arduino sketch.
    - Dual-Axis XY Joystick [EBay]- this will let you run the joystick controlled EtchABot Arduino sketch

Step 3: Attach Stepper Motors and M4 16mm Screw to Frame

Screw the motors into the front wooden panel and the right side support as shown in the pictures above using all 6 of the 8mm M4 screws. When screwing on the motors, the nuts go on the same side as the motor body and the screws go on the same side as the motor shaft. Screw the 16mm M4 screw into the left side support as shown.

Step 4: Attach Axle Hubs to the Sides

Align and stack two circular axle hubs on each side panel and attach them to the side panels of the body with the M3 12mm screws. The axle hubs with the circular center hole attach to the left side panel and the axle hubs with the flattened center hole attach to the right side panel, as shown in the images above.

Step 5: Join the Back, Sides and Bottom of the Body

Next connect the sides, back and bottom of the EtchABot body togeher. Slide the tabs on the back and bottom into the slots in the side panels. Hold them gently together while using 4 of the M3 12mm screws to secure the back and side panels to the body as shown above.

Step 6: Connect Shaft Couplers to the Etch a Sketch

First, remove the knobs from the Etch A Sketch. They can be pulled of with gentle force, or pried off with the edge of a butter knife. Then attach the shaft couplers to the Etch A Sketch shafts where the knobs were. There should only be a millimeter or two of clearance between the Etch A Sketch frame and the edge of the shaft coupler (see picture above). Tighten the set screws with the 2mm allen key until the shaft couplers are secure.

Step 7: Attach Shaft Couplers to the Stepper Motors

Slide the front panel containing the two 28BYJ-48 stepper motors towards the Etch A Sketch until the stepper motor shafts go in the holes of the shaft couplers. Slide the motor shafts into the couplers until only a millimeter or two of clearance exists between the motor body and the shaft coupler. Once they are in place, tighten the set screws securely with the 2mm allen key.

Step 8: Attach the Front Panel

Gently separate the side panels of the EtchABot body just until the front panel containing the stepper motors can fit with its tabs in the slots as shown. Use two 12mm M3 screws and nuts to secure the front panel in place.

Step 9: Add the Base

This is straightforward and involves no screws. Connect the two supports to the cross braces by sliding the vertical slits together, and stand them up. The motor shaft and screw should both be pointed inwards. Place the EtchABot body between the supports and slide the motor shaft into the flat-edged slot on the right side of the frame (it may take a little pressure to get it into the slot), and slide the M4 16mm screw through the circular slot on the left side of the frame.

Step 10: Connect Electronic Components to the Board

Attach ULN2003 stepper motor drivers and Arduino UNO to the board as shown above with the M3 10mm screws. One screw may not fit well in one of the Arduino holes. If so, just leave it off. Peel the backing off the bottom of the 170 tie-point breadboard and stick it to the base as shown above.

Step 11: Wire the Electrical Components

The complete electrical wiring is shown above. The next steps will give step-by-step instructions for hooking up the electrical connections.

Step 12: Connect ULN2003 Drivers to the Arduino

Connect the ULN2003 stepper motor drivers to the Arduino Uno using the 10 cm M-F breadboard cables with pin assignments as follows:

  • Horz Motor Driver Pin 4 -> Arduino Pin 2
  • Horz Motor Driver Pin 3 -> Arduino Pin 3
  • Horz Motor Driver Pin 2 -> Arduino Pin 4
  • Horz Motor Driver Pin 1 -> Arduino Pin 5
  • Vert Motor Driver Pin 4 -> Arduino Pin 6
  • Vert Motor Driver Pin 3 -> Arduino Pin 7
  • Vert Motor Driver Pin 2 -> Arduino Pin 8
  • Vert Motor Driver Pin 1 -> Arduino Pin 9
  • Erase Motor Driver Pin 4 -> Arduino Pin10
  • Erase Motor Driver Pin 3 -> Arduino Pin 11
  • Erase Motor Driver Pin 2 -> Arduino Pin 12
  • Erase Motor Driver Pin 1 -> Arduino Pin 13

Step 13: Connect Motors and Power Wires to ULN2003 Drivers

Next plug the 28BYJ-48 stepper motor connector cables into their ULN2003 motor drivers. After that, plug the female side of two female-to-male breadboard cables into each of the ULN2003 motor drivers as shown above.

Step 14: Connect Power to the Motors Through the Breadboard

Now wire the power connections on the 170 tie-point breadboard. Use the wiring diagram in step 11 for guidance. The power from the 6V 1A power adapter runs into the barrel jack connector on the mini breadboard and provides power for the three stepper motors. Do NOT run the power into the Arduino power jack – the motors require more current than should run through the Arduino. When you are programming the Arduino, it will receive power through the USB port. Arduino ground must be tied to power ground as in the diagram. Above is a picture of the wiring on an actual EtchABot.

Step 15: How to Power the Arduino WITHOUT a Computer

When running a sketch that doesn’t require a computer, you can power the Arduino from the power jack as well. This requires an additional connection from the positive power to the Arduino Vin pin. (see diagram above – the additional connection is in hot pink). Be sure that you don’t connect the computer to the Arduino with the USB cable while the additional power connection is in place. If you do the EtchABot may attempt to power the motors with power from the USB, which pulls too much current through the Arduino.

Step 16: The Source Code

Now that the EtchABot is assembled and wired it’s time to make it run! Download all source code from I’m new to Git/GitHub, so please let me know if you have any issues downloading.

Step 17: The EtchABot Arduino Library

The EtchABot library contains an EtchABot class with various functions to control the EtchABot. To run the examples I discuss, you must install the EtchABot library with your other Arduino libraries. The files in the EtchABot library: EtchABot.cpp, EtchABot.h and keywords.txt should be in a directory named "EtchABot" with the other Arduino libraries. See this article on installing Arduino libraries if you need help. Please note that you will also need to have the Arduino Stepper library installed as well, though I believe that it comes standard with the Arduino IDE installation.

The default pin assignments for the stepper motors in the EtchABot library correspond to the motors I used. If you are using your own stepper motors, you may find that your motors run backwards from mine. If this is the case, you will either have to change the stepper motor pin assignments in the EtchABot class from the defaults, or change the order of the pins the stepper motors connect to, in order to run the example code. When using the EtchABot library, you must specify the size of the Etch A Sketch you are using – either Pocket Size or Travel Size. To do this, look for the place in your code where the EtchABot object is created.

#include   //Must include <Stepper.h> any time we use EtchABot library
#include "EtchABot.h"

// Create an EtchABot instance - either POCKET_SIZE or TRAVEL_SIZE
EtchABot etch(POCKET_SIZE);

Step 18: The Arduino Example Sketches

Several Arduino sketches come with the EtchABot library. They are:

  • EtchABotAnalogClock – When used with a Real Time Clock connected to the Arduino, turns the EtchABot into an analog clock that erases and redraws the time every minute

  • EtchABotCalibrateBacklash – Draws a pattern with different values for the backlash parameters to determine the best values for a given Etch A Sketch

  • EtchABotDriver – Runs as firmware that takes serial input to give the EtchABot commands to perform functions like drawing lines, erasing the screen, and shutting motors off
  • EtchABotJoystickControl – When used with a small joystick connected to the Arduino, allows the user to control the motion of the stylus and the erasing with the joystick

  • EtchABotPatterns – Draws a parametric pattern (Spirograph or Lisajous functions, but you can easily add your own) for several minutes, then erases the pattern and starts again

Step 19: Checking Motor Wiring With the EtchABotDriver Sketch

If you are concerned about your motor wiring, it is best to check it before attempting to run any programs on the EtchABot. The simplest way to see if your motors are wired correctly is with the EtchABotDriver Arduino sketch which lets you type simple drawing commands into the Arduino IDE serial window.

For reference, the upper left corner of the Etch A Sketch is defined as (0,0) and the positive directions are down and right (see image). The total Etch A Sketch screen dimensions in units of stepper motor steps are: [6000, 4000] (pocket size) and [6500, 4600] (travel size).

Before starting, move the Etch A Sketch stylus to the middle of the screen. When the motors are powered off (all lights on the ULN2003 drivers are off) you can turn the shaft couplers by hand to move the EtchASketch stylus. You should not attempt to turn the shaft couplers when the motor drivers are powered on, as this might damage the motors.

Once the stylus is near the middle of the Etch A Sketch Screen, connect your Arduino to your computer, open up the Arduino IDE and download the EtchABotDriver sketch. After it has downloaded, open up the Serial Window and set the baud rate to 57600. You should see a message saying “#start up/OK“. Be sure the EtchABot is turned on (motors have power), and type the phrase “L 1000 1000;” into the serial window (exactly as shown without the quotes – the semicolon and spacing is important) and type a carriage return. This command tells the EtchABot to draw a line, in absolute coordinates from the current position, which is assumed to be (0,0) to (1000, 1000). If all is working correctly, you should see a short, diagonal line drawn downwards and to the right. If the line is pointing in any other directions, one or both of your horizontal/vertical stepper motors are wired incorrectly for the EtchABot library.

You can also perform a simple test of the Erase motor by typing “E;” into the Arduino IDE Serial Window. This causes the Erase motor to rotate the EtchASketch forwards then backwards. If the motor rotates backwards, then forwards, it is wired incorrectly for the EtchABot library.

To change the direction of a motor, you can either change the pin assignments in the code, or swap the two of the adjacent wires (NOT the two middle ones) that connect the ULN2003 driver to the Arduino until the motor moves in the correct direction.

Step 20: Backlash

Stepper motors are designed for precise movements, and the 28BYJ-48 motors in this project give 2048 steps per revolution when driven in 4-step mode. However, the limitation on drawing accuracy comes from the Etch A Sketch itself. There can be slippage in the stepper motors and backlash in the internal Etch A Sketch drawing mechanism. Running the motors at a slow and steady pace eliminates slippage, but the backlash due to slack in the EtchASketch drawing mechanism makes drawing repeatable patterns a challenge.

Taking backlash into account: If you move the drawing stylus forward 250 steps, then back 250 steps, the stylus will not end up where it started. Instead you need to move a little farther in the backwards direction to account for backlash. It's even more complicated than that, because if you move horizontally forwards and backwards the backlash will be different than if you go forward, then up, then backwards, and the effect can differ based on the length of the lines draw. Not only does the direction of drawing matter, but the magnitude of the backlash will differ for different Etch A Sketches. It is difficult to compensate for this inconsistency. The EtchABot class contains a set of horizontal and vertical backlash parameters that can be adjusted dynamically in the code. When the EtchABot drawing function detects that the direction of motion has changed, it attempts to compensate by adding a few extra steps in the new direction to take up the slack from the backlash. This method works reasonably well in certain circumstances, such as drawing horizontal and vertical lines, and not particularly well when drawing curved lines. The Spirograph sketch sets the backlash parameters to zero for this reason.

In the images above the same image has been drawn twice. The top image has been drawn with a backlash correction of [0,0] and the bottom image has been drawn with a backlash correction of [120,120] for comparison. You can see that in the images with backlash correction, lines join up better, and round edges are rounder, but you get "bumps" at the horizontal and vertical asymptotes of each curve where the horizontal or vertical stepper motor changes direction.

Step 21: Backlash Calibration

Before running the Arduino sketches that correct for backlash, it’s a good idea to calibrate the backlash correction values. The default values for backlash are wired in the library as 120 steps for both horizontal and vertical motors, but you can modify the code to set the backlash to any value.

To run the backlash calibration, download the EtchABotCalibration sketch to the Arduino, and run your Arduino IDE in serial monitor mode. You should see the Arduino serial window in the picture above. You will need to enter (1) whether you want to test horizontal or vertical backlash, (2) a starting value, and (3) the a value to increment the backlash by for each step. The sketch will test 8 different values for the backlash parameter, increasing the value by the specified increment with each step. The EtchABot will draw a pattern that looks like the one shown above. Where the horizontal lines overlap is the best value for the vertical backlash parameter. In this case, a value 120 is the best choice.

Run the program twice – once for horizontal, and once for vertical calibration. The results for vertical calibration are shown in the image above. The best backlash calibration value is the one where the lines completely overlap. Often this is with a value somewhere in the range of 100 to 140, but it does vary.

If you want to change the backlash values in one of the Arduino sketches, you can add a couple of lines to the code right after the EtchABot object is created. Look for the line in the code that says:

EtchABot etch(POCKET_SIZE);

and add two more lines after it to change the backlash settings:


Obviously, change the number 100 to whatever you want the backlash correction to be. The horizontal and vertical correction values can be different from each other.

Step 22: Analog Clock Mode

To turn your EtchABot into an analog clock, you will need a Real Time Clock (RTC) breakout board. I used a DS3231 RTC, and a LI2032 Coin Cell Battery to keep the correct time even when the Arduino is off.

Before doing anything else, you must set the correct time on the RTC. RTCs don’t adjust for Daylight Savings Time, since it differs by location, so if your RTC has been set more than 6 months ago, you will probably need to reset the time. This Instructable has easy to follow instructions to set the time.

Once the time is set, connect the RTC to the Arduino. I found the easiest way to do this is to use pins A2 and A3 for ground and 5V power respectively (by setting them to LOW and HIGH in the Arduino sketch), and SCA and SDL connect to A4 and A5 respectively. This allows you to plug the RTC board directly into the Arduino UNO. The extra pins on the RTC simply hang over the edge as seen in the picture above. If your RTC pins are ordered differently, you can also simply bend the extraneous pins out of the way. If your RTC Vcc and GND pins are backwards from mine, you must change the pin assignments the Arduino EtchABotAnalogClock sketch.

Setting up and running the code is easy. Simply download the EtchABotAnalogClock sketch to the EtchABot, making sure that you’ve correctly set the Etch A Sketch size to POCKET_SIZE or TRAVEL_SIZE in the code, and that your pin assignments correspond to your RTC board. Be sure the stylus is positioned in the upper left corner of the Etch A Sketch before turning on power to the motors.

The analog clock sketch requires no computer connection to run, so you can disconnect the USB cable from the UNO, and run a jumper from the breadboard positive power (+6V) to Arduino Vin, as shown by the pink connection in the wiring diagram shown above. (note that this diagram doesn't show the Real Time Clock)

Step 23: Spirograph Mode

To draw parametric patterns with the EtchABot, download the EtchABotPatterns sketch to the Arduino. By default, the sketch displays a changing Spirograph pattern for several minutes, then erases it and starts again. If you read the sketch, you will see several parameters that you can customize:

#include <Stepper.h> // Must include this if we will use "EtchABot.h"<br>#include "EtchABot.h"
#define DEGREES_TO_RADIANS 0.0174533
#define RESET_MINUTES  4    // # of minutes after which we reset the pattern
// Pick one of the options below to define the type of curve
//#define LISAJOUS

Simply change the RESET_MINUTES parameter to change how long the pattern will draw before being erased. Uncommenting either the SPIROGRAPH or LISAJOUS define statement will determine the kind of pattern drawn. The Lissajous pattern takes longer to draw than the Spirograph, so you might want to give it a few extra minutes to draw if you choose it.

Like the analog clock mode, the computer does not need to be connected for the sketch to run, so you can disconnect the computer from the Arduino USB, and wire up Arduino power from the Breadboard to Vin as shown in the previous step.

Be sure the stylus is in the upper left corner of the Etch A Sketch screen, turn on the power, and voila! A self-erasing Spirograph!

Step 24: Joystick Control Mode

You can use a thumb joystick to control the drawing and erasing functions of the EtchABot. The EtchABot kit comes with one, or you can provide your own. Wiring it up is easy. The joystick usually has 5 pins: GND, VCC, Vx, Vy, SW (SW = switch). You can plug those directly into the row of analog pins as shown, so that the wiring is: GND → A5, Vcc → A4, Vx → A3, Vy → A2, SW →A1

Next download the EtchABotJoystickControl sketch to the Arduino. You can then unplug the computer USB cable, and wire up power from the breadboard to Arduino Vin to run without a computer connection. Be sure the stylus is in the upper left corner before turning on the EtchABot. Turn it on and move the joystick to direct the drawing on the Etch A Sketch. Press down on the joystick to erase the EtchABot.

Step 25: Installing the EtchABot Image Software

In image drawing mode, EtchABot receives instructions through the Arduino serial port. When connected to a computer running software that converts images to a series of drawing commands, EtchABot can reproduce many vector (SVG) or raster images, as we will see.

First you must download the EtchABotDriver sketch to the Arduino. This is the firmware that will allow the EtchABot to receive commands over the serial port.

The software which translates the images into drawing commands is written with a Node.js server and a JavaScript client running in a web browser. I tried to port the code into Electron to make it a standalone desktop app, but was unable to get Electron to play nicely with the Node serialport package. The image software is still a work in progress, so look for future updates on GitHub.

Before installing the software, if you don't have Node already installed, you will need to download and install Node.js from the Node.js downloads page. When Node installs, it comes with a package manager called "npm" which simplifies installing the needed dependencies.

After installing Node, open up a command line prompt (e.g. cmd or PowerShell in Windows, Terminal on a Mac, bash in Linux) and navigate to the EtchABot directory named "nodefiles". Inside this directory is a file named "package.json". Node will use this file to install all necessary files to run the EtchABot program.
From inside the "nodefiles" directory type:

npm install

and npm will install the necessary dependencies into a folder named "node_modules".

Step 26: Running the Node Server

Now, to start the Node server running, you must connect your Arduino (with the EtchABotDriver.ino sketch already installed) to a serial port. Be sure you know the name of the serial port (one way is to open the Arduino IDE and look at Tools→Port). Then, from inside the "nodefiles" directory type "npm start -- portname" . E.g. if your serial port is COM5, type:

npm start -- COM5

A web server will start running on port 8000, and if all goes well, you should see output like that in the image above. If you would rather use a different server port, you can change that in the file "EtchABot/nodefiles/server/server.js". Just search for the number 8000 and change it to something different.

Step 27: Start the Client Window

Now open a browser window and type "localhost: 8000" as the URL. You should see a web page that looks something like the first image above (minus the red arrows and text).

The outlined box at the right side of the screen (second red arrow above) shows information from the EtchABot. When the client starts up, it polls the EtchABot asking for its size (Pocket or Travel) and its backlash settings. If the settings are not showing correctly, try reloading the page. You can change the current backlash settings by clicking the “Set backlash” button. This change won’t be permanent – the backlash correction will reset to the default every time you restart the Arduino. If you want to change the default backlash settings permanently, you can add a couple of lines to the EtchABotDriver.ino sketch, as described in step 21 (Backlash Calibration), and upload it to the Arduino.

In the EtchABot client window, the dropdown menu (first red arrow above) lets you select whether the program runs in Free Draw mode (user draws the input) or in Image mode which allows you to upload a vector or raster image.

Step 28: Free Draw Mode

Free Draw mode is pretty straightforward. Holding down the left mouse button for curves, or clicking on points to make lines, use the mouse to draw a pattern in the large box. When done, click the “Image to Data” button to convert the image into a series of drawing commands. Then click “Send to Etch A Sketch” to start the drawing. EtchABot will erase itself, then reproduce the drawing in the Etch A Sketch. EtchABot will always return the cursor to the origin (upper left corner) after finishing, so the final Etch A Sketch drawing will show an additional line to the origin.

Step 29: Image Mode - Vector Images

Vector images look better and draw far more quickly with the Etch A Sketch drawing mechanism than raster images. EtchABot can take SVG (Scalable Vector Graphics) image files if they are formatted in a certain way. They must consist of only paths that are not grouped. Additionally, objects to be drawn should have stroke (outline), but no fill. If you have an existing SVG, the easiest way to put it into the right form is to use a vector file editing program like Inkscape (freeware), followed by a program to remove extra elements from the SVG, like SVG Cleaner.

Some SVG files may not be adaptable to EtchABot. For example, if the SVG has hidden lines, behind overlapping shapes, these lines will become visible when the fill is removed. Also, since the EtchABot can’t lift the stylus, it will draw lines between the various paths in the picture. If the paths are not ordered well, or are far apart, you will end up with lots of lines criss-crossing your picture. See above for examples:

  • The first Mona Lisa SVG (color) has fill which covers hidden lines.
  • Removing the fill from the Mona Lisa SVG paths reveals hidden lines that were previously covered (2nd Mona Lisa image)
  • When rendered by EtchABot, not only do the hidden lines show, but additional lines are generated as the stylus moves between paths (3rd Mona Lisa image)

Before drawing an SVG with EtchABot, here are some basic steps to prepare it:

  1. Open the SVG in Inkscape. Select the whole image, and select “Object→Fill and Stroke” from the menubar. In the dialog box that opens, first click on the “fill”tab and click the “x” to remove all fill from the SVG.
  2. Then select the “Stroke paint” tab in the same dialog box. Select “Flat color”, which is the first square next to the “x”. Set the color RGBA values to “0 0 0 255” for opaque black.
  3. Next select the “Stroke style” tab in the same dialog box. Set the stroke width to 1 pixel. Then close the Fill and Stroke dialog box.
  4. Be sure the entire image is still selected, then choose “Object→Ungroup” from the menubar.
  5. While the entire image is still selected, choose “Path→Object to Path” from the menubar.
  6. If you would like to remove excess white space from , or add padding to the edges of the SVG, select “File→Document Properties” from the menubar. In the Document Properties dialog box, click “Resize page to content”. You can assign left, right, top and bottom margins around the image here. I usually choose margins of about 5% of the image size. Once you’ve selected margin values, click the “Resize page to drawing or selection” button.
  7. Save the image. The default format will be an SVG file.

Once you are done with Inkscape, you can streamline the SVG with SVG Cleaner or SVGO to get rid of unnecessary text that may confuse the EtchABot SVG parser. I won't go into details of how to do this, but the SVGO link contains a lot of explanation on how to use it.

Now that the SVG is ready, be sure the EtchABot software is in Image mode, click the "Load Image" button, and upload the SVG file. Select the "Image to Data" button. If the SVG is complicated, this may take a while - I mean a really, really long while, like a minute or two. I intend to put a progress bar into the program while the SVG is getting converted to coordinates, but haven't had a chance yet.

When it is done converting the SVG to coordinates, the EtchABot software will draw the SVG as it appears, but with additional lines connecting the different paths - as it will appear on the Etch A Sketch. Be sure the EtchABot motors have power (the switch is on), and select "Send to Etch A Sketch" when you are ready to start drawing. The EtchABot will first erase, then begin drawing the SVG file. The stylus will return to the origin when the drawing is finished.

Step 30: Image Mode - Raster Images

An Etch A Sketch is much better suited to draw vector images than raster images, however the EtchABot software does have the ability to render raster images by shading different parts of the Etch A Sketch with different density of lines. EtchABot converts a raster image to a usable format by scaling down the resolution to no more than 48 pixels on a side and converting the image to gray scale. When rendering a raster image, Etch A Bot runs the stylus back and forth across the Etch A Sketch screen, creating vertical jitters at each dark pixel. The darker the pixel, the larger and denser the jitters are. EtchABot can only really render about 6 visible shades of gray at this resolution. Images that work best consist of simple, large shapes with sharp contrasts. Any fine detail will be lost.

Because many tiny vertical lines are used to construct the image, it is important to use good values for the backlash calibration. See Step 21 to calibrate backlash for your Etch A Sketch.

To draw a raster image with EtchABot, make sure the EtchABot software is in Image mode. Click “Load Image”, and pick a raster image to load. Select the “Image to Data” button, and the image will be transformed in to low resolution gray scale. If the image isn’t clear on the screen, then it will look even worse on the Etch A Sketch. The best raster images for EtchABot are simple and high contrast.

When you are ready to draw the image, select the “Send to Etch A Sketch” button, and the EtchABot will erase itself, then start to draw the image. It scans back and forth along the screen drawing one pixel at a time. Depending on the color of the pixel, it will have a number of vertical “jitters”. The darker the pixel, the more jitters it will have and the taller the jitters will be. Because of this, darker images will take longer to draw than lighter ones. Raster images take a long while to draw in any case. The image above took over an hour.

Step 31: Whew!!!

Wow, this has been a long Instructable to write. I hope you enjoy reading it, and I hope some of you decide to build your own EtchABot. If you do, please let me know how it goes!

Tech Contest

Participated in the
Tech Contest

Robotics Contest

Participated in the
Robotics Contest