[El Artis] just finished building an audio spectrum analyzer that uses a character LCD. The uses an Arduino to drive the display, but unlike other meters that use the microcontroller for analysis, [El Artis] is using a discrete IC for that task.

This project uses the MSGEQ7 graphic equilizer display filter chip to grab frequency data from the audio source. The chip connects to your microcontroller of choice using two digital pins and one analog pin. [El Artis] points us to [J Skoba's] post about how to use it with an Arduino, then adds his own custom character routines for an HD44780 display. You’ll notice that there are sixteen bars in the image above, which conflicts with the 7 outputs the chip offers. [El Artis] averages neighboring values in order to add the extra outputs.

Don’t miss the demo video after the break. If you’re looking to use this part in one of your projects, we noticed they’re a little hard to find (octopart doesn’t return any suppliers) but SparkFun has them.

[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.

[Sergio] is just getting into hardware hacking. He started by getting an HD44780 compatible LCD screen running with his Arduino. To take the project to the next level, he decided to add a web interface for changing the message displayed on the LCD.

He’s doing things on the cheap (a man after our own hearts), purchasing many of his components off of eBay. Unfortunately that decision came back to bite him when it was time to connect his Arduino to the network. The Ethernet Shield knock-off wasn’t the same as the official version. That one’s got a Wiznet W5100 ethernet chip with does a lot of the heavy lifting for you. Instead, [Sergio] is using a board with an ENC28J60. It took a bit of searching, but eventually he came up with an example to help him get his Arduino serving web pages and listening for updates from them.

The ENC28J60 is actually not a bad piece of hardware. It’s cheap enough, and there are a few hardware/software demos out there that are worth taking a look at.

If you don’t have a 9-to-5 type of job you might find yourself constantly resetting your alarm clock as your calendar commitments change. [Lucas] finally got fed up with the nightly ritual and decided to build his own alarm clock which has unique settings for each day of the week (translated).

The display itself is an LM044L 20×4 character display. This provides a viewing area that is about 3″x1″ and since it’s an HD44780 compliant LCD screen, writing data to it takes very little effort (and RAM) compared to a graphic LCD. A PIC 18F2550 drives the device, taking input from a half-dozen buttons, driving the display, and turning on the enclosed buzzer when it’s time to get up. There’s a backup battery which will keep the settings when power is lost. The daily alarms, current time, and back light brightness can all be adjusted from the four screens that make up the settings menus. The only thing that it’s missing is a precision timekeeper, but that should be easy to add either by measuring the frequency of the mains or by using an RTC chip.

This hack is a bit older, but one aspect of the setup makes it worth sharing. Shift registers are a common component to include in a project when you need to increase the number of I/O pins available. We’ve used them to drive LCD screens before, but we never realize you could use a 595 chip to make a 3-wire serial LCD interface. That’s because we’ve always thought of shift registers as having three control pins which must be addressed: data, clock, and latch. But it seems that’s not the case. This hack gangs the pins for clock and latch (called the storage register clock input on this chip) together. This causes the shifted data to be latched to output register one clock cycle after it is shifted into the chip.

This means you can operate the 595 chip with just two pins, but alas, you do need one more connection to drive the LCD properly. This is an HD44780 compliant display. It is being used in 4-bit mode; four of the shift register pins provide that data, while a fifth controls the Register Select pin. Since the shifted data from the 595 appears on the pins after each clock strobe, you must control the Enable pin on the LCD separately or it will behave sporadically.

So there you have it, control an HD44780 display with just 3-pins by using a $0.42 part. Are we going a little too fast for you? Check out this 595 tutorial and give the shift register simulator a try. That should bring you up to speed.

[Thanks Rajendra]

This time-lapse photo trigger was built [Lukasz Goralczyk]. It is controlled by an ATmega168 and we were surprised to read that it uses about 12k of code. Curious about what takes up that much space, we were impressed to see all the features demonstrated in the video after the break. The small device, running on two AA batteries, has a well-designed user interface displayed on a 3V character LCD that is navigated with a clickable rotary encoder.

It isn’t the smallest intervalometer we’ve ever seen, but it deserves respect for the features packed into a diminutive form-factor.

[Thanks Michal]

Inside this box you’ll find a La Fonera wireless access point. [Emeryth] and his band of miscreants built this portable device for WiFi security testing. The AP is running OpenWRT and has been set up to use the 16×4 character display as a terminal. An ATmega88 connects the LCD as well as six buttons to the UART of the La Fonera. From there, a set of Ruby scripts takes care of the communication protocol. As you can see after the break, this setup allows you to scan the area for WiFi, showing channel, SSID, and MAC information. Although not specifically outlined in the video we suspect there’s some more devious tricks up its sleeve too.

Take that cheap fire stick you call a soldering iron and turn it into a real tool. [Giorgos Lazaridis] turned his 30 watt soldering iron into a temperature controlled soldering station by adding a thermistor just above the tip to monitor how hot things are getting. A MAX6675 takes care of the thermocouple and shoots a digital temperature value off to the PIC 16F88 which controls the unit by taking user input from a potentiometer and displaying the settings on an HD44780 character display. His use of a dissected ‘wall wort’ inside of the ATX power supply carcass used as the case for the station is a clever hack. See it melt some metal in the clip after the break.

This makes a nice upgrade to our solder station guide, which had a temperature controlled iron but lacked the sensor and automation seen here.

[Manekinen] built a power supply monitor based around an AVR ATtiny13. Voltage and amperage are displayed on a 16×2 LCD character display (we’re not sure what the third number is… samples per second?). This is no small feat considering that the tiny13 is an 8-pin chip. He makes it happen by using the pins for both LCD control and ADC input. To make this happen the HD44780 compliant display is used in 4-bit mode. Check out the video after the break and hit up the non-translated page if you want to download the source code and PCB artwork. A note of warning, he’s using the RESET pin for I/O which means once you burn the fuses you’ll need a programmer that has High Voltage Serial Programming capabilities if you want to reprogram the chip.

[Thanks RicoElectrico]

One of the best feelings in the world is when one of our posts inspires a fellow hacker to plan, create, and execute his or her own project.

[Russ] let us know about his Frustromantic Box which he gained inspiration from the original Reverse Geochache we posted about. For those out of the loop, the box is locked and will only open in a certain location. The current distance to the  location is displayed on the screen when a button is pressed, and usually there is a limited number of button presses (3 presses for those that know geometry, 50 for everyone else). As soon as the box is at location, it will open.

The Frustromantic Box uses an Arduino, classic HD44780 display, a servo, and the pièce de résistance EM406 GPS. All built in time to frustrate his wife for Christmas.

[Manekinen] built a very responsive spectrum analyzer. The components at the party are what you’d expect, an ATmega8 does the hard work interpreting data from the LM324 op-amp. This build stands out because it is fast and configurable. In fact, the explanation of the calibration process is where this project shines.

Instead of using water, an HD44780 module displays the spectrum data. The device currently supports several different character displays including 16×2, 20×2, 24×2, and 20×2. We’ve embedded a video of a 20×4 VFD in action after the break. As the video progresses, watch for the Polish words that pop up. This corresponds to the brightness and sensitivity being adjusted with the 5-button keyboard.

Futaba makes vacuum florescent character displays that can be used as a drop-in replacement for common character LCDs. VFDs have a wider viewing angle, and generally look cooler.

Futaba’s character displays can be interfaced using the standard 8-bit or 4-bit parallel LCD interface, or a simple two-wire protocol. The protocol type is set by resistors on the back of the display, so it’s not particularly easy to change without a hot-air rework station. Today we’ll demonstrate a serially-interfaced VFD using the Bus Pirate.

Futuba VFD character LCD replacement (NA204SD02, $7.00). Datasheet (PDF).

We used our Bus Pirate universal serial interface to demonstrate the Futaba VFD, but the interface operations will be the same for any microcontroller implementation. The connections we made between the VFD and the Bus Pirate are shown in the table above.

We setup the Bus Pirate for raw2wire mode (menu M, 7) with open drain outputs (HiZ). The open drain outputs let us interface the 5volt VFD from the 3.3volt Bus Pirate using the on-board pull-up resistors (menu P, 2). Finally, we enabled the on-board power supply (capital ‘W’).

The VFD’s strobe pin is connected to the Bus Pirate CS pin.  The auxiliary pin doesn’t have it’s own pull-up resistor but CS does. CS is otherwise unused in raw2wire mode, so we reassigned the auxiliary commands to the CS pin (menu C,2).

Interfacing

The two-wire interface uses a straight-forward 16bit (2byte)  protocol (datasheet page 20). The LCD control bits (R/W, RS) go in the first byte, and eight data bits go in the second. All transactions start with strobe low and end with strobe high. Read operations are similar to writes, except the R/W bit is set and the second byte is read.

The Futaba VFD accepts all the standard HD44780 LCD commands (datasheet page 27), see these tables for a detailed description of each command. After a reset (power-up), the VFD expects the first command to be the function set command.

RAW2WIRE>@ <–start with strobe high
AUX HIGH IMP, READ: 1 <– aux pin (CS) is now input, pull-up resistor holds strobe high
RAW2WIRE>a 0b11111000 0b00111000 @ <–command
AUX LOW <–strobe low
WRITE: 0xF8 <–start byte (R/W=0, RS=0)
WRITE: 0×38 <–instruction byte (function set)
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

Function set configures the data interface length (bit 4), display lines (bit 3), and brightness/luminescence (bits 1,0).  Before we start we set the strobe pin high (@) in case it’s currently low. Then, we start the transaction by taking the strobe pin low (a), and send the first byte with the R/W and register select (RS) settings.

The second byte is the command. We set the data interface length to 8bits (bit 4 = 1), but in serial mode this is probably ignored. Our display has multiple lines (bit 3 = 1), and we set brightness to full (bits 1,0 = 0). The sequence concludes when the strobe pin returns high (@).

RAW2WIRE>a 0b11111000 0b00001111 @
AUX LOW <–strobe low
WRITE: 0xF8 <–start byte (R/W=0, RS=0)
WRITE: 0x0F <–instruction byte (display on/off control)
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

The display ON/OFF command enables the display (bit 3), toggles the cursor (bit 1), and blinks the cursor (bit 0). We enabled the display (bit 3 = 1) with a blinking cursor (bit 1,0 = 1) so it’s obvious that the display is working.

RAW2WIRE>a 0b11111000 0b10000000 @
AUX LOW <–strobe low
WRITE: 0xF8 <–start byte (R/W=0, RS=0)
WRITE: 0×80 <–instruction byte (DDRAM address set)
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

Before writing characters to the display we need to position the cursor by sending the DDRAM address set command (0b10000000) summed with the desired cursor position. We set the cursor to the first character on line 1.

The second character on line 1 is located at 0×01. To set this address we’d send 0b10000001 (0b10000000 +0b00000001).

Character display memory isn’t linear, the first line starts at 0×00, the second line starts on position 0×40, the third at 0×14, and the last line begins with position 0×54. Most displays have a similar configuration, here’s some tables for determining the layout of different character displays.

RAW2WIRE>a 0b11111010 0×48 0×61 0×63 0x6b 0×20 0×61 0×20 0×44 0×61 0×79 @
AUX LOW <–strobe low
WRITE: 0xFA <–start byte (R/W=0, RS=1)
WRITE: 0×48 <–ASCII letter ‘H’
…
WRITE: 0×79 <–ASCII letter ‘y’
AUX HIGH IMP, READ: 1 <–strobe high
RAW2WIRE>

Finally, we can enter some characters at the position set with the previous command. Characters are entered as their ASCII equivalent values. We displayed “Hack a Day” with proper capitalization.

Multiple characters can be entered at once, but because the memory space isn’t contiguous it’s necessary to manually position the cursor at the beginning of each new line. After writing the last position of line 1, the cursor will advance to the first character of line 3. Use another position command, 0b10010100, to set the cursor to the beginning of line 2 (0b10000000 + 0×14 = 0b10010100).

Like this post? Check out the parts posts you may have missed. Want to request a part post? Please leave your suggestions in the comments.

Hack a Day review disclosure: We bought the serial VFD demonstrated here on eBay, Futaba also sent us a sample with a parallel interface that we’ll demo later (shown here).

[conville] has been pushing standard HD44780 character displays to the limit. Embedded above is an example spectrum analyzer and text scrolling demo. Below you’ll find a scope demo. Both of these are created using a PIC 16F688 that dynamically rewrites a custom character set to create the animation. You can find the source code on mikrocontroller.net.

[Warner] used a HEF4094 chip to group the lines together and a variable resistor to control the contrast. A zip file with the requisite code to make this work can be found in the post.

[via YourITronics]