Not content with only knowing the time, [trandi] decided his Vacuum Fluorescent Display clock would be much better if it displayed the weather and a Twitter feed.

[trandi] received a Lady Ada Ice Tube clock last month. The kit went together almost too easily. Now he had to, “make it connect to other ‘stuff’ and display some custom messages.” After playing with the firmware to display a Hello World, [trandi] mucked around with the GPS mod and figured out how to add scrolling text over a serial connection.

A serial connection to an Internet-connected computer is all well and good, but [trandi] really wanted a stand-alone solution. A tiny WiFi to RS-232 board was sourced and the work of getting a clock on the internet began in earnest. After a weekend was wasted trying to debug the HTTP mode of the WiFi board, [trandi] gave up and used TCP mode with manually constructed HTTP headers.

The clock gets the current weather and a Twitter feed. To one-up to the Ice Cube GPS mod, the clock now sets its own time from the Internet. Check out the video of [trandi] showing off his Internet clock and fine collection of single malts after the break.

[Mostafa] was a bit bored and had a broken DVD player sitting around, so he decided to take it apart to see what made the machine’s LCD panel tick. Once he popped it open, he discovered it wasn’t an LCD panel at all, it was a VFD.

The seven segment display looked to be controlled by an ET16312n VFD driver, so he dug around online and found a datasheet for the chip. After looking at the documentation he was pretty confident he could get things working without too much trouble. He started tracing the board for the STB, CLK, Din, and Dout leads he needed to set up serial communications with the panel and was on his way in no time.

He hooked the panel up to the parallel port on his computer, and got busy hammering out some C code to write text to the display. Right now, the code lets you scroll text across the display, which is about as far as [Mostafa] cares to take it. It was done mostly as a proof of concept exercise, but since this VFD is compliant with the same NEC programming standard that most VFDs use, his code can likely be reused to drive any similar display with very little tweaking.

We all love getting a good deal on sweet parts, but not all of them are documented. Some of us have trained our eyes and brains to spot “timesinks”, having been burned before. The rest sit down with whatever pile of stuff they have on hand, and figure out how to talk to that HP Media Center VFD.

[Jayeson] found some good deals on some Vacuum Fluorescent Displays from a HP Media Center computer as “new”, from some (unmentioned) shady dealers. Once receiving his B stock displays he needed to figure out a way to make them work.

Fun and excitement includes: figuring out the pins, first attempts of communication, getting the data sheet for a house brand chip… that still has the Atmel stamp on it, sniffing traffic with a logic analyzer, and deciphering that data. All that while being a pretty interesting read, good showing of willpower, and resulting in a couple Arduino Libraries as a bonus.

Clocks are relatively simple devices – they tell time, and most often sport a handful of other utilitarian features like alarms and radios. Rarely though, do you see a clock that will wake you up in the morning and also curse at you shortly thereafter. [Matt Evans] clearly thought that clocks need to pack a little more attitude, so he built his girlfriend a clock that not only tells time, but spouts off nasty phrases as well. What a lucky gal!

The clock was constructed using IV-17 VFD tubes, each bearing 16 light-able segments. It seemed wasteful to simply use the tubes to tell time, so [Matt] got busy adding other features to the clock. It has an alarm, a calendar that is always stuck on his girlfriend’s birthday, and an ambient light sensor to dim the tubes at night. It also sports a variable rudeness setting, allowing for mild insults when family members are present, and extremely foul language for when your frat brothers swing by.

He has plenty of pictures on his site, but we’re betting people will want to see schematics and some source code. After all, Mother’s Day is but a few months away!

[uhclem] was looking for a novel yet easy way to remind his kids to do their chores, and instead of using a series of post-it notes, he constructed a nice wireless Arduino-powered message board.  The message board is powered by an Arduino Pro, and communicates with his computer via a pair of series 1 Xbee radios which relay a series of canned messages to an attached VFD.  He installed all of the components in an old cigar box, and mounted it on the wall, making for a nice overall presentation.

Programming of the messages does not require any special software as the user interface is handled by the Arduino and accessed via a standard terminal session. [uhclem] mentions that the his code consumes nearly all of the device’s RAM when running, so he keeps a handful of canned messages stored in the Arduino’s flash memory, recalling them when needed.  The optional EEPROM is used to allow for streaming messages to the device as well.

[Alessandro Lambardi] had some vacuum flourescent displays that he pulled from junked VCRs. His latest project is an experiment to use one of the VFDs as a headphone amplifier. This means he’s trying to use them as vacuum triode amplifiers, aka vacuum tubes. He did get it to work but as he suspected, the output is fairly low power. It may be possible to use this setup as a preamp and build an actual tube amp to use along with it.

Update: Thanks to [Fallen] for mentioning that we’ve covered this concept in the past.

[Thanks Muris]

[Brian] wrote in to show us a site he’s been working on for a while. He’s been building a tube clock database. We didn’t realize there was actually a big enough draw for such a site, but we have to admit that we spent more than a few minutes browsing through the different clocks. There isn’t a ton of data for each clock, but there are links to individual project pages wherever available. There is also a growing amount of information on the different components themselves, so submit any data you have that he’s missing to help flesh it out.

The video above wasn’t chosen for any reason other than it is quite stylish.

We honestly thought [Jason's] VFD clock was some form of new terrorist attack when we came across the RSS. Thank goodness our relations with Russia aren’t as MAD as they used to be.

The main components are an IV-18 VFD with a MAX6921 driver, which to an untrained ear do sound surprisingly threatening. However an Arduino settles our hearts down and assures us this only has as much potential as blinking a VFD. While the main code, schematics, and CAD aren’t available (open source coming to a theater near you soon) at the moment – you can check out [Jason's] inspiration, the Ice Tube Clock, which runs many of the same components.

Enjoy a video of it in action after the break. We love the ‘countdown’ feature the most.

[via Make]

Nixie tubes make for fun projects but the fun can’t start until you get your hands on the hardware. Well, [Dieter's] got you covered with his one-stop repository on Nixie tubes and where to get them. We know that Woz’s watch isn’t currently available because of a lack of tiny tubes an obsolete accelerometer. Ladyada’s Ice Tube Clock depends on a rare 8-digit VFD tube. But you can get around parts obsolescence by adapting these designs for an available replacement. So when you take on the Dekatron Timer or a Bottled Nixie Clock you’ll know where to turn for the goods.

Update: Our mistake about Woz’s watch.  It wasn’t a tube shortage that put it out of production.

[Thanks Aaron]

Looks like they’re at it again over at Adafruit. This time they’ve produced a clock that looks more like it should be attached to a munition rather than cruising bedside. But, geek-cred aside, there’s a lot to be learned from their design. Like we’ve grown to expect, they’ve put together some good documentation on their choice of components.

Start off by taking a peek at their 5v power regulator. There is an extra diode on the output side that prevents reverse current from the 3v backup battery. The AVR ATmega168 that controls the clock is used to detect loss of power and quickly shift to the battery backup. They’ve also used the  microcontroller as a boost converter for the high voltage VFD, a nice trick we’ve seen before.

[Thanks pt]

[Agent420] brought up this touchpad and VFD hack in the comments on our capicitive sensor guide post. He had broken dell laptop from which he harvested the touchpad and an HP laserjet that contributed the VFD. Though the touchpad communicates using standard PS2 protocol, he wanted to use it with his Atmel 8535 AVR which required him to write some custom code. In the picture above, you can see the VFD displaying the coordinates of his finger. You can download his code as well as the spec sheets for the different pieces on the project thread.

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

We love old display technology, like Nixie tubes, but they’re often difficult to work with because they require higher voltages than digital logic. Vacuum florescent displays (VFD) fall into this category. While not necessarily “old”, they are becoming far less common than LCDs. The main benefit of a VFD is that it actually produces light directly; it doesn’t require a backlight. You’ll find these displays on various players and appliances: CD, DVD, VCR, microwaves, stoves, car headunits, and others.

[Sprite_tm] had written off some VFDs, but recently revisited them with renewed interest. He started by testing what sort of voltage would be required to drive the display. It took 3V for the filament plus 15V to drive the grids. There are VFD controller chips available, but he wanted to get this working with what he had on hand. He had experience with older 40xx series logic, which can be powered by much higher voltages than 5V 74xx. His final schematic has three 4094 serial to parallel chips with an ATtiny2313 controller. A 5V power supply is dropped to 3V with diodes to drive the filament while a boost converter brings it up to 15V for the 4094s that switch the segments. While the code is specific to this display, it would be a great place to start your own project.

[HP Friedrichs] sent us this cool writeup on how to use scrapped Vacuum Fluorescent Display tubes as amplifiers. For those unfamiliar, a VFD is a display device common to electronics.  Many have been replaced by LCD, but you can still find them in modern products. [Friedrichs] points out that his 2008 ford has a VFD for the multimedia display.

Since these units are basically tubes, he figured that you should be able to use them as a tube amp. After some testing, he found it to be quite adequate.  The project includes tons of background information on how tubes work, how VFDs work and how to utilize it for amplification. In the picture above, you can see him using one (middle) to amplify a home made radio (right).