You are on page 1of 13

Home Sign Up!

Browse Community Submit


All Art Craft Food Games Green Home Kids Life Music Offbeat Outdoors Pets Photo Ride Science Tech

The 74HC164 Shift Register and your Arduino


by osgeld on November 15, 2009

Table of Contents

The 74HC164 Shift Register and your Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Intro: The 74HC164 Shift Register and your Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

Step 1: So, what are shift registers? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

Step 2: Basic wiring and operation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

Step 3: Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Step 4: Project 1[pt 1]: '2 Wire' bargraph LED display controller hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Step 5: Project 1[pt 2]: '2 Wire' bargraph LED display controller software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

File Downloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Step 6: Project 2: '2 Wire' 7 Segment display controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

File Downloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

Step 7: Project 3[pt 1]: '2 Wire' 4x4 led matrix display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Step 8: Project 3[pt 2]: '2 Wire' 4x4 led matrix display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

File Downloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Step 9: Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Related Instructables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
Intro: The 74HC164 Shift Register and your Arduino
Shift registers are a very important part of digital logic, they act as glue in between the parallel and serial worlds. They reduce wire counts, pin use and even help take
load off of your cpu by being able to store their data.

They come in different sizes, with different models for different uses, and different features. The one I will be discussing today is the 74HC164 8 bit, serial in parallel out,
non latched, shift register.

Why? Well for one it is one of the most basic shift registers out there, which makes learning about it easier, but it just so happened to be the only one I had (lol!)

This instructable covers how this chip works, how to wire it, and interface it with an arduino including some sample sketches and led circuits.

I hope you all enjoy!

Image Notes Image Notes


1. 74HC164 1. there is a lot of companies that make 74xx logic series chips, mine happens to
2. bare bones arduino, the first arduino I have ever owned (since October) be GoldStar, it could have been TI, phillips or anyone

Step 1: So, what are shift registers?


As mentioned earlier they come in all different flavors, and I also mentioned that I am using a 74HC164 8 bit, serial in parallel out, non latched, shift register

so what does that all mean?!?

First, the name


74 -- means its part of the 74xx logic family, and since its logic it cannot directly control very much current (16-20ma for the entire chip is common) , it only passes
signals around, but that does not mean that signal is not going to a transistor which can switch a higher current load.

HC means its a high speed cmos device, you can read about that on the link below, but what you basicly need to know about that is that it is a low power device and will
run from 2 to 5 volts (so if your using a 3.3 volt arduino your ok)

Also it can work properly at high speeds this particular chip has a typical speed of 78mhz, but you can go as slow or as fast (until it starts goofing up) as you want
www.kpsec.freeuk.com/components/74series.htm

164 is the model number for this chip, there is a large chart of them on wikipedia
en.wikipedia.org/wiki/List_of_7400_series_integrated_circuits

Next, 8 bit
A shift register is made up of flip flop circuits, a flip flop is 1 bit of memory, this one has 8 (or 1 byte of memory). Since it is memory, if you do not need to update the
register you can just stop "talking" to it and it will remain in whatever state you left it, until you "talk" to it again or reset power.

other 7400 logic series shift registers can go upto 16 bit

serial in parallel out


This means your arduino sends it data serially (on off pulses one after another) and the shift register places each bit on the correct output pin. This model only requires 2
wires to be controlled, so you can use 2 digital pins on the arduino, and break those 2 out to 8 more digital outputs

some other models are parallel in serial out, they do the same thing but as inputs to the arduino (for example a NES gamepad)

non latched
This may be a downfall of this chip if you need it. As data enters a shift register via serial, it shows up on the first output pin, when a clock pulse enters in, the first bit
shifts over 1 place, creating a scrolling effect on the outputs, for example 00000001 would show up on the outputs as

1
01
001
0001
00001
000001
0000001

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
00000001

If your talking to other logic devices who are sharing the same clock and not expecting this, it could cause issues. Latched shift registers have an extra set of memory, so
once the data is done entering the register you can flip a switch and show the outputs, but it adds another wire, software, and things to keep up with.

In the case of this instructable we are controlling LED displays, the scrolling effect happens so fast you cant see it (except when you very first turn on the chip), and once
the byte is in the shift register there is no more scrolling

We will be controlling bargraph type, 7 segment, and a 16LED 4x4 dot matrix with this chip and software on the arduino using only 2 digital pins (+ power and ground)

Image Notes
1. there is a lot of companies that make 74xx logic series chips, mine happens to be GoldStar, it could have been TI, phillips or anyone

Step 2: Basic wiring and operation


Wiring
The 74HC164 is a 14 pin chip, it has 4 input pins, 8 output pins, power and ground, so lets start from the top.

Pins 1 and 2 are both serial inputs, they are setup as a logical AND gate, meaning that they both have to be logic high (ie 5 volts) in order for the bit to be seen as a 1, a
low state (0 volts) on either will read as a zero. We dont really need this and its easier to deal with in software, so choose one and tie it to V+ so it always reads high. I
choose to use a jumper from pin 1 to pin 14 (V+) since you can just pop a breadboard jumper over the chip. The one remaining serial input (pin 2 in my schematics) will
goto digital pin 2 of the arduino.

Pins 3,4,5,and 6 of the 74HC164 are the first 4 bytes of output

Pin 7 connects to ground

Jumping to the right, pin 8 is the clock pin, this is how the shift register knows the next serial bit is ready for it to read, this should be connected to digital pin 3 on the
arduino.

Pin 9 is to clear the entire register at once, if it goes low, you have the option to use it, but nothing in this inscrutable does, so tie it to V+

pins 10, 11 12 and 13 are the last 4 bytes of output

pin 14 is the chips power

Operation
First you need to set the serial input of the register (digital pin 2 on the arduino) high or low, next you need to flip the clock pin (digital pin 3) from low to high, the shift
register will read the data on the serial input and shift the output pins by 1, repeat 8 times and you have set all 8 outputs.

This can be done by hand with for loops and digital writes in the arduino IDE, but since this is a very common hardware level communications (SPI) they have a single
function that does it for you.

shiftOut(dataPin, clockPin, bitOrder, value)

Just tell it where the data and clock pins are connected to the arduino, which way to send the data and what to send, and its taken care of for you (handy)

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
Step 3: Projects
Okay, enough lecture and theory, lets do some fun stuff with this chip!

There are 3 projects to try in this instructable, the first 2 are easy and can be breadboarded out in moments. The third one, the 4x4 led matrix, requires more time and
thought to construct, due to the led wiring.

List of parts

Project 1: '2 Wire' bargraph LED display controller


1 * 74HC164 Shift register
1 * solderless breadboard
1 * arduino, or arduino compatible (5v)
1 * 330 ohm 1/4 watt resistor
8 * normal output red LED's
12 * jumper wires

Project 2: '2 Wire' 7 segment display controller


1 * 74HC164 Shift register
1 * solderless breadboard
1 * arduino, or arduino compatible (5v)
1 * 330 ohm 1/4 watt resistor
1 * common cathode seven segment display
9 * jumper wires

Project 3: '2 Wire' 4x4 led matrix display


1 * 74HC164 Shift register
1 * arduino, or arduino compatible (5v)
4 * 150 ohm 1 1/4 watt resistor
8 * 1Kohm 1/8 watt resistor (or larger)
8 * NpN transistor (2n3904 or better)
16 * normal output red LED's

a means to construct it and regulated 5 volt power that can handle 160+ma (you can turn on all the LED's at once like a brake light)

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
Step 4: Project 1[pt 1]: '2 Wire' bargraph LED display controller hardware
Hook up the arduino and shift register according to the schematic, I already have a 10 segment bargraph display ready for breadboard use and that is what you will see in
the image, but you can do the same thing with individual led's

On the second page I stated that these were not driver devices, that they were logic devices, with tiny amounts of current able to pass through them. In order run 8 LEDs,
while keeping the circuit simple, and not cooking the shift register, requires that we limit the current quite a bit.

The LED's are wired in parallel and share a common ground (common cathode), before going into the power supply ground they need to pass through a 330 ohm
resistor, limiting the total amount of current that all the LED's could possibly use to 10ma (at 5 volts)

This leaves the LED's in a sickly looking state but they do light up and thus serve for this example, in order to drive the LED's at their proper current you will need to insert
a transistor where the shift register can turn on / off a higher current source (see project 3)

The Data pin of the shift register (pin 2) needs to connect to arduino digital pin # 2
The Clock pin of the shift register (pin 8) needs to connect to arduino digital pin # 3

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
Step 5: Project 1[pt 2]: '2 Wire' bargraph LED display controller software
Example 1:
Open the file " _164_bas_ex.pde" Inside the arduino IDE, Its a simple sketch that just lets you define on or off LED's in the bargraph display

The first 2 lines define the pin numbers we will be using for data and clock, I use #define over const integer, I find it easier to remember, and there is no advantage to one
or the other once compiled

#define data 2
#define clock 3

next is the void setup function, it only runs once, so the arduino turns on, sets the shift register and has nothing else to do. Inside the void setup function we set the clock
and data pins as OUTPUT pins, then using the shiftOut function we send the data to the shift register

void setup()
{
pinMode(clock, OUTPUT); // make the clock pin an output
pinMode(data , OUTPUT); // make the data pin an output
shiftOut(data, clock, LSBFIRST, B10101010); // send this binary value to the shift register
}

In the shiftOut function you can see its arguments


data is the data pin, clock is the clock pin

LSBFIRST refers to what order its in, when writing it out in binary notation (Bxxxxxxxx) the 7th element past the B is the Least Signifigant Bit First, this is fed in first so it
ends up on the last output once all 8 bits are fed in

B10101010 is the Binary value being sent to the shift register, and it will turn on every odd light, try playing with different values to turn on or off different patterns

and finally a empty void loop (because you need one even if your not using it)

void loop(){} // empty loop for now

Example 2:
the first 8 lines are the same as the first 8 lines of the first example, in fact they will not change for any of the other projects, so

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
#define data 2
#define clock 3

void setup()
{
pinMode(clock, OUTPUT); // make the clock pin an output
pinMode(data , OUTPUT); // make the data pin an output

But now in void setup there is an 8 count for loop, its taking an empty byte and shifting 1 bit in at a time starting from the leftmost bit and moving right. This is backwards
from the first example where we started from the rightmost bit and worked left, but using MSBFIRST the shift out function sends the data the correct way

Also we add a delay in the for loop so it slows down enough to be visible.

for(int i = 0; i < 8; ++i) //for 0 - 7 do


{
shiftOut(data, clock, MSBFIRST, 1 << i); // bit shift a logic high (1) value by i
delay(100); // delay 100ms or you would not be able to see it
}

void loop(){} // empty loop for now

upload the script and you should now see the bargraph light up each light one at a time

Image Notes
1. notice the lights match our binary pattern of B10101010

File Downloads

_164_bas_ex.pde (296 bytes)


[NOTE: When saving, if you see .tmp as the file ext, rename it to '_164_bas_ex.pde']

_164_bas_ex_2.pde (411 bytes)


[NOTE: When saving, if you see .tmp as the file ext, rename it to '_164_bas_ex_2.pde']
Step 6: Project 2: '2 Wire' 7 Segment display controller
Look at the pinout of your 7 segment display (I only had a dual one but just using half) and use the drawing below to connect each segment to the correct bit on the shift
register

bit 1 = pin 3
bit 2 = pin 4
bit 3 = pin 5
bit 4 = pin 6
bit 5 = pin 10
bit 6 = pin 11
bit 7 = pin 12
bit 8 = pin 13 (if you want to use the decimal point)

And the cathode of the display through the 330ohm resistor and to power supply ground

now open the seven_seg_demo.pde in the arduino IDE

First you see where we define the data and clock pins

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
#define data 2
#define clock 3

Next we set all of the charater patterns in binary, this is pretty easy, look at the drawing below, if you need the middle segment type in a one, next do you need the top
segment, if so type in another one, keep doing this until you cover all 8 segments, notice my rightmost bit (bit 8) is always 0, thats becuase i never turn on the decimal
point.

byte zero = B01111110;


byte one = B00000110;
byte two = B11011010;
byte three = B11010110;
byte four = B10100110;
byte five = B11110100;
byte six = B11111100;
byte seven = B01000110;
byte eight = B11111110;
byte nine = B11110110;

next in void setup we set our data and clock pins to outputs

void setup()
{
pinMode(clock, OUTPUT); // make the clock pin an output
pinMode(data , OUTPUT); // make the data pin an output3
}

then in void loop we use shiftOut to display each pattern (number) wait 1/2 a second and display the next, 0 to 9, since its being done in the void loop function it will count
0-9 and repeat forever.

void loop()
{
shiftOut(data, clock, LSBFIRST, zero);
delay(500);
shiftOut(data, clock, LSBFIRST, one);
delay(500);
shiftOut(data, clock, LSBFIRST, two);
delay(500);
shiftOut(data, clock, LSBFIRST, three);
delay(500);
shiftOut(data, clock, LSBFIRST, four);
delay(500);
shiftOut(data, clock, LSBFIRST, five);
delay(500);
shiftOut(data, clock, LSBFIRST, six);
delay(500);
shiftOut(data, clock, LSBFIRST, seven);
delay(500);
shiftOut(data, clock, LSBFIRST, eight);
delay(500);
shiftOut(data, clock, LSBFIRST, nine);
delay(500);
}

File Downloads

seven_seg_demo.pde (1 KB)
[NOTE: When saving, if you see .tmp as the file ext, rename it to 'seven_seg_demo.pde']
http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
Step 7: Project 3[pt 1]: '2 Wire' 4x4 led matrix display
The 4x4 LED matrix project is quite a bit more complex, but it is almost all in construction, I choose to make mine soldered on perfboard, but it should be possible to
replicate on a breadboard , just a lot more spaced out.

The circuitry also differs in that the shift register is not directly driving the led's, instead the shift register outputs are sent through a 1Kohm resistor to the base of a NpN
transistor, when the output of the bit is high, it lets enough current and voltage pass into the transistor to switch the connection tween the collector and emitter, the
collectors are tied to a "sturdy" regulated 5 volts.

The emitters of the transistors are connected to 150 ohm resistors and the resistors are tied to the annodes of 4 led's in a row and limits the row to 20ma, although when
drawing images on the display only 1 led is on at a time, and therefore near full brightness (near becuase they switch on and off really fast to make up the whole image)

There are 4 rows and 4 columns, each row gets a resistor and a transistor, on each column the LED's cathodes are tied together, ran into the collector of a transistor,
whose base is also controlled by the shift register, and finally out to ground.

Large version of schematic


www.instructables.com/files/orig/F7J/52X0/G1ZGOSRQ/F7J52X0G1ZGOSRQ.jpg

Step 8: Project 3[pt 2]: '2 Wire' 4x4 led matrix display
The shift register controls both the anode and the cathodes of the LED's in a YX format, look at the following

bit 1 = column 1 (rightmost)


bit 2 = column 2
bit 3 = column 3
bit 4 = column 4
bit 5 = row 1 (topmost)
bit 6 = row 2
bit 7 = row 3
bit 8 = row 4

To make an image draw out a 4x4 square on graph paper and fill in which ones you want displayed, next make a YX table. Below you will see a mapping for a simile, well
as best one can do on 4x4 "pixels"

For each filled in section I write down which column (Y) it is in, then which row it is in (X)

Now open up the _4x4.pde file in the arduino IDE you will see our old 2 friends

#define data 2
#define clock 3

then a array of integers

int img[] = {1,1,4,1,1,3,4,3,2,4,3,4};

If you look its just a list of my written down YX coordinates, it would be a big pain in the butt to convert those values by hand, and we have a computer ... let it do it!

Moving on there is void setup where we make our clock and data pins OUTPUTS

void setup()
{
pinMode(clock, OUTPUT); // make the clock pin an output
pinMode(data , OUTPUT); // make the data pin an output3
}

And a confusing looking void loop, to start things off we need to declare some local variables

void loop()
{
int Y;

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
int X;
byte out;

Then a for loop, this loop needs to be as long as the amount of entries in the img array, for this image I only used 6 pixels, so that makes 12 YX coordinates. I make it
skip every other number by using i +=2, because we read 2 coordinates per loop

for(int i = 0; i < 12; i += 2) // number of points in the img array, this case 12
{

Now we read the Y entery at [i] in the array, and subtract one from its value, because bytes don't start at one, they start at zero, but we counted from 1

// get the first pair of YX cords


Y = (img[i] - 1); // subtract one since the bit count starts at 0

Next we read the X entery at [i + 1] in the array, and subtract one from its value, because of the same reason

X = (img[i+1] - 1);

After we have the YX values of the pixel, we do some bitwise or math and shifting to the left.

First we need to read the X value, and whatever its value is shift it that many places + 4 left, so if X is 4 and add 4 it is bit 8 (MSB), looking at the chart again ...

bit 1 = column 1 (rightmost)


bit 2 = column 2
bit 3 = column 3
bit 4 = column 4
bit 5 = row 1 (topmost)
bit 6 = row 2
bit 7 = row 3
bit 8 = row 4

Bit 8 is the last row

Next the Y value is also shifted to the left, this time just by its self, nothing added on.

Finally the two are or'ed together into 1 byte instead of 2 half bytes (nibbles), using bitwise or (the symbol | ) takes two bytes and basicly adds them together, lets
assume

X = 10000000
Y = 00000001
--------------------
OR =10000001

row 4 column 1

out = 1 << (X + 4) | 1 << Y;

And finally shiftOut to display the current picture, and keep doing that until we have no more data in the array ... delay a moment and loop forever, since we were shifting
data to the left and we need the MSB to be on the last output pin of the shift register send it out first.

shiftOut(data, clock, MSBFIRST, out); // shift the byte out to our register
delay(1); // delay it abit so it has a chance to leave a spot of light in your eyes

Feel free to make your own images, and effects, There are 3 sample files, the smiley face and a checkerboard (which looks more like stripes), and finally a random
sparkle maker

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
File Downloads

_4x4.pde (884 bytes)


[NOTE: When saving, if you see .tmp as the file ext, rename it to '_4x4.pde']

_4x4_rnd_sparkle.pde (570 bytes)


[NOTE: When saving, if you see .tmp as the file ext, rename it to '_4x4_rnd_sparkle.pde']

_4x4_chx.pde (892 bytes)


[NOTE: When saving, if you see .tmp as the file ext, rename it to '_4x4_chx.pde']
Step 9: Conclusion
Over all this is a pretty handy little chip, and I am glad I scrapped it off of a old piece of electronics headed to the trash.

It can be used for other things besides display systems, but everyone likes lights and the instant feedback of seeing whats going on is extremely helpful for the visual
thinkers like I.

Also please forgive my code, I have only had the arduino since bout the third week of October, and its been a pretty big crash course. But that's the great thing about the
system, if you sit down and work with it, its full of neat features that make controlling the world with an 8 bit microcontroller quite easy to do.

As always questions and comments are most welcome, and thanks for reading, I hope you learned a lot

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
Image Notes
1. 74HC164
2. bare bones arduino, the first arduino I have ever owned (since October)

Image Notes
1. there is a lot of companies that make 74xx logic series chips, mine happens to
be GoldStar, it could have been TI, phillips or anyone

Related Instructables

How to use a Make a debug LED Projector Arduino Target Big 7-segment
74HC595 Shift display for Using a Dot by Practice by Digital Clock by
Register with a microcontrollers Matrix LED with PuffMag1cDrag0n sebtiger slwthr
AVR ATtiny13 an Arduino and
by andyk75
by roznerd Shift Register by
nevdull

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/
Comments
7 comments Add Comment

Tamerz says: Oct 18, 2010. 11:26 PM REPLY


It has been so long since I have done any electronics. This was very helpful, much better than the one output per segment I was using!

MCUman says: Aug 18, 2010. 4:12 AM REPLY


It's a great way to add an alphanumeric LCD to a low pin count MCU. Instead of 14 pins, it drops to 4.

matt byrne says: Jun 24, 2010. 4:23 PM REPLY


Great write up, very useful.

n3r0 says: Jan 18, 2010. 1:07 AM REPLY


Great instructable! You gave the best explanation of shift registers that I have heard so far.

kitecraft says: Dec 23, 2009. 6:06 PM REPLY


Fantastic instructable! Thank you :)
I made this with your help.
http://www.youtube.com/watch?v=3UNbvYED0bI

osgeld says: Dec 24, 2009. 10:02 AM REPLY


Pretty cool!

I have 4 or 5 of these chips laying around, and just for giggles I wired up a old 4 section 7 segment led display from an alarm clock

Bongmaster says: Nov 16, 2009. 1:55 AM REPLY


kool ible :)
i got a bunch of shift regs to put to use :P

http://www.instructables.com/id/The-74HC164-Shift-Register-and-your-Arduino/