It’s no secret that the era of the landline telephone is slowly coming to a close. As of 2020, it was estimated that less than half the homes in America still subscribed to plain old telephone service (POTS). But of course, that still amounts to millions upon millions of subscribers that might get a kick out of this Arduino caller ID developed by [Dilshan Jayakody].
Truth be told, until this point, we hadn’t really given a lot of thought to how the caller ID system works. But as [Dilshan] explains, you can actually pick up a dedicated IC that can decode incoming caller data that’s sent over the telephone line. In this case he’s using a Holtek HT9032D, which comes in a through-hole DIP-8 package and can be picked up for around $2 USD. The chip needs a handful of passives and a 3.58 MHz crystal to help it along on its quest, but beyond that, it’s really just a matter of reading the decoded data from its output pin.
To display the caller’s information, [Dilshan] is using an Arduino Uno and common 16×2 HD44780 LCD. As a nice touch, the code will even blink the Arduino’s onboard LED when you’ve missed a call. As a proof of concept there’s been no attempt to condense the hardware or ditch the breadboard, but it’s not hard to imagine that all the components could be packed into a nice 3D printed enclosure should you want something a bit more permanent.
We’ve seen caller ID data being collected in previous projects, but they used a USB modem combined with a software approach. We really like the idea of doing it with a cheap dedicated IC, though we’ll admit this demonstration would probably have been a bit more exciting a decade ago.
Nothing feels better than getting a salvaged component to do your bidding. But in the land of electronic displays, the process can quickly become a quagmire. For more complex displays, the secret incantation necessary just to get the things to turn on can be a non-starter. Today’s exercise targets a much simpler character display and has the added benefit of being able to sniff the data from a functioning radio unit.
When [Amen] upgraded his DAB radio he eyed the 16×2 character display for salvage. With three traces between the display and the controller it didn’t take long to trace out the two data lines using an oscilloscope. Turing on the scope’s decoding function verified his hunch that it was using I2C, and gave him plenty of data to work from. This included a device address, initialization string, and that each character was drawn on screen using two bytes on the data bus.
He says that some searching turned up the most likely hardware: a Winstar WO1602I-TFH- AT derived from an ST7032 controller. What we’re wondering is if there is a good resource for searching this kind of info? Our go-to is the LCD display and controller reference we covered here back in March. It’s a great resource, but turns up bupkis on this particular display. Are we relegated to using DuckDuckGo for initialization strings and hoping someone’s published a driver or a logic dump of these parts in the past, or is there a better way to go about this? Let us know in the comments!
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.