While the SSD1306 OLED has somewhat become the go-to display for up-to-date projects, the good old character displays with their Hitachi HD44780 controller don’t seem to be disappearing just yet either. And why would they, especially if you want to show just text, having a built-in font has certainly its perk compared to worrying about integrating your own characters — which you can still do on top as well. Or perhaps you can combine both worlds, which is what [oldmaninSC] did with his digital clock that takes an entire 16×2 LCD to show each single digit.
The whole clock uses 16 individual, upright rotated 16×2 LCDs that are arranged in two rows of eight LCDs each, turning the entire construct sort of into a giant 8×2 display itself. For some additional information such as the date, there’s also a smaller font available that uses only half the height, allowing up to four total rows of information. To communicate with each LCD via I2C, two TCA9548A I2C multiplexers are connected to an Arduino, along with an RTC to keep track of the time and date itself.
As the TCA9548A has three pins dedicated to define its own address, the entire clock could be scaled up to a total of 64 LCDs — so how about a 16×4 display made out of 16×4 displays? Sure, adding smooth scrolling might become a bit tricky at some point, but imagine playing Tetris on that one!
Most Hackaday readers are likely to be familiar with character LCDs driven by the extremely common Hitachi HD44780 controller chip. If you’re looking for a cheap and easy way for your microcontroller project to display some data, they’re pretty much the go-to solution. But as popular as these displays are, there’s no denying that they’re starting to look a bit dated in 2020. Which is why the tweaks [Joseph Rautenbach] is working on are so interesting.
With one of these displays, the controller puts a single character on each 5×8 block of pixels. There’s also support for creating custom characters, which can be used for rudimentary icons. You’re pretty limited by the per-block resolution, but with a little imagination, you can usually get the point across. With a bit of dead space between each block of the display there’s little point in trying to make icons that “bridge” multiple blocks, as they’ll always be segmented.
But as [Joseph] realized, that’s less of a problem for scrolling text. So he wrote some code that takes an ASCII string and breaks it down into partial letters and numbers which can be displayed as custom characters. The controller only has space for 8 of these characters though, so the code needs to continually step through the string and generate the appropriate offset characters as the position of the text changes.
While the effect looks pretty good in the video after the break, [Joseph] has found that real-world utilization is a bit finicky. He tried the same code on one of the displays that uses white text on a blue background, and the scrolling text ended up ghosting together so it looked like gibberish. So while he’s released the source code for others to experiment with this trick, your mileage may vary.
The venerable Commodore 64, is there anything it can’t do? Like many 1980s computer platforms, direct access to memory and peripherals makes hacking easy and fun. In particular, you’ll find serial & parallel ports are ripe for experimentation, but the Commodore has its expansion/cartridge port, too, and [Frank Buss] decided to hook it up to a two-line character LCD.
Using the expansion port for this duty is a little unconventional. Unlike the parallel port, the expansion port doesn’t have a stable output, as such. The port contains the data lines of the 6510 CPU and thus updates whenever RAM is read or written to, rather then updating in a controlled fashion like a parallel port does. However, [Frank] found a way around this – the IO1 and IO2 lines go low when certain areas of memory are written to. By combining these with latch circuitry, it’s possible to gain up to 16 parallel output lines – more than enough to drive a simple HD44780 display! It’s a testament to the flexibility of 74-series logic.
It’s all built on a C64 cartridge proto-board of [Frank]’s own design, and effort was made to ensure the LCD works with BASIC for easy experimentation. It’s a tidy mod that could easily be built into a nice enclosure and perhaps used as the basis for an 8-bit automation project. Someone’s gotta top that Amiga 2000 running the school district HVAC, after all!
The HD44780 is one of the first chips we learned about as a kid, and chances are good you’ve used one in your project at some point, and almost certain that you’ve interacted with one in your life. The character LCD is ubiquitous, easy to interface, and very robust. They come in sizes from 8 x 1 to 20 x 4 and even larger, but they almost all have the same pinout, and there are libraries in many embedded environments for interacting with them. [The 8-Bit Guy] decided to interface with one using just switches and a button, (YouTube, embedded) with the intent of illustrating exactly how to use them, and how easy they are.
Roland’s Alpha Juno 2 is an analog, polyphonic synth made in the mid-80s. While it isn’t as capable as the massive synths made around that time, it was very influential synth for the techno scenes of the late 80s and early 90s.
[Jeroen] is lucky enough to have one of these synths, but like all equipment of this era, it’s showing its age. He wanted to replace the character LCD in his Alpha Juno 2 with an OLED display. The original character LCD was compatible with the Hitachi HD44780 protocol, and still today OLEDs can speak this format. What should have been an easy mod turned into editing hex values on the EEPROM, but he still got it to work.
While the original character LCD could display one line of 16 characters, the ROM in the synth didn’t know this. Instead, the display was organized as a 2×8 display in software, with line one starting at address 0h, and line two starting at 40h. For a drop-in replacement, [Jeroen] would need a display the characters organized in this weird 2×8 format. None exist, but he does have a hex editor and an EEPROM burner.
After burning and installing the new ROM, the OLED display was a drop-in replacement. That meant getting rid of the whiney EL backlight in the original display, and making everything nice and glowy for a few nights on a dark stage.
We really like to see hardware hackers stepping out of the safe and polished boundaries of available Arduino libraries. One example of this is a project which [Matteo] thought worked: using a shift register to drive a character LCD. This can be a desirable way to do things, because it takes the GPIO usage down from six to just three connections. If you don’t remember seeing that one earlier this month take another look. The gist of it is that [Matteo] hacked one function in the LiquidCrystal library to make it happen.
What makes this a truly great fail is that the problem was not immediately apparent, and is difficult to reliably reproduce. The LCD is unstable depending on how the Arduino board is reset. When connecting the Arduino to a computer the screen doesn’t work until you press the reset button. But press the reset button repeatedly and you get a non-functional screen plus the gibberish seen above.
There’s not much to go on here, but we think it’ll be a lot of fun to state your theory on the malfunction and suggesting for testing/fixing the issue. This could be a lot of things, the controller on the display getting mixed-up, the 595 missing an edge (or something along those lines). Do you fix this with hardware (ie: capacitor to avoid voltage dip), a software issue (need a longer delay after startup), or a combination of the two?
Fail of the Week is a Hackaday column which runs every Wednesday. Help keep the fun rolling by writing about your past failures and sending us a link to the story — or sending in links to fail write ups you find in your Internet travels.
Here’s a quick tip to extend the usefulness of your multimeter. It’s a set of mini test hooks soldered to alligator clips with a short hunk of stranded wire in between. You can buy mini test hooks that go right on the metal probes of your meter, but the weight and bulk of the meter probes and cords sometimes get in the way. This rig allows more flexibility because of that wire.
Staying on the theme of test equipment tips, here’s a simple way to make a Y-connector for logic analyzers. [Thomas] uses a dual-row pin header, shorting each pair of pins so that both rows are connected. When this is plugged into a pin socket it leave two pins for connecting your test equipment and the rest of the project hardware.