Not all of our projects find themselves with a need to display data locally. With the IoT and the myriad sensors being such popular targets for project work, many of our designs post their data back up to the web these days, for us to watch over on our favorite dashboards, etc.
However, when there exists a need to display data locally, it's worth taking some time to ponder over the pros and cons of the various viewing options and controller configurations when it comes to pushing pixels around.
From FSTN liquid crystal, to flip-dot electro-mechanical, to memory LCD, to monochrome VFD, there are a vast array of viewing options to cover a wide range of applications — both from the perspective of data to be displayed, and environment of deployment — the choices are nearly countless!
If you are just looking to string out a few simple variables, perhaps you don't want to implement an LVDS interface to drive a 65K IPS color OLED panel... Suffice to say, your aim might be to look at simpler ways to get your project printing "Hello World!" up in lights!
Although impressive as it is, instead of interfacing to a laser over ILDA, many of the projects we find ourselves working on would be better suited by something more like an alphanumeric display, the type of which is going to be dependent upon the application itself.
Normally, these LCD panels are supplied with some built in "intelligence" — a controller that takes the load of managing a pixel array away from your list of things to do, and instead, provides some element of serial interface, allowing you to 'printf("my data");' — directly out of the UART that is in turn connected to your display device.
Simple, and easy to use, the only downside is that if you wanted any graphics to glitz up your data, you're resigned to the glyphs that may be gathered in the rest of the controllers "Character RAM" collection — the memory where the pixel maps that make up the letters we see are stored.
Although the functionality for fun with the font set is there, you're often limited to the number of custom characters you can hold in the controller RAM, and cycling through them, loading them from the MCU as required, can be a tedious task to keep tabs on.
A dot matrix display isn't too far removed from the humble character display, the main difference centering around the controller connected to them.
Instead of shipping supplied with a controller that translates your serial strings into signals that control the segments of the LCD, the silicon that sits between your microcontroller and the switching elements of the display is instead expecting you to give it a bit more guidance in how to go about gating the flow of current to it's flock of segment switching elements.
The trade-off in this higher level of hand-holding is the reward of being able to put pixels wherever you wish, usually at much higher rates of refresh, and without care for the conventions of characters, etc — even animations are often possible!
What if you want the best of both worlds? The simplicity of slinging strings at a USART, but with the ability to leverage low-level commands to let your pixels light up in the liveliest of ways?
Perhaps you might want to take a look at the Pixie display peripheral, fromLixie Labs.
Pixie is a pretty neat idea. Designed to keep you sane, its simple interface will keep you from asking "where's my mind?" when using it in your next project! When faced with the presenting as a pluggable pair of 5 x 7 dot matrix pixel displays, its form factor is perfect to plug in to the front face of any project.
It's the best of both worlds: a lightweight display with a few hidden tricks up its sleeve, such as slick animations, as showcased in the block below!
Let's take a look under the hood of these micro LED modules, and see if we can pick out a few details that make the Pixie shine! First thing's first — a peek at the schematic for Pixie.
At its core, we can see that Pixie is based around a pair of 5 x 7 green micro LED pixel displays, Lite-On Inc LTP-305HR/G equivalent.
You might have seen these displays on your workbench if you're a patron of the Pimoroni product range, having been put into action on their Micro Dot pHAT boards. While not exactly flying off the production lines these days, these parts have a certain nostalgic following. Perhaps due to their high-density, packing an array of 5 x 7 LED elements into a 0.3" DIL-14 package, or the retro aesthetic they are able to produce, they have been popular targets for reverse engineering, with numerous projects dedicated to reimagining similar displays for modern day production efforts.
Although these particular displays sport 35 individual LED elements per DIP package, they are still "dumb" — in the sense that they lack any form of controller to take care of the addressing of the rows and columns in the array of LEDs, in order to light up the desired pixels.
With 13 pins required to address a single display making for a total of 26 GPIO required, before any tricks such as making common either the rows, or columns of both displays, it's pretty clear there is some additional circuitry going on, in order to enable the ATtiny45 and its limited eight pins — six of which are I/O — to light up this litany of LEDs!
Let's flip on over and have a peek at the back of this pluggable module, and see if we can spot just how the Pixie gets tricksy!
With our lives filled with LEDs every which way we look, and displays dishing out information from nearly every device, there are quite a range of application specific chips designed to lighten some of the load that designers would otherwise face when deciding on how to drive, for example, LED arrays like these.
Lixie Labs has chosen the IS31FL3730, from the ISSI FxLED driver family, seen top left in the photo above — in its tiny QFN-24 package — to light up the way on the Pixie boards.
With the ability to drive two arrays of 64 LED elements each, this part has more than enough capacity to control the 70 LEDs that form the 2, 5 x 7 pixel arrays found between the LTP-305G displays.
We've seen this family of I2C LED drivers from ISSI put to use everywhere, from the pHAT boards designed by Pimoroni that we mentioned earlier, to the charlieplexed array driver boards that from Adafruit, that make use of another of the ISSI offerings, the IS31FL3731.
With these parts offering the ability to abstract such a huge array of LEDs — and the I/O normally required to drive them — down to a single I2C port, the appeal of these devices is already obvious!
When you look at some of the extra functionality provided by these parts, such as being able to readily modulate the brightness of the array with an analog signal applied to a dedicated audio input pin, these parts really start to look quite attractive for things like conference badges, where the analog input can provide the potential for some additional, audio reactive fun!
So with other products using similar LED setups, what sets the Pixie apart from this group of pre-existing, driver-integrated, LED arrayed, display boards?
Well, Pixie packs a punch, thanks not only in part to it's pre-programmed firmware, residing on the on-board Microchip ATtiny45, but also in part to the amount of effort put into supporting these display modules by Lixie Labs.
The ATtiny is able to serve as a bridge between the host MCU, and the I2C interface of the ISSI LED driver, allowing it to simplify the control of the IS31FL3730.
The stock firmware loaded on the Pixie also serves as a great reference for how to implement an I2C peripheral device on an ATtiny, one that is still able to control its own, on board peripheral devices. I've seen that question asked a lot on the Arduino forums, so I'll be keeping this in my bookmarks!
First and foremost, the user documentation is impeccable. Comprehensive in nature, and well structured, it's better than a lot of efforts seen from... "larger" manufacturers!
With the supplied Pixie Arduino library ready to go, you can get straight to interfacing these parts, and pushing pixels about in practically no time at all! Again, it's well documented, and has a great guide to the full function set.
If you've got a need for some custom characters, it couldn't be easier to add them to your code, with a simple to use online character generator that lets you punch in the patterns you want to print out, before presenting you with the line of code needed to instruct Pixie to display your intended character.
Outside of the design files themselves, the GitHub repo contains all sorts of additional goodies, such as 3D printing files for a desk clock style stand, 3D part data, even ECAD part libraries for easy integration into your projects!
If you want to have a play with the Pixie modules, and perhaps aren't kitted out to build your own from source, Lixie Labs have them available for sale on Tindie, at a price that would make you question trying to build your own — even with the required tooling on hand!