Acoptex.com

members

Basics: Project 018k

Project name: 74HC595 - Serial to Parallel Shifting-Out

Attachments: sketch1, sketch2, sketch3 and sketch4, sketch5, sketch6

In this project, you needed these parts :

1.Aruduino Uno R3 (you can also use the other version of Arduino)

2.Arduino IDE ( you can download it from here  )

3.Jumper cables

4. Breadboard

5.74HC595 (shif register) 2 pcs

6. LEDs 8 pcs (red) and 8 pcs (green)

7. Resistor 16 pcs (220 Ohm each)

8. Capacitor 0.1 uF 1 pc

General

In this project we will learn how to connect one or two 74HC595 to Arduino board. 

Understanding the 74HC595

The 74HC595 consists of an 8-bit shift register and a storage register with three - state parallel outputs. It converts serial input into parallel output so you can save IO ports of an MCU.When MR (pin10) is high level and OE (pin13) is low level, data is input in the rising edge of SHcp and goes to the memory register through the rising edge of SHcp. If the two clocks are connected together, the shift register is always one pulse earlier than the memory register. There is a serial shift input pin (Ds), a serial output pin (Q) and an asynchronous reset button (low level) in the memory register. The memory register outputs a Bus with a parallel 8-bit and in three states. When OE is enabled (low level), the data in memory register is output to the bus.  At sometime or another you may run out of pins on your Arduino board and need to extend it with shift registers. This project is based on the 74HC595. The datasheet refers to the 74HC595 as an "8-bit serial-in, serial or parallel-out shift register with output latches; 3-state." In other words, you can use it to control 8 outputs at a time while only taking up a few pins on your microcontroller. You can link multiple registers together to extend your output even more. (Users may also wish to search for other driver chips with "595" or "596" in their part numbers, there are many. The STP16C596 for example will drive 16 LED's and eliminates the series resistors with built-in constant current sources.) How this all works is through something called "synchronous serial communication", i.e. you can pulse one pin up and down thereby communicating a data byte to the register bit by bit. It's by pulsing second pin, the clock pin, that you delineate between bits. This is in contrast to using the "asynchronous serial communication" of the Serial.begin() function which relies on the sender and the receiver to be set independently to an agreed upon specified data rate. Once the whole byte is transmitted to the register the HIGH or LOW messages held in each bit get parceled out to each of the individual output pins. This is the "parallel output" part, having all the pins do what you want them to do all at once. The "serial output" part of this component comes from its extra pin which can pass the serial information received from the microcontroller out again unchanged. This means you can transmit 16 bits in a row (2 bytes) and the first 8 will flow through the first register into the second register and be expressed there. You can learn to do that from the second example. "3 states" refers to the fact that you can set the output pins as either high, low or "high impedance." Unlike the HIGH and LOW states, you can"t set pins to their high impedance state individually. You can only set the whole chip together. This is a pretty specialized thing to do. Think of an LED array that might need to be controlled by completely different microcontrollers depending on a specific mode setting built into your project. Neither example takes advantage of this feature and you won't usually need to worry about getting a chip that has it.

Here is a table explaining the pin-outs adapted from the Phillip's datasheet.

Build the circuit

1. The first step is to extend your Arduino with one shift register.

1. Turning it on.

Make the following connections:

GND (pin 8) to ground,

Vcc (pin 16) to 5V

OE (pin 13) to ground

MR (pin 10) to 5V

This set up makes all of the output pins active and addressable all the time. The one flaw of this set up is that you end up with the lights turning on to their last state or something arbitrary every time you first power up the circuit before the program starts to run. You can get around this by controlling the MR and OE pins from your Arduino board too, but this way will work and leave you with more open pins.

2.Connect to Arduino board

DS (pin 14) to Ardunio DigitalPin 11 (blue wire)

SH_CP (pin 11) to to Ardunio DigitalPin 12 (yellow wire)

ST_CP (pin 12) to Ardunio DigitalPin 8 (green wire)

From now on those will be refered to as the dataPin, the clockPin and the latchPin respectively. Notice the 0.1 uf capacitor on the latchPin, if you have some flicker when the latch pin pulses you can use a capacitor to even it out.

3. Add 8 LEDs.

In this case you should connect the cathode (short pin) of each LED to a common ground, and the anode (long pin) of each LED to its respective shift register output pin. Using the shift register to supply power like this is called sourcing current. Some shift registers can't source current, they can only do what is called sinking current. If you have one of those it means you will have to flip the direction of the LEDs, putting the anodes directly to power and the cathodes (ground pins) to the shift register outputs. You should check the your specific datasheet if you aren't using a 595 series chip. Don't forget to add a 220-ohm resistor in series to protect the LEDs from being overloaded.

2. The second step is to extend your Arduino with one more shift register.

1. Connect the first shift register and 8 red LEDs to your Arduino like it was described before.

2. Add a second shift register. Starting from the previous example, you should put a second shift register on the board. It should have the same leads to power and ground.

3. Connect the 2 registers.

Two of these connections simply extend the same clock and latch signal from the Arduino to the second shift register (yellow and green wires). The blue wire is going from the serial out pin (pin 9) of the first shift register to the serial data input (pin 14) of the second register.

THE CODE (ONE SHIFT REGISTER)

The code is based on two pieces of information in the datasheet: the timing diagram and the logic table.

The logic table is what tells you that basically everything important happens on an up beat. When the clockPin goes from low to high, the shift register reads the state of the data pin. As the data gets shifted in it is saved in an internal memory register. When the latchPin goes from low to high the sent data gets moved from the shift registers aforementioned memory register into the output pins, lighting the LEDs.

Step by Step instruction

1. Plug your Adruino Uno board into your PC and select the correct board and com port
2. Open up serial monitor and set your baud to 9600 baud
3. Verify and upload the the sketch to your Adruino Uno board

THE CODE (TWO SHIFT REGISTERS)

If you are curious, you might want to try the samples from the first example with this circuit set up just to see what happens.

Sketch 4 Dual Binary Counters

There is only one extra line of code compared to the first code sample from Sketch 1. It sends out a second byte. This forces the first shift register, the one directly attached to the Arduino, to pass the first byte sent through to the second register, lighting the green LEDs. The second byte will then show up on the red LEDs.

Sketch 5 Byte One By One

Comparing this code to the similar code from Sketch 1 you see that a little bit more has had to change. The blinkAll() function has been changed to the blinkAll_2Bytes() function to reflect the fact that now there are 16 LEDs to control. Also, in version 1 the pulsings of the latchPin were situated inside the subfunctions lightShiftPinA and lightShiftPinB(). Here they need to be moved back into the main loop to accommodate needing to run each subfunction twice in a row, once for the green LEDsand once for the red ones.

Sketch 6 - Dual Defined Arrays

Like Sketch 5, Sketch 6 also takes advantage of the new blinkAll_2bytes() function. Sketch 6's big difference from Sketch 3 is only that instead of just a single variable called "data" and a single array called "dataArray" you have to have a dataRED, a dataGREEN, dataArrayRED, dataArrayGREEN defined up front. This means that line

data = dataArray[j];

becomes

dataRED = dataArrayRED[j];

dataGREEN = dataArrayGREEN[j];

and

shiftOut(dataPin, clockPin, data);

becomes

shiftOut(dataPin, clockPin, dataGREEN); 

shiftOut(dataPin, clockPin, dataRED);

We have learnt how to connect one or two 74HC595 to Arduino board

Library:

• No libraries required for this project

Sketches:

• See attachments on the begining of this project description. 
• Sketch 1 to Sketch 3. The first is just some "hello world" code that simply outputs a byte value from 0 to 255. The second sketch lights one LED at a time. The third cycles through an array.
• Sketch 4 Dual Binary Counters, Sketch 5 Byte One By One, Sketch 6 - Dual Defined Arrays