SVG image plotter

Vector graphics plotter

 UPDATE:

The code has been significantly changed to be compatible with Processing 2.1.1. Also, some functionality has been added. It can now support "translate" transformations and "rect" paths. "polygon" paths and "matrix" transformations are not yet implemented, but might be eventually. The hardware has been slightly modified: better pen holder, removed unnecessary resistors

It was a golden day, that day I finally got up the courage to click the "add to cart" button, electronically plucking a little arduino off a hook and placing it in my empty cart. My first microcontroller needed a first project: to get some stepper motors moving on the skeleton of a long dead printer. Here follows the tale of that adventure.

First, I'll show you the result for motivation.

 Junk (the hardware):

• Olde Epson printer: frame, two stepper motors, motor driver circuitry
• CD player: The laser head moving mechanism
• Desktop compy PSU as a 5V power supply
• One H-bridge - SN754410NE 
• Some resistors
• Bits of wire and a small breadboard
• Arduino uno, computer and pen

The software:

• On the computer: Reads an SVG file(a common vector graphics file) and turns the path data into a series of coordinates. Then it sends the coordinates via USB to an arduino.
• On the arduino: Receives coordinate data from USB and tells the motors to move.

 Details:
 Starting from the printer side, here you can see the frame, pen moving mechanism and motor driver board.

 The blue thing is thin plastic to provide backing support for paper. The frame has been stripped to the minimum amount of parts. It has a stepper motor to move the print head left and right, and one to feed paper back and forth. The thing attached to the print head came out of a CD player. It has a DC motor(not a stepper) that was used to move the laser. It now moves a pen up and down. This motor has so much gearing that it can move things slowly with a large amount of torque, and it holds its position well without any braking. The rectangular bit of metal is attached to the print head with a few screws and a bit of square aluminum tube.

Moving on to the driver board, here you can see half of the main circuit board from the printer:

Yes, I simply snapped the board in half. Why? I didn't want any of the other stuff on the board interfering. On the component side(right picture) you can see those two beautiful stepper motor driver ICs along with diodes for each wire and a power capacitor. Those wires go to the motors.

On the other side(left picture) you can see a mess of wires that is the splayed end of a printer(parallel) cable. Notice that most of them are simply connected to ground. These were intended to connect to ground in the actual printer. Who knows why they bothered to put so many in the cable. The parallel port has 25 pins, but there were 30-something wires. Anyway, 8 wires are carefully soldered to pins on the ICs. See the schematic below for details. You can also see a variety of surface mount resistors and capacitors. Most of these are used by the ICs. The thick red wires go to the 5V power supply(not the arduino power supply!)
  Tutorial tip     

• You probably won't have the same printer as I, but any old printer will have stepper motors. There are two main types: unipolar and bipolar. A quick google search will provide many good descriptions. If you get unipolar, they are way easy to use and you won't need such complicated circuitry. If you get bipolar, don't cry, bipolar have better torque and accuracy, but you'll either need a stepper motor driver(such as you may find on the printer's circuit board) or some H-bridges. Again, there are many good pages already made on the subject, so google it.

 Here is the schematic taken out of the printer's service manual(click to enlarge):

If you are trying to do this, just look for keywords like "phase" and "enable". These are the pins you need. Everything else is just details. By the way, each enable turns on one of the two coils in the motor. Phase determines the direction of current flow in the coil. Google "bipolar stepper motor".

Moving along to the other end of the cable, we arrive at the little breadboard:

 There are 8 wires going from arduino pins 6-13 to the enable and phase pins on the motor drivers. The stuff on the top is an H-bridge to drive the pen's up/down motor. Just ignore the other larger chip. It's not related. Arduino pins 4 and 5 control that. This leaves me with two empty pins on that side, which are the interrupt pins and could be used to add limit switches. I didn't add any because, well, I'm optimistic. Remember, you can't, or at least shouldn't, use pins 0 and 1 if you are using the serial port. They are the rx/tx pins.

Here is the schematic for the H-bridge:

One of the arduino pins should be high and the other low. Inverting highs and lows on both will reverse the direction of the motor. Depending on your h-bridge, it may be dangerous to set both the same way at the same time. Be careful. 

OK, now you have seen all of the hardware. Let's look at software.

The software consists of two programs. One runs on the computer. The other runs on the arduino. The details of the code require a lot more knowledge of SVG file structure, math and programming than I could reasonably include here, so I will just provide an outline and let you figure out the details from the code.

On the computer:

An SVG file contains graphical information encoded into basic mathematical structures such as lines, elliptical curves and Bezier curves, the parameters of which are written in an XML text file. This program scans the file and picks out the path data. It ignores everything else. That means that you will only get lines, which is exactly what a pen is capable of drawing. It then interpolates the curves and generates a list of coordinates which are sequential points along the path. Think of it as a connect-the-dot picture. The precision with which it interpolates curves can be set as a parameter. Also, everything is scaled to a size in mm which is also a parameter. This list of coordinates is then sent via USB to the arduino.

On the arduino:

The coordinates are received by the arduino, which then tells the motors to draw a straight line to the next point. The arduino needs to know the details of the mechanical setup so that it can actually draw straight lines between points. This is accomplished with a little math rather than simple motor speed.

Here are the two parts of code (GNU GPL copyrighted):
SVGReader.pde (computer part) - see processing.org for processing language info
SVGPlotter.ino (arduino part)  - written for the arduino ide

///////////////////////////////
 OLD FILES: these are no longer compatible with Processing
SVGReader.pde (Depreciated)
SVGPlotter.ino (Depreciated)
///////////////////////////////