Arduino Shift Out

Description: At some point, it may be necessary to extend the number of pins on an Arduino board using shift registers. This example utilizes the 74HC595, which is described in the datasheet as an "8-bit serial-in, serial or parallel-out shift register with output latches; 3-state." This component allows control of eight outputs simultaneously while using only a few pins on the microcontroller. Multiple registers can be linked together to further increase output capabilities. Users may also explore other driver chips with "595" or "596" in their part numbers, such as the STP16C596, which can drive 16 LEDs and includes built-in constant current sources to eliminate the need for series resistors. The operation relies on "synchronous serial communication," where a single pin is pulsed to transmit a data byte to the register bit by bit, while a second pin, the clock pin, delineates between bits. This differs from "asynchronous serial communication" used in the Serial.begin() function, which requires the sender and receiver to agree on a data rate independently. Once a byte is transmitted to the register, the HIGH or LOW signals stored in each bit are distributed to the individual output pins, enabling parallel output. The serial output, accessible through an additional pin, allows the serial information received from the microcontroller to be sent out unchanged, enabling the transmission of 16 bits (or 2 bytes) in sequence. The term "3 states" indicates that output pins can be set to high, low, or "high impedance." However, pins cannot be individually set to high impedance; the entire chip must be configured together. This feature is specialized and may not be necessary for typical applications. When powered on, the output pins may revert to their last state or an arbitrary state before the program begins execution. This issue can be mitigated by controlling the MR and OE pins from the Arduino, although this approach conserves more pins. The pins will be referred to as the dataPin, clockPin, and latchPin. A 0.1µF capacitor on the latchPin can help reduce flicker during pulsing. Each LED's cathode (short pin) should be connected to a common ground, while the anode (long pin) connects to the respective shift register output pin. Using the shift register to provide power is termed sourcing current. Some shift registers can only sink current, necessitating a reversal of LED connections. A 220-ohm resistor should be included in series to protect the LEDs from overload. Three code examples are provided: the first outputs a byte value from 0 to 255, the second lights one LED at a time, and the third cycles through an array. The code is based on the timing diagram and logic table from the datasheet, indicating that significant actions occur on the rising edge of the clockPin. When the clockPin transitions from low to high, the shift register reads the dataPin's state and stores it in an internal memory register. When the latchPin goes high, the stored data moves to the output pins, activating the LEDs. Connections include extending the same clock and latch signals to a second shift register and linking the serial out pin of the first register to the serial data input of the second. The code samples illustrate the differences when controlling 16 LEDs, with modifications to accommodate the additional outputs.

The 74HC595 shift register is a versatile component for expanding the output capabilities of microcontrollers like Arduino. It operates using synchronous serial communication, allowing the transmission of data in a controlled manner, with data bits being shifted into the register upon clock pulses. The ability to daisy-chain multiple shift registers increases the number of outputs available, making it suitable for applications such as LED control, where multiple outputs need to be managed efficiently.

The setup typically involves connecting the dataPin, clockPin, and latchPin to the microcontroller, with the output pins connected to the loads (e.g., LEDs). The use of a capacitor on the latchPin can help stabilize the output, reducing flickering during transitions. It is essential to ensure that the current requirements of the connected loads do not exceed the specifications of the shift register, as some versions can only sink current rather than source it.

The provided code examples demonstrate practical applications of the shift register, highlighting the importance of timing in controlling the outputs. The logic table in the datasheet serves as a guide for understanding how the shift register processes inputs and outputs, ensuring that the correct sequence of operations is followed for reliable performance. Overall, the 74HC595 is a powerful tool for enhancing the functionality of microcontroller projects, particularly in scenarios where pin availability is a constraint.At sometime or another you may run out of pins on your Arduino board and need to extend it with shift registers. This example 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 o nly 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. 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. From now on those will be refered to as the dataPin, the clockPin and the latchPin respectively. Notice the 0. 1"f capacitor on the latchPin, if you have some flicker when the latch pin pulses you can use a capacitor to even it out.

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. Here are three code examples. The first is just some "hello world" code that simply outputs a byte value from 0 to 255. The second program lights one LED at a time. The third cycles through an array. 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.

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.

Here again are three code samples. 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. There is only one extra line of code compared to the first code sample from Example 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. Comparing this code to the similar code from Example 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 LEDs and once for the red ones.

Like sample 2. 2, sample 2. 3 also takes advantage of the new blinkAll_2bytes() function. 2. 3`s big difference from sample 1. 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