Smooth(er) Text Scrolling On HD44780 LCDs

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.

Hardware support is not guaranteed.

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.

This certainly isn’t the first time we’ve seen somebody make clever use of custom characters on the HD44780. We’ve seen it used for an exceptionally tiny game of Tetris, a rendition of Conway’s Game of Life, and even a horizontal space-shooter.

Continue reading “Smooth(er) Text Scrolling On HD44780 LCDs”

Fail Of The Week: Reset Issues With 595 And HD44780

fotw-reset-issues-595-character-lcd

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?


2013-09-05-Hackaday-Fail-tips-tileFail 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.

Using An HD44780 Character LCD With The Raspberry Pi

[Tech2077] is one of the lucky ones who already got his hands on a Raspberry Pi. He’s been looking into different interface options with the GPIO header and just posted a guide to using an HD44780 character display with the RPi. We like this approach because instead of doing some hard-core LCD work he’s using prototyping equipment you probably already have on hand.

Getting a character LCD running should be really simple. The gotcha is the logic level gap between the devices. If you’ve been working with Arduino, your add-ons are probably meant for a 5V power rail  and logic levels. The RPi outputs 3.3V logic. You could use a level converter (you’d need at least 7 pins to be converted in this case) or you can be a bit more clever. [Tech2077] grabbed an I2C port expander that uses just 2 of the RPi lines to address even lines of the display (four data bits plus three control bits). This is a bit of a hack, as the 3.3V logic is 0.2V below the recommended minimum for a digital 1 on the port expander. But it seems to work just fine! If it didn’t, a couple of NPN transistors would do the trick as well.

Addressing the new peripheral is just a matter of loading the i2c module and writing some Python.

Spectrum Analyzer Users Custom Characters On An HD44780 Display

[Camilo] built a spectrum analyzer to use with his audio system (translate). The hardware is quite simple, using an op-amp, microcontroller and LCD display. He chose an LMV324M low-voltage op-amp which connects to the incoming audio signal and feeds its output to the microcontroller’s ADC. In this case, he chose a Freescale microcontroller from the HCS08 family which is running at 20 MHz. This gives the project enough speed to properly analyze the incoming audio. He mentions that he’s following the guidelines set forth in the Nyquist-Shannon sampling theorem and using the Fast Fourier Transform when processing the samples.

This isn’t the first time we’ve seen a character LCD used as a display for a frequency analyzer. This other ATmega8-based rendition supported several different screen layouts. These displays have enough RAM to store eight custom characters. Each character is 5×8 pixels, lending eight levels to each character for a total of 16 for each column seen above. We love the simplicity of the hardware in the project but we wouldn’t mind seeing an additional potentiometer to fine-tune how the data is displayed on the screen to take advantage of its full range. See the project in action in the clip after the break.

Continue reading “Spectrum Analyzer Users Custom Characters On An HD44780 Display”

Character VFD Becomes Spectrum Analyzer

These days, streaming services are a great way to listen to music or podcasts on your computer or on the go. However, they lack one feature of the MP3 players and streamers of old: visualizations! [mircemk] is a fan of those, and has built a hardware spectrum analyzer that pumps with the music.

The build relies on a 20×2 character VFD display that looks great, with high brightness and excellent contrast. It can be easily driven from a microcontroller, as it has a controller on board compatible with the typical HD44780 command set. On Arduino platforms, this means the display can easily be driven with the popular LiquidCrystal library.

The Arduino Nano inside takes in the audio signal via its analog inputs. It then processes the audio with the fix_fft library, which runs a Fast Fourier Transform in order to figure out the energy level of each frequency bin in the audio spectrum for both the left and right channels. This data is then sent to the screen for display. It’s impressively fast and smooth, with the display dancing along with the beat nicely as [mircemk] tests it out with some tunes.

If it looks familiar, it’s because it’s an updated version of a prior project from [mircemk]. We saw it previously as a VU meter that pulsed with the beat, an altogether simpler visualization but still a cool one. Video after the break.

Continue reading “Character VFD Becomes Spectrum Analyzer”

ESP32 composite library with LVGL demo. (Credit: aquaticus)

Generating Composite Video On ESP32 With LVGL GUI

RCA connector mounted to ESP32 board. (Credit: aquaticus)
RCA connector mounted to ESP32 board. (Credit: aquaticus)

Just because a microcontroller doesn’t have a dedicated video peripheral doesn’t mean it cannot output a video signal. This is demonstrated once again, this time on the ESP32 by [aquaticus] with a library that generates PAL/SECAM and NTSC composite signals. As a finishing touch on the hardware side, [aqaticus] added an RCA jack is an optional extra. The composite signal itself is generated on GPIO 25, with the selection from a wide number of PAL and NTSC resolutions.

In addition, LVGL support is integrated: this is an open-source library that provides a cross-platform way to provide graphical UIs for embedded platforms. Using this combination any ESP32 can generate a fully graphical UI on a monochrome or color display to add some extra flair and functionality to an ESP32 project.

Currently, this library does not support color output, but hopefully this will be added in the future. Even so, together with simple VGA output using a DAC, this library provides yet another way to add analog video output to ubiquitous MCUs like the ESP32. Even if these MCUs are not going to be decoding any video formats at a reasonable speed, adding a UI that’s more user-friendly than an HD44780-based display and a few buttons can really elevate the user experience.

VFD Character Display Turned Into Audio VU Meter

Humans love visualising music, whether it’s in the form of an inscrutable equation drawing squiggles in Winamp, or a simple VU meter pulsing with the beat. This build from [mircemk] is of the latter variety, repurposing a VFD display to do the job.

The project is built around a VFM202MDA vacuum fluorescent display, which provides that lovely green-blue glow we all know and love, driven by a PT6314 driver chip. This has the benefit that it can be readily driven by a microcontroller in much the same way as the familiar HD44780 character LCD driver chip. With some minor tweaks, the character set can be modified to allow the display to become a surprisingly-responsive VU meter.

An Arduino Nano runs the show, with an envelope follower circuit feeding a signal for the left and right channels into the analog inputs of the microcontroller. The Arduino then measures the voltage on those inputs and feeds the necessary commands to the PT6314 driver to update the display.

The resulting VU meter has 38 bars per channel, and is highly responsive. The fast flickering of the meter bars in response to the music make it compelling to watch, and the era-appropriate enclosure the project is built in adds plenty to the aesthetic.

We’ve seen other VU meter builds before too, like this one that uses a little physics knowledge to create a more realistic analog-like needle meter. Video after the break.
Continue reading “VFD Character Display Turned Into Audio VU Meter”