Wait, what is BrailleBox?

When I originally built the first edition of this with the Arduino Uno, it involved loading a text file into the program which was quite a manual process — this wasn’t very ‘smart’ (hey, it was only a prototype!). With the Internet of Things, you expect a device to be a bit ‘smarter’ than this — so it was obvious that the the approach this time around needed to be automated, or somewhat less-manual.

Rather than the loading of this text file, I thought it would be a nice idea to display some form of informative data to the user. One of my favourite ideas that came to mind was to allow users to read some latest news articles in braille — I came across News API and this felt like the perfect API for me to get something up and running fast. Using this API I could fetch a collection of news articles from a desired source and simply them to the user 🙂

Initially, I originally had a single key requirement when it came to creating BrailleBox:

It needed to display a news article in the form of braille as requested by the device

But with a little bit of thinking, there were a few more things I had to think about in-order to improve the UX of the device:

Should the device fetch the news automatically? This is automated, but I might not be at the device when it displays the article. This could also be quite alerting for the user if the device randomly starts clicking out of the blue.

Instead of the above, the box could have a button which when pressed fetches and displays a news article in braille. Provided the box is placed in a location that the user is comfortable with, this will allow for

The rate at which the news article is read could be either too fast or too slow for users. To solve this, it would be worth adding a potentiometer to allow changing of the rate at which the letters within each of the words in the news article text are displayed. (I didn’t actually end up putting that in this version, next time though 😉)

With that it mind, this is what I ended up with:

It’s only here to act as a prototype, so it’s not currently the most beautiful looking thing on this planet but it works, right! Here’s a little clip of it doing its job:

But wait, what’s Braille

Just to cover some foundations (I’m not a master in braille either, so I can’t give you a full lesson here I’m afraid), but braille is a system that allows the visually impaired to read sequences of patterns that represent letters, words and symbols. Each individual braille character consists of a combination of raised ‘points’, this is best represented in the graphic below:

You can see here that each letter and each number is represented by its own unique representation of braille ‘points’. With this in mind, it’s actually quite a simple system (probably not so simple to learn however) — from this system we can create complete word representations by piecing together combinations of letter representations. Once we have these ‘words’, we then need some way of displaying them in the physical world.

But how can we recreate this in the physical world? Current solutions have been pretty expensive — dynamic braille displays are nothing new, except they cost thousands of pounds to build and purchase. The whole point of this project originally was to be able to do it for a fraction of the price, making this kind of technology accessible to many (that’s one of the things I love about Android after all).

But how do these braille points get shown when it comes to BrailleBox? Well, in relation to the Android Things platform, we have access to what’s known as GPIO (General Purpose Input Output), we’ll come onto this more later in the article — but if you look at the image on the left, you’ll notice that we can arrange the output of these pins to look very similar to the braille sequences above.

Saying this, we can use GPIO and position 6 outputs to recreate the same representation of the braille characters that we previously looked at. For this, I used what are called Solenoids — a solenoid allows us to pass in a current, creating an electromagnet that can pull in our magnet, as well as pop it back out. You can read more about solenoids here, but the ones that I’m using look a little something like this: