Posts with «vfd» label

Vintage vacuum fluorescent display controlled with Arduino Due

Vacuum fluorescent displays (VFDs) have a distinct cool blue-greenish glow, and were once used in a wide range of devices, from VCRs to microwave ovens and even car dashboards. Although extremely popular way back when, they can be more difficult to source today. In the video below, Scotty Allen of the Strange Parts YouTube channel takes on the challenge of getting a $600 ISE (now Noritake) display up and running with an Arduino Due.

The process starts with examining the datasheet to find that the Due’s 3.3V logic can indeed drive the 20×2 character display, then he constructs a custom adapter board to do just that. After more datasheet lurking, head scratching and hacking, he finally got it to show “Hello world!” toward the end of the clip, along with some simple animations. 

The VFD control is part of a larger build that will be revealed in the future, and a good reminder of just how much trial and error is needed to succeed in making something awesome.

Stylish Alarm Clock Rocks a VFD

There are a great many display technologies available if you wish to make a digital clock. Many hackers seem to have a penchant for the glowier fare from the Eastern side of the Berlin Wall. [ChristineNZ] is one such hacker, and managed to secure some proper Soviet kit for an alarm clock build.

The clock employs an IV-27M vacuum fluorescent display, manufactured in the now-defunct USSR. Featuring 13 seven-segment digits, it’s got that charming blue glow that you just don’t get with other technologies. A MAX6921AWI chip is used to drive the VFD, and an Arduino Mega is the brains of the operation. There’s also an HD44780-compliant LCD that can display further alphanumeric information, and a 4×4 keypad for controlling the device.

The best part of the build though is the enclosure. The VFD is encased in a glass tube, and supported at either end by 90-degree copper pipe couplers. These hold the VFD aloft, and also act as a conduit for the wires coming off each end of the tube. It’s all built on top of a wooden base that holds the rest of the electronics.

It’s an attractive build, and we love the floating look created by the glass tube construction. It’s not the first time we’ve seen old Russian VFDs, and we doubt it will be the last. Video after the break.

Th

CNC Machine Boasts Big Bed, Impressive Power from Off-the-Shelf Parts

A lot of homebrew CNC machines end up being glorified plotters with a router attached that are good for little more than milling soft materials like wood and plastic. So if you have a burning need to mill harder materials like aluminum and mild steel quickly and quietly, set your sights higher and build a large bed CNC machine with off-the-shelf components.

With a budget of 2000 €, [SörenS7] was not as constrained as a lot of the lower end CNC builds we’ve seen, which almost always rely on 3D-printed parts or even materials sourced from the trash can. And while we certainly applaud every CNC build, this one shows that affordable and easily sourced mechatronics can result in a bolt-up build of considerable capability. [SörenS7]’s BOM for this machine is 100% catalog shopping, from the aluminum extrusion bed and gantry to the linear bearings and recirculating-ball lead screws. The working area is a generous 900 x 400 x 120mm, the steppers are beefy NEMA23s, and the spindle is a 3-kW VFD unit for plenty of power. The video below shows the machine’s impressive performance dry cutting aluminum.

All told, [SörenS7] came in 500 € under budget, which is a tempting price point for a machine this big and capable.


Filed under: cnc hacks
Hack a Day 15 May 12:00
arduino  cnc  cnc hacks  extrusion  gantry  gerbl  steppers  vfd  

VFD Clock Only Speaks Romanian

There’s no shortage of clock projects, but [niq_ro] has his own take using a vacuum fluorescent display (VFD), and Arduino, and a pair of MAX6921 ICs. Those chips are made to drive a VFD, and the use of two of the ICs required a bit of work. The Arduino is not a great time keeper, so the clock also uses a DS3231 clock module and a humidity and temperature sensor.

The clock is in Romanian, although there are some options for different text. You can find the code on GitHub and can see the result in the video below.

VFDs are often used in places where a display is meant to be read outdoors. It uses cathodoluminescence to actually generate light. The process is similar to a CRT, but at lower voltages. The tubes have a phosphor-coated anode and the cathode bombards it with electrons, making the phosphor glow. VFDs are available in different colors.

VFDs are popular for clocks, ranging from very polished looking ones, to something similar to this one, but with an MSP430. If you are interested in low-level interfacing for VFDs, we’ve talked about that too.


Filed under: Arduino Hacks, clock hacks

Using older Noritake Itron VFD modules

Introduction

Now and again you come across interesting parts on ebay, from friends or just rooting around in second-hand stores. One example of this was a huge Noritake Itron 40 x 2 character vacuum-fluorescent display from 1994 (or earlier) which was passed on from a client. Originally it looked quite complex, however after spending some time the data sheets were found and it was discovered to have a simple serial interface – and with a little work we’ve got it working, so read on if you’re interested in classic VFDs or have a similar unit.

Getting Started

The model number for our display is CU40026SCPB-T20A. Here’s a quick walk-around, the front:

… the back:

… the interfaces:

… and configuration jumpers:

The serial interface baud rate is determined by the jumpers (above), for example:

So comparing the table above against the jumpers on our module gives us a data speed of 19200 bps with no parity. Great – we can easily create such a connection with a microcontroller with a serial output and 5V logic levels; for our examples we’ll use an Arduino-compatible board.

Wiring up the VFD is simple – see the white jumpers labelled CN2 as shown previously. Pin 1 is 5V (you need an external supply that can offer up to 700 mA), pin 2 to Arduino digital pin 7, and pin 3 to Arduino and power supply GND. We use Arduino D7 with software serial instead of TX so that the display doesn’t display garbage when a sketch is being uploaded. Then it’s a matter of simply sending text to the display, for example here’s a quick demonstration sketch:

// Working with Noritake Itron VFD modules - model CU40026SCPB-T20A
// John Boxall 2013

#include <SoftwareSerial.h>
SoftwareSerial VFD(6,7); // RX, TX

void setup()
{
  VFD.begin(19200);
}

void loop()
{
  VFD.print("Hello, world. This is a Noritake VFD "); // You can blast out text 
  do {} while (1);
}

… and the results:

If you’re not keen on the colour or intensity of the display, try some Perspex over the top – for example:

Controlling the display

At this point you’ll need the data sheet, there’s a couple you can download: data sheet onedata sheet two. As you saw previously, writing text is very simple – just use .print functions. However you may want to send individual characters, as well as special commands to control aspects of the display. These are outlined in the data sheet – see the “Software Commands” and “Character Fonts” tables.

If you need to send single commands – for example “clear display” which is 0x0E, use a .write command, such as:

VFD.write(0x0E); // clear display

Some commands are in the format of escape codes (remember those?) so you need to send ESC then the following byte, for example to change the brightness to 50%:

VFD.write(0x1B); // ESC
    VFD.write(0x4C); // brightness
    VFD.write(0x40); // 50% brightness

Armed with that knowledge and the data sheets you can now execute all the commands. According to the data sheet it is possible to change fonts however no matter what the hardware jumper or command we tried it wouldn’t budge from the Japanese katakana font. Your screen may vary. If you use the “screen priority write” function heed the data sheet with respect to the extended “busy” time by delaying subsequent writes to the display by a millisecond.

 Putting it all together

Instead of explaining each and every possible command, I’ve put the common ones inside documented functions in the demonstration sketch below, which is followed by a quick video of the sketch in operation.

// Working with Noritake Itron VFD modules - model CU40026SCPB-T20A
// John Boxall 2013

#include <SoftwareSerial.h>
SoftwareSerial VFD(6,7); // rx, tx

void setup()
{
  VFD.begin(19200); // set speed for software serial port 
  resetVFD();  
  VFDclearsceen();
//  VFD.write(0x12); // vertical scroll mode (on)
}

void resetVFD()
// performs a software reset on the VFD controller
{
  VFD.write(0x1B); // ESC
  VFD.write(0x49); // software reset
}

void VFDnewline()
// moves cursor to start of next line
{
  VFD.write(0x0D); // carriage return
  VFD.write(0x0A); // line feed
}

void VFDclearsceen()
// moves cursor to top-left and clears display
{
  VFD.write(0x0E); // clear display 
  VFD.write(0x0C); // form feed - cursor to top-left
}

void VFDbrightness(int amount)
// sets VFD brightness - 25/50/75/100%
// uses ESC sequences
{
  switch(amount)
  {
  case 25:
    VFD.write(0x1B); // ESC
    VFD.write(0x4C); // brightness
    VFD.print(0); // 25% brightness
    break;
  case 50:
    VFD.write(0x1B); // ESC
    VFD.write(0x4C); // brightness
    VFD.write(0x40); // 50% brightness
    break;
  case 75:
    VFD.write(0x1B); // ESC
    VFD.write(0x4C); // brightness
    VFD.write(0x80); // 75% brightness
    break;
  case 100:
    VFD.write(0x1B); // ESC
    VFD.write(0x4C); // brightness
    VFD.write(0xC0); // 100% brightness
  }
}

void VFDchars()
// run through characters for selected font
{
  for (int i = 21 ; i < 256; i++)
  {
    VFD.write(0x16); // underline cursor off
    VFD.write(i);
    delay(100);
  }
}

void moveCursor(byte position)
// moves the cursor - top row is 0~39, bottom row is 40~79
// vertical scroll mode must be turned off if used
{
    VFD.write(0x1B); // ESC
    VFD.write(0x48); // move cursor 
    VFD.write(position); // location
}

void loop()
{
  VFD.write(0x16); // underline cursor off
  VFD.print("Hello, world - line one."); // You can blast out text 
  delay(1000);      
  VFDnewline();
  VFD.print("Hello, world - line two."); 
  delay(1000);    
  VFDclearsceen();
  VFDbrightness(25);
  VFD.print("*** 25% brightness ***");   
  delay(1000);
  VFDclearsceen();  
  VFDbrightness(50);
  VFD.print("*** 50% brightness ***");     
  delay(1000);
  VFDclearsceen();   
  VFDbrightness(75);
  VFD.print("*** 75% brightness ***");       
  delay(1000);
  VFDclearsceen();   
  VFDbrightness(100);
  VFD.print("*** 100% brightness ***");         
  delay(1000);
  VFDclearsceen();

  VFDchars();
  VFDclearsceen();

  for (int i = 0; i < 80; i++)
  {
    VFD.write(0x16); // underline cursor off
    moveCursor(i);
    VFD.print("X");
    delay(100);
    moveCursor(i);    
    VFD.print(" ");    
  }
  VFDclearsceen();
}

 

Conclusion

We hope you found this interesting and helpful. And if you have an inexpensive source for these old displays, let us know in the comments. Full-sized images are on flickr. And if you made it this far – check out my new book “Arduino Workshop” from No Starch Press.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

The post Using older Noritake Itron VFD modules appeared first on tronixstuff.