The Utopia Open Source Braille Reader/Display ‘Audrey’

When I read Graeme McCreath’s book “Politics of Blindness” earlier this year, I was appalled at what the CNIB was doing. As a sighted person, I naturally assumed they were taking good care of the blind, helping and assisting them in any way possible to enhance their lives, and maximize their contribution to society. I was wrong – very wrong (I won’t spoil the book for you – but please read it as soon as possible, or better yet, buy your own copy, and copies for your friends – it’s that eye-opening).

After reading that book, I realized I wanted to do something directly. So, consulting with local blind people (including Graeme himself), I decided to start with a Braille Display.

Typically, if a blind person wanted tactile Braille from anything digital (computer display, website, etc.) it needed to be converted in to six individual ‘dots’ per character, using small pins that were raised or lowered so as to create the appropriate letter (or combination, which is the case with Grade 2 Braille). This three by two grid of dots is the Blind person’s character set:

Braille Characters

However, Braille display devices run around $7000 – well out of range of most blind people. Yet with a device like this, doors open wide; for example, all the content of the Internet can be read in the comfort of your home; writing and interaction becomes much easier, and waiting for huge Braille volumes in the mail is a thing of the past.

Braille provides the most reliable communication medium for a Blind person to access the printed word, and therefore denying it (or making it so expensive as to effectively deny it) is an injustice. According to one study, 56% of those who read Braille were employed, versus 23% for those who could not. Obviously, lack of Braille instruction is significant. The fact is, for blind people, Braille is a right, not a privilege. And for that reason I designed a Braille Reader to bridge the gap:

Braille Display

This Refreshable Braille Display (called ‘Audrey’, after my mother) takes in computer data and displays it on a small window in the center. This prototype is only five characters; it’s a proof of concept to get the programming, alignment and so forth ironed out.

To understand how it works, consider a single Braille character of two columns of three dots each. Any of these six dots can be either raised, or not; computer programmers will likely catch on right away that means 2 to the power of 6, or 64, possible patterns are available. If we were to mold all 64 patterns onto a long stick, and then move the stick forwards and backwards so that the appropriate character showed through a tactile window, we’d have a simple mechanical Braille display.

Of course, there’s a problem – such a stick would need to be long – at about 1/2 inch per character height, you’d need a stick 32 inches long! Also, the time to move the stick back and forth with a motor would be very time consuming. So as a compromise, this device uses two sticks per character, one each for the left and right columns:

Braille Display Rods/Pins

The result is that eight possible patterns per stick is enough to display all 64 possible Braille characters, in a smaller package, and with faster update speed.

From there, the design next requires a motor to move each stick. Of course, it’s not practical to use one motor for each stick or pin, so we use a single motor for all, with a second motor to move the first from pin to pin (much like a printer moves the active head across a piece of paper). This cutaway shows the mechanical parts in better details:

Braille Display

To finish off, the rest is straightforward: using the Open Source Arduino microcontroller running a monitor program, the Braille Display receives serial data from the computer, translates it into movement and position data, and then moves each rod or stick to the appropriate character position. A motor controller board, additional serial port, and assorted switches and wiring, is about all that is needed to complete the design.

The result is a low cost Braille display – in fact, I estimate a 40 character display can be made for under $200, significantly less than the multi-thousand dollar devices out there today. And while it won’t have all the features of the top of the line model, it will enable those who could never afford a Braille display to actually have one of their own.

In fact, the motivation behind my design has always been ultra-low cost; using two motors for instance, instead of multiple ones reduces the cost considerably. Also, the design is currently adapted for use with a laser cutter, which means that the parts could also be cut out of various materials with hand tools. And the hardware is minimal; with Arduino devices selling for $20-$30 dollars on eBay (and that of course is with sellers still making a profit), even someone in a third world country should have access to the components to build this device cheaply.

Additionally, my goal is to Open Source every part of this device. Open Source solves several problems; unlike proprietary knowledge, this is available to anyone to edit, change, and hopefully, improve. It means ideas can spread faster, with no proprietary ‘locks’ to restrict knowledge. It is immune to accidents; should I for any reason leave off the project, someone else can continue. And with more minds able to look at the issue, the chances for solutions becomes exponentially greater. As Linus Torvalds of Linux fame pithly observed, “Given enough eyeballs, all bugs are shallow”. Opening the hardware and software to this device ensures that problems are visible and are dispensed with quickly.

I do not consider this the ultimate answer to low-cost Braille display – far from it. It is a first small step. However. it’s 2011 – isn’t it time someone took a step forward? It is my hope that from this point on, others will take bigger and more confident steps, with the result that the true beneficiaries, those that are blind, obtain better and better products at lower and lower prices.

One day soon, I imagine a young child in rural India finally being able to take in all the text of the Internet through a Braille Display – if we can provide her with the opportunity, it’ll have been well worth it.

Headshot Horrors – How You Can Get a Reasonable Headshot on a Budget

For my latest Sitepoint article submission, I realized it was time to update my bio, including headshot. My last one was shot from a distance using a low-pixel camera, and let’s face it, years out of date (I did like looking younger, though). Now that I really needed a new/recent headshot, I felt it was time to bite the bullet and do it properly.

One catch: I am not an Adonis. In fact, I am Adonically-challenged. Cameras don’t like me, and I don’t like them. But, I’m not alone, and so for anyone looking to get the maximum headshot ‘bang’ with the minimum fuss, and keep costs low, I thought I’d explain how I got a reasonable headshot/portrait out there, without too much pain and sweat.

Step 1: Give up on the background. One of the most frustrating things I find with photos is where to pose. Professionals have a selection of artsy backgrounds you can pose in front of, but that’s out of the question for a one-off shot. My solution? A little digital magic, using a green screen background. I got ahold of several large sheets of florescent green paper, taped them behind me, and shot in front of that. The benefit is that I could ignore the background, focus on the headshot, and then digitally add a better background afterwards. For that, this website has a step by step guide to creating chroma-key photos with free software, and using green OR blue backgrounds.

Here’s my result:

my and my green screen David Pankhurst w/new background (Oct/2011)

If I was doing it again, I’d go for a neutral green over florescent, and preferably a neutral blue. Either color is OK to use with the Paint.net technique I used here, but reflections from green screens are harder to get rid of naturally (notice my final picture has a green background to hide this). Blue, even if some gets into the picture, blends in unobtrusively.

Step 2: Light right. The whole point of lighting is to direct people where you want them to look. So if you don’t like your neck, avoid putting a spotlight directly on it! In my case, I had my left side lighted from a window, an overhead light in the room, and a reflector for the right side (which provided a little less light there than I wanted, but still evened it out fairly well). Lighting is especially important across gender lines: most guides I read recommended men looking slightly down into the camera, and women slightly up in photos. If you follow that guide, you’ll need different lighting (and camera positioning) for each.

Step 3: A decent camera is your friend. Digital photos are cheap, so get as high a resolution as you can. You will be chopping down the photo, but starting with high resolution makes life a lot easier. As well, a good camera has a number of settings that can simplify shots, like adapting to lighting conditions, eliminating red eye, or lighting with different ‘colors’ (such as light, warmer, reddish lighting, or cooler blue lighting). And make sure you have enough memory. You will be taking a lot of photos to try to find the look you want, changing angles, lighting, clothing and much, much more. Keep batteries handy, too!

Step 4: Your photographer is also your friend. My wife took my shots. She is long suffering and kind, and I don’t deserve her. You’ll feel the same way after you’ve gone for a few dozen shots that don’t quite work. As you see photo after photo of mysterious oddball poses you don’t remember doing, you’ll need a morale boost; that’s when you’ll be glad you have a photographer to suggest different settings, changes like clothing and facial attitude, and much, much more. In fact, the shot I’m using was one of the last, proof that if you work at it, a good shot can come about!

Step 5: You favorite paint program is REALLY your friend! This is where the extra pixels come in handy. You can even out coloring, tweak the layout, crop, and even smooth the picture (don’t forget switching in the new background of course). Although my chroma-key trick uses Paint.Net, and you could probably use the program for your whole edit, I’m a big fan of Paintshop Pro, which is where I did the rest of my image processing. For those of you on a budget, Gimp is also a highly-respected and free paint program that will make it easy to finish off your picture.

These are just my experiences – yours will vary. But be prepared to take quite a few photos, and go through a lot of them to get a feel for what works. In my case, the turtleneck and pose was a last-minute change that surprised both of us by working well, and ended up being the photo I’m going with. Keep trying, and you’ll eventually find a ‘best of’ shot you can use as well.

One final point: remember the reason for your photos. If you’re about to start a fifty-city book tour for your million-seller novel, spring for a professional photo! Any photo you put out there reflects on you, likely for as long as the Internet exists (sadly). So if you need to put a professional foot forward, remember to spend some time getting the best shot, and also know when it’s time to call in a professional picture-taker. But if you can, it IS possible to do a reasonable job with a little effort, and some digital trial and error!

I’m a Hacker!

This month has been busy with planning for my Really Important Project. As part of it, I needed quick prototyping with fast turnaround (cheap would be nice, too!)

In scouring Victoria BC and environs for 3D printing services (hint: give up and go to Vancouver!), I came across a local group – MakerSpace – a local ‘chapter’ of the HackerSpace movement.

Wondering what a HackerSpace is? Imagine a big room or two with band saw, sander, many, many more power tools, vinyl cutter, a few computers – and a 3D printer and Laser Cutter! The 3D printer is a Cupcake Model, with a bed size of about 4×4 inches, enough for a gear or two. However, playing with the laser cutter (actually, watching others play with it), I rethought my project in terms of flat pieces, instead of 3D printed pieces. The laser cutter is fast, clean – and although it stinks something awful cutting wood and acrylic – a much better way to prototype than 3D printing.

Fast forward to last weekend, when I finished my ‘official’ training on using it, and now I’ve spent an intensive week reworking my project to be built out of thin 3mm (~1/8″) pieces of Acrylic cut and snapped together (or in a very few cases glued – I’ve just tested ‘Crazy Glue’ and it bonds great, although I’m told pure Acetone would work as well). The result I hope will be a simple to use/share demo of my idea.

In any case, I’m hoping for a hot weekend of laser cutting, and later, as they offer more classes, learning other techniques (I won’t catch this weekend’s class on forging, but possibly when it’s available again…)

In the meantime, if you’ve wondered how you can get access to saws and other tools locally, or just needed access to a workspace ASAP, check out Victoria’s MakerSpace/HackerSpace. Whether you join or just drop by for a day (at $20, quite a bargain), you have access to a wide range of tools, and knowledge from members. Better yet, sign up as a member – your $50 monthly fee goes towards a good cause, and makes it possible to get even more and better tools!

My New Uno – A Ruggeduino

I’ve been using my Arduino for about a year now – a Duemilanove – and I’d been eying the new Unos for a project. However, they are almost the same – so why upgrade?

I found a reason: safety. Check out this post on what can happen with a regular Arduino if anything goes wrong. It explains that although the Arduino is great to work with, it lacks a few areas of protection – areas that clumsy ‘ol me felt were only too likely to end up in.

So I bought one.

No socketed chips, it’s all surface mounted. However, unlike the Uno, it includes a lot of extra protection – fuses, protection diodes, etc – allowing me to goof with it. Which happened almost immediately: I was working on a switch multiplex circuit when I touched a +5v wire directly to ground (I was too lazy to wire in a switch). The computer halted, paused, and then started up again, perfectly sound. According to their page, that’s exactly the kind of problem that fries a typical Arduino. I’ll take their word on it – I’ve no interest in finding out for myself!

But back to the Ruggeduino: when it arrived, I plugged it into my USB and was rewarded with a LED fade – very thoughtful of them to preprogram something useful to show me it’s fine straight out of the box…

The next step was to get it installed. The Windows driver was not the usual Uno driver, and is available on their site. To use it, do the following:

  • Their installation section explains what to do to get the file, which is available from their site, as a text file you copy and store locally as a text file, but with the .inf suffix (for instance, rugged.inf).
  • Most of the installation is similar to the Arduino generic install from there on in – just point to your newly-created .inf file during the install process.

A bit more work – but on the other hand, it means you can safely run an Arduino and Ruggeduino side by side, since they won’t conflict on the USB ports.

Finally, to program, you just set up the editor to use an Uno as the device (Tools; Board; Arduino Uno). And that’s it. You’re working with the latest – and with a lot of ‘goof-proofing’ added in for good measure. If you’re as nervous about short circuits and turning $20-$50 of electronics into exotic paperweights with one mistake as I am, then I suggest you look into a Ruggeduino too. You’ll be making your money back the very first time you don’t blow it up!

Product Source: www.Ruggedcircuits.com

Braille Distribution: Or, Just Which Pins Take The Most Abuse In a Braille Reader?

It seems a simple question: which patterns/letters are the most common in Braille?

However, it’s not quite so simple, since Braille is not a straight character-for-character representation. For example, capital letters require another character in front, and Grade 2 Braille includes many contractions that use previously unused cells from Grade 1 Braille.

So, to do a very informal test, I entered some web text into the online from at MathsIsFun.com (actually, the text contents of that page!), and gathered the output in Grade 2 Braille, then wrote a program to count things: which characters were use and how often.

The result is not a big surprise, since the space is by far the most common character – here’s the table in Braille DOTS pin format and ASCII, as well as ranking (which is the direct entry in the Unicode 0x2800 Braille code page):

Position ASCII Code DOTS Format Count Position ASCII Code DOTS Format Count
0 SPACE 171 18 3 (2+5) 4
30 t (2+3+4+5) 50 19 h (1+2+5) 4
1 a (1) 44 38 8 (2+3+6) 4
17 e (1+5) 43 45 x (1+3+4+6) 4
14 s (2+3+4) 42 52 0 (3+5+6) 4
32 , (6) 42 57 ? (1+4+5+6) 4
21 o (1+3+5) 40 58 w (2+4+5+6) 4
23 r (1+2+3+5) 30 63 = (1+2+3+4+5+6) 4
7 l (1+2+3) 28 5 k (1+3) 3
29 n (1+3+4+5) 25 33 * (1+6) 3
10 i (2+4) 24 34 5 (2+6) 3
9 c (1+4) 22 51 \ (1+2+5+6) 3
15 p (1+2+3+4) 20 55 ( (1+2+3+5+6) 3
25 d (1+4+5) 20 22 6 (2+3+5) 2
61 y (1+3+4+5+6) 17 53 z (1+3+5+6) 2
37 u (1+3+6) 14 6 2 (2+3) 1
13 m (1+3+4) 13 24 ^ (4+5) 1
46 ! (2+3+4+6) 13 28 > (3+4+5) 1
2 1 (2) 12 35 < (1+2+6) 1
3 b (1+2) 12 39 v (1+2+3+6) 1
11 f (1+2+4) 12 40 . (4+6) 1
50 4 (2+5+6) 12 41 % (1+4+6) 1
27 g (1+2+4+5) 11 42 [ (2+4+6) 1
20 9 (3+5) 10 49 : (1+5+6) 1
47 & (1+2+3+4+6) 7 4 ' (3) 0
59 ] (1+2+4+5+6) 7 8 @ (4) 0
16 (5) 6 26 j (2+4+5) 0
36 - (3+6) 6 31 q (1+2+3+4+5) 0
44 + (3+4+6) 6 43 $ (1+2+4+6) 0
54 7 (2+3+5+6) 5 48 ; (5+6) 0
60 # (3+4+5+6) 5 56 _ (4+5+6) 0
12 / (3+4) 4 62 ) (2+3+4+5+6) 0

The results come close to the distribution in English of letters, which is (roughly) “eitsanhurdmwgvlfbkopjxczyq” – but one big difference is the comma, which is actually the ASCII representation of the capitalization symbol (to make it even more complicated, apparently British Braille does not include it, which would skew the results).

Put together, it does give an idea of wear and tear on specific cells (say, for example, a daisywheel style Braille embosser). But another way to look at it is the individual ‘pins’ in a display: based on this sample, here’s how often each pin/dot gets used:

Braille Pin Counts In Sample
Pin 1: 399 times
Pin 2: 320 times
Pin 3: 364 times
Pin 4: 319 times
Pin 5: 318 times
Pin 6: 178 times

Good news: wear and tear is more or less evenly distibuted, except for pin 6, which is used about 50% as often as the others. Except for that, the result does means that a Braille display gets roughly even wear/usage across the pins – important for designers.

Arduino Strings Are BIG!

Interesting test: I was wondering if you could avoid the automatic string copy to RAM by putting strings inside a subroutine:

 
#include <avr/pgmspace.h>
int freeRam () {
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}
void sub(void)
{
  char *text="ssssssssssssssssssssssssssssssss";
  Serial.print("inside function: ");
  Serial.println(freeRam());
//  text[0]='\0';
}
void setup()
{
  Serial.begin(9600);
  Serial.println(freeRam());
  sub();
  Serial.println(freeRam());
}
void loop()
{
}

Run it, and you’ll get a memory display of RAM before, during, and after the subroutine call, something like this:

1840
inside function: 1834
1840

But uncomment the line

//  text[0]='\0';

and run again – likely, you’ll get something more like this:

1806
inside function: 1800
1806

What happened? In the first one, the compiler optimized the text string right out of the system – until you did something with it (like setting text[0]) then it put it back in, and with a vengeance: that string is now in free memory RAM from the start of the program (notice the value before the subroutine was called – no change after).

What does this mean? If you use strings, be careful of them – anywhere they exist they add to RAM usage. Of course, if you move your strings to program memory, that’s another matter…