Day: August 5, 2009

While I was putting together the Tek 492 memory board reader, I though it’d be a nice idea to add a small display. While the Arduino has USB serial I/O, the update rate is fairly pokey and an on-board display can provide more-or-less real time status.

Given that the reader was built for an early-80s memory board, I just had to use a pair of Litronix DL-1414 4-character LED displays from my parts heap. The DL-1414 datasheet [Update: link rot? try that] proudly proclaims:

The 0.112″ high characters of the DL1414T gives readability up to eight feet. The user can build a display that enhances readability over this distance by proper filter selection.

I think that distance is exceedingly optimistic.

However, I needed to see only a few feet to the benchtop. Even better, adding the displays required no additional hardware: the SPI-driven shift registers on the board already had address and data lines, plus a pair of unused bits for the write strobes. What’s not to like?

This schematic connects to the one you just clicked on; the two big blue bus lines are the same bus as in that schematic.

If you don’t have anything else riding the data bus, adding a pullup on the D7 bit that isn’t used by these displays will make all the bits float high; the DL-1414s seem to pull their inputs upward. That came in handy when I was debugging the EPROM-burning code, because reading data without an EPROM in the socket produced 0xff, just like an erased EPROM byte.

The two displays are the dark-red rectangle in the lower-right of the first picture, covered with a snippet of the Primary Red filter described there.

These closeups, without and with the filter, demonstrate why you really, really need a filter of some sort.

Using the displays is straightforward, given the hardware-assisted SPI code from there. You could actually do it with just the I/O pins on an Arduino board, but you wouldn’t be able to do anything else. If you don’t have any other SPI registers, you could get away with a pair of HC595 outputs:  7 data + 2 address + 2 strobes + 5 outputs left over for something else.

A few constants set the display size and a global buffer holds the characters:

#define LED_SIZE            4            // chars per LED
#define LED_DISPLAYS        2            // number of displays
#define LED_CHARS           (LED_DISPLAYS * LED_SIZE)

char LEDCharBuffer[LED_CHARS + 1];       // raw char buffer, can be used as a string

A routine to exercise the LEDs by scrolling all 64 characters they can display goes a little something like this:

Serial.println("Exercising LED display ...");

 Outbound.Controls |= CB_N_WRLED1_MASK | CB_N_WRLED0_MASK;        // set write strobes high
 digitalWrite(PIN_DISABLE_DO,LOW);                                // enable data outputs

 while (digitalRead(PIN_PB)) {

  digitalWrite(PIN_HEARTBEAT,HIGH);

  byte Character, Index;

  for (Character = 0x20; Character < 0x60; ++Character) {
   for (Index = 0; Index < LED_CHARS; ++Index) {
    LEDCharBuffer[Index] = Character + Index;
   }
   UpdateLEDs(LEDCharBuffer);
   delay(500);

   if (!digitalRead(PIN_PB)) {
    break;
   }
  }

  digitalWrite(PIN_HEARTBEAT,LOW);
 }

 WaitButtonUp();

A routine to plop a string (up to 8 characters!) on the LEDs looks like this:

void UpdateLEDs(char *pString) {
byte Index = 0;

 while (*pString && (Index < LED_CHARS)) {

  Outbound.DataOut = *pString;           // low 6 bits used by displays
  Outbound.Address = ~Index;             // low 2 bits used by displays, invert direction
  Outbound.Controls &= ~(Index < LED_SIZE ? CB_N_WRLED1_MASK : CB_N_WRLED0_MASK);

  RunShiftRegister();

  digitalWrite(PIN_DISABLE_DO,LOW);      // show the data!

  Outbound.Controls |= CB_N_WRLED1_MASK | CB_N_WRLED0_MASK;
  RunShiftRegister();

  digitalWrite(PIN_DISABLE_DO,HIGH);     // release the buffers

  ++pString;
  ++Index;
 }

You can use sprintf() to put whatever you like in that string:

void ShowStatus(word Address,byte Data) {

 sprintf(LEDCharBuffer,"%04X  %02X",Address,Data);
 UpdateLEDs(LEDCharBuffer);

}

Not, of course, that anybody would actually use DL-1414 displays in this day & age, but the general idea might come in handy for something more, mmmm, elegant…