Using a Dot Matrix LED With an Arduino and Shift Register

For this short little project, you will need:

• an AVR-based microcontroller like an Arduino or any of it's ilk. These instructions could probably be adapted to your MCU of choice.
• a DLO7135 dot matrix LED or other in the same family
• an 8-bit shift register like the 74LS164, 74C299, or 74HC594
• a breadboard
• hookup wire, wire cutters, etc.

A soldering iron isn't needed, although I use one later; you can get by without it.

Lay out your small list of parts and grab the LED. Place it on the breadboard centered somewhat, straddling the midline groove. The first part of connecting takes place all on the left side of the LED. Pin #1 is located at the top left as indicated by the triangle/arrow. I put the pin functions on a picture for your reference as you're reading or connecting up your LED.

The Left Side

Positive and Negative
Starting at the top left, connect Vcc to 5V. It's maybe a good idea to not have your board powered until you get the entire left side completed; the LED can be bright if you're trying to see small holes to poke in wires. Connect the bottom left GND to ground.

Lamp Test, Chip Enable and Write
The 2nd and 3rd from the top on the left are Lamp Test and Chip Enable. These are both negative logic, meaning they are enabled when they are at a logical 0 instead of 1. My picture below should have bars over them, but I didn't annotate that for any of them. The LT pin when enabled lights up every dot in the dot matrix at 1/7th brightness. It's more of a pixel test, but the interesting thing about the LT pin is that it doesn't overwrite any character that's in the memory, so you if you have several of these strung together (they have a 20ft viewing distance), strobing LT can make it look like a cursor. To ensure it's disabled, connect it to 5V.

The CE and WR pins are also negative logic and are required to be enabled for this smart device to be written to. You could micromanage these pins with spare I/O ports on your microcontroller, but we won't bother here. Just connect them to ground to keep them enabled.

Brightness Levels
There are four programmable brightness levels on the DLO family of LEDs:

• Blank
• 1/7 Brightness
• 1/2 Brightness
• Full Brightness

BL1 HIGH and BL0 LOW is 1/2 brightness. Both HIGH is full brightness. Set it to whatever you like. Again, if you have I/O ports to spare and it's important enough to you, this can also be controlled by your Arduino.

That wraps up the left side. If you bring power to your board you should see the LED light up. Play with the brightness controls and the lamp test to get familiar with it, if you're curious.

The Right Side

The right side consists of entirely data ports. The bottom right, pin 8 or D0 to be precise, represents the Least Significant Bit in the 7-bit character. The top right, pin 14 or D6 represents the Most Significant Bit. This lets you know what order to shuffle your bits when writing to the LED.

When you have the data input ports wired up, find seven empty digital I/O ports on your Arduino or AVR and connect them. You'll probably want to remember what data output port on your AVR goes to which data input port on the LED.

Now you're ready to push some data onto that smart LED. Are you trembling with excitement yet? I know I am...

The character set that's used on this CMOS LED is your run-of-the-mill ASCII starting at 0x20 (decimal 32; a space) and ending at 0x7F (decimal 127; a delete, although represented on the LED as a cursor graphic). So, having the LED display a character entails nothing more than pushing the a logic 1 or 0 on your data output pins, usually followed by a WR pulse, but I'm foregoing that for this exercise.

So, you've written down or remembered what pins go to what ports, right? I chose PD[2..7] and PB0 (digital pins 2 through 8 in Arduino-speak). I don't normally suggest using PD[0..1] because I dedicate it to my serial communication back to a FreeBSD box, and Arduino's et al. map those pins to their FTDI USB communication channel, and although "they" SAY pins 0 and 1 will work if you don't initialize serial communication, I have never been able to use those pins as normal digital I/O. In fact, I spent two days trying to debug a problem when I tried to use PD0 and PD1 and found that they were always HIGH. *shrug*

It would probably be good to have some sort of external input, like maybe a keypad, a pushwheel or thumbwheel switch, or maybe even input from a terminal (my ArduinoTerm isn't ready for prime time just yet...). The choice is yours. For now, I'm just going to illustrate how to get the code to get the character you want onto the LED. There is a zipfile for download including the source code and Makefile and there's also a short movie showing the LED printing out its character set. Sorry for the crappy quality of the video.

The code below prints the string "Welcome to my Instructable!" then cycles through the entire character set that the LED supports.

DDRD = 0xFF;	// OutputDDRB = (1<<DDB0);	char 	msg[] = "Welcome to my Instructable!";uint8_t	i;for (;;){    for(i=0;i<27; i++)    {        Print2LED(msg[i]);			        _delay_ms(150);    }	    for(i=0x20; i<0x80; i++)    {        Print2LED(i);        _delay_ms(150);    }    Print2LED(&apos*&apos);}

The port output is taken care of in the Print2Led() function.

voidPrint2LED(uint8_t i){	PORTD = (i << 2);	if (i & 0b01000000)	    PORTB = (1<<PINB0);	else	    PORTB = (0<<PINB0);}

The code and Makefile is included in a zip file below.

Attachments

• dotmatrixled-vid (divx).avi
  Download
• dotmatrixled1.zip
  Download

So now our microcontroller can send data to the dot matrix LED but it's using eight I/O ports. That excludes using an ATtiny in an 8-pin DIP package, and even with a newer Arduino sporting an ATmega328p that's a lot of I/O ports for one LED. We can get around this, however, by using an IC called a shift register.

A moment to "shift" gears...
A shift register can be understood best by thinking about the two words that make up its name: "shift" and "register." The word shift refers to how the data is moving through the register. Here (as in our Arduino and microcontrollers, in general) a register is a location that holds data. It does this by implementsing a linear chain of digital logic circuits called "flip flops" that has two stable states that can be represented by either a 1 or 0. So, by putting eight flip flops together you have a device that is capable of holding and representing an 8-bit byte.

Just as there are several types of flip flops, and several variations on a theme of shift registers (think up/down counters and Johnson counters), there are also several types of shift registers based on how data is latched into the register and how that data is output. Based on this, consider the following types of shift registers:

• Serial In / Parallel Out (SIPO)
• Serial In / Serial Out (SISO)
• Parallel In/ Serial Out (PISO)
• Parallel In / Parallel Out (PIPO)

Two of note are SIPO and PISO. SIPO registers take data serially, that is, one bit after another, shifting the previously input bit over to the next flip flop and sending the data out on all inputs at once. This makes a nice serial to parallel converter. PISO shift registers, conversely, have parallel inputs, so all bits are entered at once, but are output one at a time. And you guessed it, this makes for a nice parallel to serial converter. The shift register we want to use to reduce the number of I/O pins would allow us to take those 8 IO pins we used earlier and reduce them down to one, or maybe just a couple, considering we may need to control how we input the bits. Therefore, the shift register we'll use is a Serial In / Parallel Out.

Wire up the shift register between the LED and Arduino
Using a shift register is easy. The hardest part is just visualizing the data output pins and how the binary digits will end up in the IC, and how they will eventually show up on the LED. Take a moment to plan this out.

1. Attach 5V to pin 14 (top right) and take pin 7 (bottom left) down to ground.
2. The shift register has two serial inputs but we'll only be using one, so connect pin two to 5V
3. We won't be using the clear pin (used to zero out all outputs) so leave it floating or attack it to 5V
4. Connect one digital IO port to pin one of the shift register. This is the serial input pin.
5. Connect one digital IO port to pin 8 (bottom right). This is the clock pin.
6. Connect your data lines from Q0 to Q6. We're only using 7 bits because the ASCII character set only uses seven bits.

I used PD2 for outputting my serial data and PD3 for the clock signal. For the data pins, I connected Q0 to D6 on the LED and continuing that way (Q1 to D5, Q2 to D4, etc). Since we're sending out data serially we will have to examine the binary representation of each character we want to send, looking at 1's and 0's, and outputting each bit on the serial line. I've included a second version of the dotmatrixled.c source along with a Makefile below. It cycles through the character set and displays all even characters (if it's weird thinking that a letter could be odd or even, think about the binary representation for a moment). Try to figure out how to make it cycle through displaying all odd characters. You can further experiment with the connections between the shift register, the dot matrix LED, and your Arduino. There are several control features between the LED and the register that can allow you to fine-tune your control about when data is displayed.

So....we've gone from having to use eight I/O ports to only using two!

Attachments

• dotmatrixled.c
  Download
• Makefile
  Download