DRBO – A new drawbot kit

The best thing about being involved in a project like Polargraph, is that you meet like-minded people.  Stuart Childs is one of these people, and a good guy to know.  He is one of the guys behind FriiSpray (which is another art/tech crossover project), amongst other things.  He has put together a very neat new drawbot kit called the DRBO.  It comes complete with arduino uno and motorshield, motors and all the bits you need, and is made of fragrant lasercut mdf.  I got a kit of the hardware bits off him to try out.

As you see, it is adorable when small, but the most best thing about it is that the top bit, the drawing surface bit is pretty sacrificial, if you unbolt it, then you’ve got a good little unit that contains the motors, bobbins and microcontroller, and all you need is a couple of nails banged into a wall to hook the threads over, and you’ve got a machine as big as you want. The threads can just run down to the DRBO on the floor.  No messing about with long wires or some such.

Now, when I’ve tried such shenanigans in the past, it’s never been quite as straightforward as that, but in principle at least, this is very handy.  There’s a very good case for keeping the motors close to the drivers, and it’s so much neater if nothing else.

The build is easy and it’s an example of good design for lasercutting.  It’s all push-out and bolt-together, well-labelled, and there’s even a little circle of sandpaper stuck on to take off the burrs, and a couple of wrenches that have enough life in them to tighten up all the nuts and bolts that you might want more than finger-tight.  That’s a really nice touch.  My favourite bit is that there are counter-sunk bolts at certain points on the surface, and Stuart supplies these dinky little magnetic buttons to hold the paper on!  Brilliant!

The box for the microcontroller is big enough to fit an arduino mega in it, for those who mate megas with adafruit shields.

I did take other pics, but none of them are quite as good as the ones on the DRBO site.  It’s also dead cheap, considering this is basically a full arduino+stepper motors dev kit, PSU, microcontroller, motorshield, motors, servo, fitments, the lot.

Norwegian pixel

So this is the real star of v1.2: The norwegian pixel.

  1. Save your source image as a greyscale PBM or PGM file, and put it on the SD card. Note that GIMP saves PBM files as 2 colour dithered files, so you need to export as PGM to get it to work there.  Photoshop just saves in whatever format the image happens to be in, so make sure you convert to grayscale (not RGB or indexed) before saving.
  2. Put the SD card in the PolargraphSD and turn it on.
  3. Open the controller and drag a selection box where you want to draw your picture.  For one reason or another, you do need to have an image loaded before you’re allowed to drag a selection area.  I just noticed that.  But the image you load is nothing to do with what you’re drawing.
  4. On the roving tab, click set roving area.  This tells the machine where you want it to start.
  5. Click draw norwegian… and enter the filename of your image file.
    Click trace outline and the machine will quickly draw an outline of where the image will be.  The image will be scaled so that it is the width of the rove area, regardless of how tall that works as being.  So really the height of the rove area is irrelevant.
  6. Choose the amplitude (row width) and the wavelength, and hit submit to send the command off to the machine.
  7. Wait many hours.

I haven’t done an awful lot of testing of this, but the initial results are beautiful.  

HOWEVER, I have noticed one issue – there are regularly spaced breaks in each row, some more obvious than others.  This is because of the way the beaded cord slips on the sprockets, and it’s a problem I actually expected to see before now.  The issue is that the beaded cord is not manufactured to very close tolerances, so the sprockets are rarely a perfect size.  It means that each beads-worth of rotation, there’s a little slip while the beads pull taut into the teeth.

There isn’t really a solution as far as I can see, as long as there’s even a mismatch between the circumference of the sprocket and the length of a piece of cord with the same number of beads, there’ll always be a little period where it falls forward.

Note that I think it’s only a problem for machines with beaded cords – if you use reels of thread and smooth bobbins, you’ll be fine.

–EDIT I goofed a bit with the various firmwares, and half the stuff didn’t work. I’m a bit puzzled how I didn’t notice, but there you go. Anyway, I’ve fixed a bunch of stuff, so if you had problems with the newest stuff, give it another shot.

Polargraph v1.2: Vector sprites guide.

Two exciting new features for PolargraphSD.  Both of them rely on the new roving area facility.   This is essentially nothing more than a way of specifying a drawing “live” area, and telling the machine.  Previously the machine has had very little concept of state, and (more-or-less) just did what it’s told.  Now, by setting a rove area, we can tell it to limit its behaviour to just that area.

Both of these features are very GOOD ones.

How to rove.

Most of the roving functions are hidden away on the roving tab, but it shares buttons with input.  Define a area on-screen by dragging a selection area, or selecting the frame.  Now just press send roving area and a new command is sent off that sets this in the machine’s live memory.  This area is volatile, so if you reset, you’ll need to resend.

Vector sprites.

A vector sprite is nothing more than a small vector design, but instead of existing in the coordinates system of the machine, it has its own coordinates system.  So when I have made up a font with each letter being one sprite, each letter has 0,0 at the bottom-left point.  Capital letters are 1.0 high, and around 0.4 wide.  What unit these values are measurements of is irrelevant, because the machine can now scale them to any size, and  draw them anywhere, and rotate them to the four cardinal native polargraph directions.

Vector sprites will be able to be lots of things in the future, but the first application is writing text.

  1. Choose your rove area by selecting an area and clicking send roving area.
  2. Choose whereabouts in the rove area you want the text to start by clicking start text at point and clicking somewhere in your rove area.  The gondola will move to that point on the machine and wait.
  3. Click render writing to bring up the writing dialog:
    Type in your text or load it from a text file using the button. For now, it can only draw in a south-east direction.
  4. Notice that there’s a file prefix here.  This tells the machine to find the sprite font files on the SD card in a subdirectory called sprite, and that the files themselves will be prefixed with let (for letter).
  5. Hit generate commands and see that each character has been converted to a new command:
    The C39 commands tells the machine to draw a sprite from a file on the SD card, at the current machine position, and scaled 80x.

In this case, these are letter form files, and there’s loads of them which is why they get their own directory on the card.  And because this is being done in the context of writing, then the machine knows that if it finds itself outside the rove are, then it knows how to work out where to start the new line.

The grid size sets the text row height, and the pixel scaling controls how big the actual letter forms are scaled within those rows.

In practice, this has the ring of Jack Torrance to it, which is nervously apt.  It’s possible to read fragments, but because each line is longer than the last, and because of the curve and the distortion, it’s almost impossible to figure out how the lines follow on from one another, and very easy to lose track.  Quite disorientating to try.

For this to work you need to copy the sprites folder onto your SD card.

Get the new code, controller and things from the repo

Polargraph 1.2 Controller source code

Polargraph server for polarshield source code

Or in the binaries bundle.  I put the mac and the pc version in together – let me know if there’s any problems with doing it this way.

The other new feature is actually more significant, but a bit more simple:

Norwegian pixel FTW.  I’ll write some more about that tomorrow, because it’s bedtime now.

Norwegian pixel preview

Didn’t get around to making up a numbered release this weekend, entirely restructured the server code instead to separate the basic polargraph stuff from the advanced polargraphSD stuff.  This will make it much easier to keep multiple versions in sync, but needs a bit more testing to make sure I haven’t broken something in the mean time.

However, also added a couple of new features, one of which is the much-asked for norwegian pixel style (above).  This is named after the Norwegian Creations drawbot that I featured on this blog before, and looks quite like it, but is remarkable because it draws directly from a bitmap file on the SD card itself, rather than interpreting commands from the controller.

10 Bullets, working to code

I forgot to mention, Viet Anh Cao used a Polargraph machine to great effect in his graphic and media design graduation show.

I really like the crisp and clean quality of this work – looks very nice, and especially love the joining lines done without the pen lift.  Those kinds of character marks are my favourite parts about this machine, how it shows the process and sequence.

Link to the Creative Review page about the show.

Vector sprites – aka WRITING

A major new feature sprang up over the weekend, and it’s actually one of the things that was immediately desirable when this project started over a year ago. 

PolargraphSD can now draw vector sprites.  These are little fragments of vector art saved into their own files, they are executed by a new command (C39) that specifies where on the machine they should be drawn and at what size.  It works as a kind of macro.  The first application is writing:

In this case I’ve made up 26 files, each with a letter form in it.  I specify the active area using the controller and a starting point where to draw the first letter, then feed in a load of text.  Lines wrap until the active area is full.

This uses the rove area as the demarcation for it’s operations.  The rove area is not entirely a new thing, but it’s never really worked before.  It’s really nothing more than a safe, cartesian area to behave in and it’s specified as simply as dragging a box in the controller and sending it to the machine. It’s going to be important for future standalone functions where the machine will be given free rein to draw or scribble or otherwise fill in this rove area.  It’s called a rove area because the machine is free to rove anywhere in it.

I’ve committed the code I’ve done already, but there’s still a little bit of work to do before putting out a full new compiled version, so that’ll happen later in the week.

Scribble and scale

Pioneer polargrapher and beta tester supreme Kongorilla tested out the scale pixel routines – I think this drawing is exceptional.

Tor Johnson Polargrah Drawing

Showing that pixel scaling is exactly the tonic that scribble pixel has been waiting for all these years.  He drops some science thusly:

The pixels were scaled to 1.4, if I remember correctly. I set the pixel samples to a much lower value than I would normally. I did one pass (row size 70 or 80) that looked OK, but I wanted more of a value range, so I ran it again at a smaller row size. I masked most of the higher value pixels on the second pass, and used pen lifts, to keep my brights bright.

Which confirms that the controller now has a good set of features to get around what I see as this drawing style’s biggest problem – how to add more darkness without also adding any density to the lightest areas.  Very pleased with that.

Also wanted to mention he’s been using StippleGen:

Ernie Kovacs StippleGen Polargraph Drawing

I never got the hang of stipplegen, but I expect I was just being a doofus.

Polargraphs in the gallery

I got wind of this set of polargraph drawings in a recent show in Belfast.  Richard Forrest is the fellow behind them.


I like this exploration of the intrinsic nature of the digital, or quantised, sampled or rasterised forms – the pixelation is a big part of my own work, and I see it here too.  Richard revels a little more in the flaws of the machine, with some great effects, the distorted face is ace, but I like the abstract portraits the best.

I’m not clear if this last show is still on, but Richard tells me he has an upcoming show in Cork next month that will hopefully be featuring a live machine in situ.  I love to see a live machine.


Polargraph and Rasterbator – a slow but beautiful relationship

I remember seeing the provocatively-named rasterbator ages ago, but was reminded of it again when Morbo linked to some work he’s done on the forum, (his pic is here – I can’t embed it from flickr).

I jumped on the bandwagon with my mooning and it came out really nice – the coarse resolution of the polargraph suits this kind of half-toning very well.

Polargraph moon 2

Read the whole thread for some interesting experiments.  Thanks to all involved.

Kongorilla did make the point that running this in a tethered mode (as opposed to from an SD card) is deadly slow, and that’s made me look again at implementing a native circular pixel style, so look for that some time soon, hopefully for UNO-sized arduinos.