Thursday, 5 January 2017

I bought a giant plotter.

I bought a new toy. Specifically - I bought an insanely massive and very heavy, A1-sized, Roland DPX-3300 XY plotter from the 1980's. It is now sitting in my office taking up all the space until I sort some studio space out, and I'm very happy with it.

Anyway, I have big plans (creatively and physically) for it, and I've already discovered a few neat things, so I thought I'd jam a post together with some photos and musings.

The most important part for now is... it works:

So first question: why.

Well obviously, the main answer is: given the chance, why would you not want a giant robot monster that can draw stuff for you? And then I guess the other part is that I've been having a lot of fun with prints and experimental mark-making in a few different formats, and wanted to use something that would let me translate some of my digital and algorithmic artwork into new forms and outputs. Initially I have a specific project in mind, but in a general sense I wanted more flexible tooling that would let me get weird with computers and strange materials.

Initially I was looking at vertical XY plotters (like Polargraph and similar). I find these devices quite appealing to use and watch, but they're incredibly slow and not very flexible. During my search, I spoke to both the Polargraph guys, and also longtime creative coding hero Seb Lee-Delisle. It was in fact Seb who suggested this route, and pinged me a link to the plotter that had just gone up on eBay.

I quickly realised that this sort of machine held a lot more technical and artistic potential, and the one Seb pointed me at on eBay was about a 90 minute drive away in Derby. It was listed at £250, so I jammed BUY IT NOW and snapped it up. I've made a gentleman's agreement with Seb that should I tire of making amazing things with this machine, he gets first refusal on it. (Seb, if you're reading, thankyou for the heads-up on this. You're a gent).

(I'd also like to just take a minute to say thank you to Danny for helping me get this thing back home! My little Yaris wasn't going to cut it. Danny, you da real MVP).

I wasn't sure if £250 was a good price for a giant machine from the 1980's, but there were videos of it working, and it felt right, so I pulled the trigger on the same day. For comparison, the guys down at the Bristol hackspace (who I've also had loads of help from, so thankyou!) rescued a rain-damaged one from a skip and restored it, and have been using it to great effect at Maker Faires and similar. To have one that was already in perfect working condition seemed too good to be true. There's some great info and images of their restoration here:

Contrary to how it looked on the listing, the machine is stupidly massive - obviously my logical brain knew this really, given that it's for A1, but until you see it in person it doesn't really click. It's also so heavy it needs two people to lift it. Here's a photo of it, with the obligatory banana for scale:

Luckily it's not staying in my house. There's potentially some studio space arrangements happening via the FAULT LINES program I'm on, but I'm not sure to what degree yet until everything starts happening in a couple of weeks. If this isn't suitable, then there are a few places in the city that are very keen to give it a home too. Whatever happens, it's certainly only here as a temporary measure... but I still couldn't resist firing the sucker up.

I saw it working on the listing video, and also quickly in person when I picked it up, but the main thing I wanted to do was make sure I can send artwork to it. It also does a handy test plot even when not connected, which was the first thing I did, with it laying flat (if you power it up while holding a specific button down, it launches into a full A1 demo plot):

I particularly like the digital XY position readouts, not only are they very visual appealing, but they're really useful too - having something to compare numbers to in the code is mega useful:

Here's the final test plot pattern, the fonts are built into the machine (there are a few) and they're all pleasingly 80's and outliney. It's unlikely I'll be using them, I think they're more for drafting purposes, but they're cool:

The next step was to connect the thing up and fire artwork to it.

This plotter, like most of them, uses HGPL commands. They're pretty obvious and succinct (pen up/down, movement, beziers, pen select), and you can go about things in two ways: either sending individual commands to the machine, or sending a full HGPL file for print.

I'm interested in both these approaches - for some standard printing purposes obviously I just want to convert some artwork and sling it down the pipe to the plotter. I also want to get weird with it, and have the plotter directly controllable from sound, movement, or who knows what else - for this I'll be issuing HGPL commands directly.

In both cases it's as simple as hooking up the thing via serial/parallel and throwing data at it. There's a fairly standard go-to Python library called Chiplotle (notice the spelling, chi-PLOT-le? I love it when people make things and then give them pun names that are both hard to spell and confuse search engines. Blah). Chiplotle supposedly handles things like handshake and data passing, but only works with serial connections I think. I only have a parallel cable to hand, but this ended up being fine anyway, as I was able to find the device under Linux. Once you know where it is, it's as simple as copying a HGPL file to the location and the printer whizzes into action. Something like this is just a simple copy:

cp artwork.hpgl /dev/usb/lp1

I've not tried individual control commands yet, but I'm sure that'll work fine, it's doing the same basic action. I'm also tempted to look into Chiplotle in more detail, as I've an idea it might handle big files at the software side and pipe it to the machine in bits, and do resuming and controls and things. There must be more to it as it's so ubiquitous, I just need a serial cable.

Oh, and people are even sticking wireless modules into the mix too, which is ace:

To generate the HPGL file itself, I used Inkscape - handily, Inkscape outputs HGPL files natively, which was really useful. The only gotchas with it are that you need to ensure your artwork is all rendered as paths, rather than strokes - presumably this is part of how the printer does a best guess for where it should draw and in what order etc.

Inkscape also lets you set the origin point for the plot, which for this model is actually in the center of the page - I love the reasoning too, as discovered by the guys at Bristol in their post:

"Now it was clear that the bigger plotters place their (0,0) origin in the middle of the paper, not at the lower left as the smaller ones do. This is because the HPGL co-ordinates are bigger, and would get very close to 16-bit integer overflow. By using the negative half of the signed 16-bit range, overflow could be avoided. Remember that most of the old software for these machines was written in FORTRAN, which had no unsigned integer type. My modern C code used 32-bit integers to generate co-ordinates."

Alignment is a funny issue, although I'm able to get things scaling and printing correctly via Inkscape, actually placing the paper correctly on the machine has been hit and miss. Neither the machine not HGPL has any concept of paper sizing, it's just measurements, with the origin point at the centre. This means that there's no paper lineup points anywhere, it's just a big black rectangle. I've been making best guesses, but my ultimate aim is obviously to make quite precise prints for display, so I need to get some marks down of some kind.

I did a test print or two, here's one with some vector Algorave artwork. I also had the plotter stood vertically, which works perfectly well - the paper is held on via an electrostatic base, so this is a surprisingly solid way of working and of course takes up significantly less room.

The final piece of the puzzle is making the marks themselves. The plotter has eight pens, which are selected/picked as part of the print. This is really neat to watch. When I bought the machine, it came with a huge box of pens (about 100 or so) of which maybe a couple of dozen have any ink in. I split them into duds and working pens with a tough audition process:

My intention is to drill out some of the duds, so I can swap out the old shitty inks for nice new rollerball pens, Sharpies, and whatever else. I have huge plans for this stuff, and a strong desire to make marks with things that aren't pens - charcoal, chalk, crayons. This will require a bit more thinking, as obviously pressure needs to be applied as these materials wear down, but I'm sure a 3D printer and some application of logic will get around it.

As a quick test I made one with a biro, which works great apart from being too long, resulting in an unbroken line (which I actually find quite appealing to look at too, seeing the path the machine took):

And that's as far as I've got.

Of course, I have a million billion plans for this thing. First is to house it somewhere permanent, and pop the sucker open - there's presumably a few decade's worth of dust and wear, so it'll be good to clean it up a bit.

Following this I want to establish better tooling and more accurate lineup etc, so I can confidently make prints that are nicely aligned, and my pens/marks are working as perfectly as possible. And of course, on the software side I want a nice workflow, which might involve Chiplotle but also might end up being something I write myself - there are openFrameworks HGPL libs already, for example. Although really, Inkscape has taken me pretty far already, which is so useful.

I'm also going to throw this open to anyone who wants to play with it too - I'm as keen to see what others do with it as I am my own stuff. As ever, there's already a huge community of people using these things (check out #plottertwitter!) and I'm already picking up ideas and inspiration from this too. Aside from traditional prints, I'm also very excited about the prospect of using this thing as a live drawing device, controlled by sound or movement or who knows what. The possibilities are endless.

Consider this an open invitation: if this sort of thing is tickling your fancy (and if it doesn't, you are dead inside) then ping me via the usual channels and come have a play with it. Or throw me your zany ideas and we'll make cool stuff.

Lots more to come on this, but for now: plot all the things.


  1. What do some of the HPGL data streams sound like?

  2. Would be really cool to hook it up to a webcam and get it to draw a digitised (Solargraph)[] in real time. I suspect leaving the machine powered up and drawing for 6 months is a little too much to ask though ;)