Let us try again

Sigh…

Polargraph controller 2.3.0

  • Added: Density preview is now posterized by default, and is linked to the
    pen width setting. So should be able to use this to better visualise the link
    between pen width and grid size.
  • Fixed: Queue preview bug: http://www.polargraph.co.uk/forum/polargraphs-group2/code-software-forum2/updated-controller-thread504.0/#postid-2938
    thanks jbscribble.
  • Fixed: Slight improvement in pixel rendering speed.

Experiments in the controller, and now buildable in Arduino v1.6.6+

Made up a new code bundle, wrapping up a couple of recent changes.

  • Firmwares are now all buildable in Arduino IDE v1.6.6+.
  • The polargraph_server_polarshield firmware now uses the same kind of communications protocol as the _a1 variation. This is a little experimental, so let’s give it a shot.
  • The controller console is back! In a bit of a reduced form anyway. We’ll see if it’s worth anything. Ctrl-C.
  • There’s a posterisation option for the pixel density preview. You might use this to visualise how a compressed dynamic range will affect your drawing. You get a compressed dynamic range when you use very small grid size, or a big pen. It’s not linked to pen size yet, but that’s the obvious thing to do next.

https://github.com/euphy/polargraphcontroller/releases/tag/v2.2.2

Updated firmware for Polarshield v1.2.2

Given recent discoveries, I wonder if the spate of recent touchscreen problems (see http://www.polargraph.co.uk/2015/10/touchscreen-issues/) are to do with the weird startup problem that I described in that post, OR to do with the base stupidity I displayed by including a in-development version of the polargraph_server_polarshield firmware.

It actually had USE_LCD turned off in it.

So that’ll make sense.

I’ve fixed it, rebuilt it and repackaged it and apologise if this made you mad.

https://github.com/euphy/polargraphcontroller/releases/tag/2015-11-10-23-07

An interesting discovery is that the newest version of Arduino IDE (1.6.6 – it’s only a week or two old) CANNOT compile Polargraph firmware. So, thanks Arduino dudes, for breaking everything again – it looks like two can play that game.

So use Arduino IDE v1.6.5. Until I figure out what’s screwed.

 

Touchscreen issues

I’ve had a rash of problems with the touchscreens on bare Polarshields!

Over the last six months or so, I’ve noticed an issue where the touchscreen doesn’t work after booting. It looks ok, and updates fine, just no response to tapping.

I solve this by discharging the static from the device, while it is unplugged. I do it by either leaving it for a couple of minutes, unplugged, or by touching the metal USB socket housing, and rubbing an earthed piece of metal (it’s a wall-mounted shelving rack that I know happens to be screwed into the grounded metal studding in the wall). Handle it carefully, by the edges of the board while you’re plugging it back in.

I didn’t write anything about this until now, because until recently I was hoping this was a problem that only I was having! I think the touch IC must be being blocked during it’s boot process, or something like that.

I have handled hundreds of these, and the screens actually breaking down somehow is very rare. Having them rebel against their touch programming happens every day though, and I always fix it this way.

You can test your screen by using the UTFT and UTouch example sketches, but with these updated lines:

UTFT        myGLCD(TFT01_24_8, 38, 39, 40, 41);   
UTouch      myTouch(11, 12, 18, 19, 2);

Good luck!

Polarshield now compiles in Arduino v1.6

what the hell are you doing?

Well, I’m glad you asked.

The drawing above is by Ben Young. I love it.

Released new code bundle. Only code change is that I’ve mended this line about how the crc_check pre-computed value table is defined in polargraph_server_polarshield.ino. The only purpose for this is to allow it to compile in the newest versions of the Arduino IDE (1.6x). If you aren’t using that version, you don’t need to update anything.

Also updated the UTFT library to v2.81, for the same reason (Arduino IDE 1.6 compatibility).

https://github.com/euphy/polargraphcontroller/releases/latest

Machine Sketches show featuring PolargraphSD

Whitley Bay-based PhD student Carl Gregg has a show opening in a couple of days, featuring elements of his research made material:

Transition5_inviteGregg has used a couple of PolargraphSD machines in his work for the last couple of months, and wrote custom software to drive them over long periods of time, presenting them as performances. I really like this experimental approach, and the materialistic artefacts (like the missing, ghosted names in the drawing above) add depth and resonance to the work.

If you find yourself in Newcastle or Shields in the next couple of weeks you should go along to The Customs House and have a deek! Thanks to Gregg for letting me know about this.

G-Code importing, and a bit of calibration help. Controller v1.2

I am generally filled with forboding about adding features to the Polargraph Controller. I remember it as being a twisted and unstructured wild-west kind of program. However, whenever I actually get into coding in it again, I always regret my fear, because I get something really useful done, in a really short length of time. Last weekend was no different.

Download the result: Polargraph v1.2 code bundle, or read on… If you dare.

G-Code importing

Polargraph exemplar Kongorilla has made a number of not-so-subtle hints about the impediments he runs into in getting stuff prepared for drawing. There’s a workflow that is sometimes fairly tortuous, even if it is logically straightforward. The controller has only been able to import SVG files, so a run through inkscape has always been the last step for most people.

IMG_20150519_172018910

The load vector dialog now allows .gco and .g files too, so anything that emits g-code files is also now a contender. Now, it’s fairly simplistic, understands only G0 and G1 commands, and the Z-axis implementation is rudimentary, but it does mean that it can swallow the output of wonderful things like Dullbits’ beautiful Death-To-Sharpie sketch.

The Z axis automatically makes a choice about when the pen is up or down. The very first Z axis change is ignored, and the second one is used henceforth as the “down” (drawing) position. Any position other than that second position is considered a travel (non-drawing_ position. This is because dullbits has Z1.0 as it’s drawing position and Z0 for travel, whereas inkscape(‘s gcodetools) seems to have Z-0.125000 as it’s drawing position, and moved to Z5.0 for travel. So opposite directions.

Usually the first Z movement is to shift into travel mode, in order to safely get to the start point, and then the second Z movement is to drop the pen / tool. Scripts that have funky stuff going on in their Z movement might need a bit of manual editing to work.

It’s immediately become obvious that .gco is not a standard enough file extension, so I’ll change it to .gcode as well for the next release. For now, just rename the file.

Preview cord offset

A commonly reported problem is that a drawing is short and fat, or tall and thin, or has a curved top or bottom, or it’s sides diverge.

There is a page about this in the Polargraph wiki, but it’s quite hard to diagnose, and hard to explain in words. I added this extra feature to the queue preview that allows me to simulate common calibration errors.

The way I imagine this being used, is:

  1. Draw a shape. Oh no, it’s all wrong!
  2. View the command queue in the controller app. It looks right here!
  3. Adjust the preview cord offset until it the preview matches what happened on the paper.
  4. Look at the value of preview cord offset. If it is:
    1. Positive: Your home point is further from the sprockets than you’ve told the machine. This might mean your home point is actually further down than you’ve measured, or your machine is wider than you’ve measured.
    2. Negative: Your home point is closer to the sprockets than you’ve told it. The home point might be higher up the machine than you have measured, or your machine is actually narrower than you’ve measured.

Firmwares

Polargraph_server_a1 has been updated to v1.2, and while there is no new functionality for UNO owners, I have merged the old MEGA-only features in, and made them configurable at compile time. So you can use polargraph_server_a1 on a MEGA, and get the SD card reading, norwegian pixel, spiral pixel etc. I actually fully expect this to have broken a load of stuff, so please take care, and report bugs.

In other news, I’ve also been working on porting the Controller to Processing 2, but that’s not borne fruit quite yet.

Download the code: Polargraph v1.2 code bundle

Polargraph at the Edinburgh Science Festival 2015

Once again, the Polargraph Pro is featured as part of the Edinburgh Science Festival’s Making It touring exhibit, stationed until the 19th of April 2015 in Ocean Terminal Shopping Centre down the road in Leith.

P1050631_c_p

Tricking the machine with smartphones

I was a bit nervous about having the machine presented in such a uncontrolled environment (it was in the National Museum last year), but it’s been remarkably low-maintenance during it’s first week.

Some better than others

Some better than others

For this year’s outing, there were a very small number of changes to the firmware, mainly to add a feature to support a button and an indicator LED on the circuitboard that is controllable via commands, and used to signal to the Science Communicators that it needs it’s paper changed.

The changes to the Polarweb controller software are a little deeper, and there’s now a visualisation video stream published to a browser so you can see what the machine sees, and what processing it’s doing. Worked pretty well, but taxed the original laptop a bit much (it was an Atom), so the machine has been upgraded.

Other upgrades:

  • Minimum face size, so only people close-up get recognised and drawn
  • Path sorting to make for more efficient drawing (I hope to pull this work into the general Polargraph Controller some time soon)
  • Except for changing the paper, there is no manual intervention required during operation
  • Tracing controls are available in the interface to change posterisation levels, minimum path length, maximum path count and smoothing
  • The pen lift servo wire is routed more neatly, and uses spring-loaded retractable cable spools rather than the coiled cable that got stuck all the time
  • Drawing sequence can now fixed bottom-to-top so that pictures can be cut out and taken home as soon as they are drawn

How to make a PolargraphSD

Just thought it might be interesting to see the steps that go into making a PolargraphSD. I’m curious about this kind of stuff, and I love work-in-progress pictures. So I assume you do too.

P1050515_c_p

Apply solder paste.

Starting with the PCB mounted in a jig made of other PCBs, I use a plastic stencil, and a card to squeegee on the solder paste. This can be messy, but it’s very fast, takes less than a minute for each one.  I have taken to making up batches of 10 polarshields at a time, it takes a reasonable weekend, or a long day from beginning to end.

P1050576_c_p

Sometimes bits get missing, or I accidentally rub off the paste during placing, and I use a little syringe to do touch-up stuff. Afterwards, there’s these nice little pillows of paste on all the pads.

P1050580

 

Pick and place

I’ve got all the parts I need in little boxes, and empty out about the right amount of parts, sort through the pile and turn them over and line them up with a pair of tweezers. I used to use tweezers to place them too, but have recently got a cheap vacuum pickup tool that makes it a bit quicker.

P1050582_c_p

 

Using magnifiers and good lighting, dealing with these tiny parts is much easier than I thought it would be.

P1050583_c_p

I place most of the ICs with tweezers, because I get a bit more control over their orientation – they have a tendency to swing around a bit on the tip of the vacuum. The really big parts (electrolytic caps and the inductor) are just placed with fingers.

Soldering / reflow

I’ve got a hot air gun (Atten 858D+) that I used to take 8 minutes to melt all the solder paste on each board, and I still use that for touch-up and fixing. The last couple of batches of Polarshields have been soldered with a little home-made reflow oven though. This is a mini oven, retrofitted with a Zallus temperature controller. The temperature controller was a Kickstarter I backed at the end of last year, and it seems to work really well. Though the whole contraption looks like junk – but that’s my fault.

P1050585_c_p

The boards go in two at a time, and cook for 6 minutes, releasing all kinds of (probably deadly) fumes. I only use lead-free solder in all my stuff, so it’s not the nice smell you get out of rosin-fluxed lead solder. I miss that. My old tutor told me that eating plenty of jam would help ward off the poisoning that we would all get off the solder fumes. I like the story.

Now comes the really boring bit.

Through-hole soldering

There doesn’t seem to be any way to short-cut this one, just got to cut lots of parts to length and solder them all in. Using the kind of small iron tip that is useful for touching up SMT work makes this an absolute misery, so use a big clumsy chisel tip instead to whizz through.

P1050593_c_p

There are 156 points of through-holes to solder. During soldering, I sometimes spot things like this:

P1050596_c_p

There’s a solder bridge between the first three pins of the IC. This is irritating, but out of 10 shields, there’s normally four or five bridges like this that need a touch-up. Fix it with some solder braid. In this case, I noticed the IC was a bit skew-whiff on it’s pads too. I am not sure if it is something about the heating profile, but it seems like the parts don’t always get “pulled” onto their pads by the solder tension during flowing. At least, not as straight as I saw when I was using the heat gun. So with this IC, I reflowed it using the heat gun, and just nudged it to straighten it up. Afterwards, I wash the board with Techspray Flux remover to clean it up. Add stepper drivers and LCD, and it’s ready to test.

Testing

Upload the latest version of polargraph_server_polarshield and see what happens. Well, I just got a white screen. So I took another look at the board and spotted another solder bridge. Fixed it.

Testing involves plugging in a couple of steppers, a servo and an SD card and running a test script from the card. If the motors move smoothly and quietly, and the servo wiggles, and the LCD responds to touch, then it’s cooked.

IMG_0043_c_pFor full PolargraphSD kits (with the motors and cables), I do another test of the same routine before I pack everything up, to make sure the particular motors and the cables are correctly constructed, and they all work together.

Case

The case is made up of 16 laser cut parts, and is fastened together with six M3 nuts and bolts, tab and slot style. I try to leave as much of the protective film on as possible during assembly.P1050604_c_pI enjoy peeling that stuff off when I buy a new product, so I assume other people like it too. It stops my grubby fingerprints spoiling it too. I’ve got white gloves and everything, for this bit.

So now you know. Tune in next week and I’ll show you something equally as thrilling, how I clean my oven or do the hoovering or something.

 

 

Huge Portland Design Week project

It’s great to hear from polargraph people from around the world, and I was especially pleased when it turns out they’ve had zero problems, and have added their own features to the standard kit.

IMG_1725You can see this is a big machine (12ft wide, 8ft tall), drawing some promo stuff for for an agency in Portland. Notice the extra pulleys that have been added to reduce the drop of the counterweights – liking that.

This isn’t merely a really big machine though: The makers, Olivier and Evan spend 55 hours drawing the motorbike above and decided they could do better, and came up with a very sweet little script that will read your optimise the saved command queue and … make it efficient!

motorcycle_originalAbove is what the original pen path looks like. No surprise it took 55 hours really. The path planning has never been efficient, and just draws the file as it reads it, from top to bottom.

Running an exported command queue (previewed above) through this Polargraph Optimizer results in:

motorcycle_optimized

Which I think we can agree is much more sane. Evan reckons this is 3 1/2 times faster, and I don’t doubt it. Brilliant!

Thank you to Olivier, Evan and Squishymedia for supporting the project, and for giving back too. I’m going to try and pull those algorithms into the Polargraph controller at some point, but until then, I’d recommend that anyone doing really complex drawings should have a look at this.

Most of the things I end up talking with folks about about are troubleshooting and helping get things working, and I feel endlessly guilty about putting you through all that. It’s really gratifying and refreshing to hear success stories – and when someone cares enough to contribute, it means a lot. Even if it is embarrassing because it shows up all the bits I never got around to finishing…

Source: Polargraph Optimizer on github