Tutorial.ShiftOut History

Hide minor edits - Show changes to output

November 05, 2013, at 08:10 PM by Scott Fitzgerald -
Changed lines 96-97 from:
[[shftOut1_3 | Code Sample 1.3 Two shift registers]]\\
to:
[[shftOut1_3 | Code Sample 1.3 Using an array]]\\
March 24, 2010, at 01:44 PM by Tom Igoe -
Changed lines 7-14 from:
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 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 �[[http://en.wikipedia.org/wiki/High_impedance | 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.
to:
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 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 "[[http://en.wikipedia.org/wiki/High_impedance | 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.
Changed line 20 from:
(:cell:) Q0 � Q7
to:
(:cell:) Q0 " Q7
Changed line 26 from:
(:cell:) Q7�
to:
(:cell:) Q7"
Changed lines 71-72 from:
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.
to:
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.
Changed lines 77-78 from:
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.
to:
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.
Changed lines 87-88 from:
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.
to:
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.
Changed line 132 from:
[[ShftOut21 | Code Sample 2.1 � Dual Binary Counters]]\\
to:
[[ShftOut21 | Code Sample 2.1 Dual Binary Counters]]\\
Changed line 135 from:
[[ShftOut22 | Code Sample 2.2 � 2 Byte One By One]]\\
to:
[[ShftOut22 | Code Sample 2.2 2 Byte One By One]]\\
Changed lines 139-140 from:
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
to:
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
Deleted line 155:
March 24, 2010, at 01:43 PM by Tom Igoe -
Changed lines 7-14 from:
to:
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 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 �[[http://en.wikipedia.org/wiki/High_impedance | 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.
Changed line 20 from:
to:
(:cell:) Q0 � Q7
Changed line 26 from:
to:
(:cell:) Q7�
Changed lines 71-72 from:
to:
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.
Changed lines 77-78 from:
to:
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.
Changed lines 87-88 from:
to:
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.
Changed lines 94-97 from:
to:
[[shftOut1_1 | Code Sample 1.1 Hello World]]\\
[[shftOut1_2 | Code Sample 1.2 One by One]]\\
[[shftOut1_3 | Code Sample 1.3 Two shift registers]]\\
Changed lines 102-103 from:
to:
In this example you'll add a second shift register, doubling the number of output pins you have while still using the same number of pins from the Arduino.
Changed line 132 from:
to:
[[ShftOut21 | Code Sample 2.1 � Dual Binary Counters]]\\
Changed line 135 from:
to:
[[ShftOut22 | Code Sample 2.2 � 2 Byte One By One]]\\
Changed lines 139-140 from:
to:
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
May 23, 2007, at 06:26 PM by Paul Badger -
Changed lines 7-10 from:
to:
May 23, 2007, at 06:23 PM by Paul Badger -
Changed lines 7-8 from:
to:
December 08, 2006, at 12:20 AM by Carlyn Maw -
Changed line 21 from:
(:cell:) Ground, Vss
to:
(:cell:) Output Pins
November 14, 2006, at 12:18 AM by Carlyn Maw -
Changed lines 83-84 from:

to:
Attach:ShftOut_Schm1.gif
Added lines 124-127:
!!!Circuit Diagram

Attach:ShftOut_Schm2.gif
November 09, 2006, at 11:25 PM by Carlyn Maw -
Changed lines 89-91 from:
%rframe width=200px% [[http://www.arduino.cc/en/uploads/Tutorial/595_logic_table.png |Attach:595_logic_table.png"logic table"]] | [-595 Logic Table-]
%rframe width=200px% [[http://www.arduino.cc/en/uploads/Tutorial/595_timing_diagram.png |Attach:595_timing_diagram.png"logic table"]] | [-595 Timing Diagram-] 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.
to:
%rframe width=200px border=1% [[http://www.arduino.cc/en/uploads/Tutorial/595_logic_table.png |Attach:595_logic_table.png"logic table"]] | [-595 Logic Table-]
%rframe width=200px border=1% [[http://www.arduino.cc/en/uploads/Tutorial/595_timing_diagram.png |Attach:595_timing_diagram.png"logic table"]] | [-595 Timing Diagram-]

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.
November 09, 2006, at 11:22 PM by Carlyn Maw -
Changed lines 77-78 from:
to:
Added lines 100-101:
November 09, 2006, at 11:10 PM by Carlyn Maw -
Changed lines 13-14 from:
to:
November 09, 2006, at 10:07 PM by Carlyn Maw -
November 09, 2006, at 10:07 PM by Carlyn Maw -
Added lines 87-88:
Changed lines 90-97 from:
to:
%rframe width=200px% [[http://www.arduino.cc/en/uploads/Tutorial/595_timing_diagram.png |Attach:595_timing_diagram.png"logic table"]] | [-595 Timing Diagram-] 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.
Added lines 96-97:
[[<<]]
November 09, 2006, at 10:04 PM by Carlyn Maw -
Added lines 87-89:
%rframe width=200px% [[http://www.arduino.cc/en/uploads/Tutorial/595_logic_table.png |Attach:595_logic_table.png"logic table"]] | [-595 Logic Table-]
%rframe width=200px% [[http://www.arduino.cc/en/uploads/Tutorial/595_timing_diagram.png |Attach:595_timing_diagram.png"logic table"]] | [-595 Timing Diagram-]
Deleted lines 93-95:
%lframe width=200px% [[http://www.arduino.cc/en/uploads/Tutorial/595_logic_table.png |Attach:595_logic_table.png"logic table"]] | [-595 Logic Table-]
%lframe width=200px% [[http://www.arduino.cc/en/uploads/Tutorial/595_timing_diagram.png |Attach:595_timing_diagram.png"logic table"]] | [-595 Timing Diagram-]
November 09, 2006, at 10:02 PM by Carlyn Maw -
Changed lines 87-88 from:
to:
Changed lines 91-97 from:
%lframe thumb% [[Attach:595_logic_table.png |Attach:595_logic_table.png"logic table"]] | [-595 Logic Table-]

%lframe width=200px% [[Attach:595_logic_table.png |Attach:595_logic_table.png"logic table"]] | [-595 Logic Table-]

Attach:595_logic_table.png
Attach:595_timing_diagram.png
to:
%lframe width=200px% [[http://www.arduino.cc/en/uploads/Tutorial/595_logic_table.png |Attach:595_logic_table.png"logic table"]] | [-595 Logic Table-]
%lframe width=200px% [[http://www.arduino.cc/en/uploads/Tutorial/595_timing_diagram.png |Attach:595_timing_diagram.png"logic table"]] | [-595 Timing Diagram-]

[[<<]]
November 09, 2006, at 10:00 PM by Carlyn Maw -
Changed lines 87-88 from:
to:
Added lines 91-94:
%lframe thumb% [[Attach:595_logic_table.png |Attach:595_logic_table.png"logic table"]] | [-595 Logic Table-]

%lframe width=200px% [[Attach:595_logic_table.png |Attach:595_logic_table.png"logic table"]] | [-595 Logic Table-]
November 09, 2006, at 09:46 PM by Carlyn Maw -
Deleted lines 54-55:
Attach:ShftOutExmp1_1.gif
Added lines 63-64:
Attach:ShftOutExmp1_1.gif
Deleted lines 66-67:
Attach:ShftOutExmp1_2.gif
Added lines 73-74:
Attach:ShftOutExmp1_2.gif
Added lines 77-78:
Deleted lines 80-81:
Added lines 104-105:
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.
Deleted lines 107-108:
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.
Deleted lines 108-109:

Attach:ShftOutExmp2_2.gif
Added lines 112-113:
Attach:ShftOutExmp2_2.gif
Added lines 116-117:
In this case I added green ones so when reading the code it is clear which byte is going to which set of LEDs
Deleted lines 119-120:
In this case I added green ones so when reading the code it is clear which byte is going to which set of LEDs
November 09, 2006, at 09:41 PM by Carlyn Maw -
November 09, 2006, at 09:41 PM by Carlyn Maw -
Changed line 18 from:
(:cell rowspan=9 :)Attach:pin_diagram.png
to:
(:cell rowspan=9 :)Attach:595_pin_diagram.png
Changed lines 55-56 from:
Attach:Exmp1_1.gif
to:
Attach:ShftOutExmp1_1.gif
Changed lines 67-68 from:
Attach:Exmp1_2.gif
to:
Attach:ShftOutExmp1_2.gif
Changed lines 77-78 from:
Attach:Exmp1_3.gif
to:
Attach:ShftOutExmp1_3.gif
Changed lines 104-105 from:
Attach:Exmp2_1.gif
to:
Attach:ShftOutExmp2_1.gif
Changed line 110 from:
Attach:Exmp2_2.gif
to:
Attach:ShftOutExmp2_2.gif
Changed lines 116-117 from:
Attach:Exmp2_3.gif
to:
Attach:ShftOutExmp2_3.gif
November 09, 2006, at 09:22 PM by Carlyn Maw -
Changed lines 77-78 from:
Attach:Exmp1_.gif
to:
Attach:Exmp1_3.gif
November 09, 2006, at 09:19 PM by Carlyn Maw -
Added lines 55-56:
Attach:Exmp1_1.gif
Added lines 67-68:
Attach:Exmp1_2.gif
Changed lines 75-76 from:
!!!!Add 8 LEDs.
to:
!!!!3. Add 8 LEDs.

Attach:Exmp1_.gif
Added lines 83-84:

Added lines 91-93:
Attach:595_logic_table.png
Attach:595_timing_diagram.png
Added lines 104-105:
Attach:Exmp2_1.gif
Added lines 109-110:

Attach:Exmp2_2.gif
Added lines 115-117:

Attach:Exmp2_3.gif
November 09, 2006, at 09:08 PM by Carlyn Maw -
Changed lines 15-17 from:
Here is a table explaining the pin-outs adapted from the datasheet.

(:table border=1 cellpadding=5 cellspacing=0:)
to:
'''Here is a table explaining the pin-outs adapted from the [[Attach:595datasheet.pdf | Phillip's datasheet]].'''

(:table border=1 bordercolor=#CCCCCC cellpadding=5 cellspacing=0:)
November 09, 2006, at 09:01 PM by Carlyn Maw -
Changed lines 18-48 from:
(:cell rowspan=9 :) a1
(:cell:) b1
(:cell:) c1
(:cell:) d1
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
to:
Deleted lines 47-48:
Attach:pin_diagram.png
November 09, 2006, at 08:53 PM by Carlyn Maw -
Added lines 17-50:
(:table border=1 cellpadding=5 cellspacing=0:)
(:cell rowspan=9 :) a1
(:cell:) b1
(:cell:) c1
(:cell:) d1
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:cellnr:) b2
(:cell:) c2
(:cell:) d2
(:tableend:)
November 09, 2006, at 08:49 PM by Carlyn Maw -
Changed lines 13-14 from:
to:
November 09, 2006, at 08:45 PM by Carlyn Maw -
Changed lines 13-14 from:
to:
November 02, 2006, at 02:38 AM by Carlyn Maw -
Changed lines 9-10 from:
to:
Changed lines 13-14 from:
to:
Changed lines 28-29 from:
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 might 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 also controlling the MR and OE pins from your Arduino board, but this will work and leave you with more open pins.
to:
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.
Changed lines 36-37 from:
to:
Changed lines 40-41 from:
to:
Changed lines 48-49 from:
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 on the shift register. When the latchPin goes from low to high the sent data gets moved from the aforementioned memory register into the output pins, lighting the LEDs.
to:
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.
November 02, 2006, at 02:28 AM by Carlyn Maw -
Changed lines 9-10 from:
to:
Changed lines 13-14 from:
to:
November 02, 2006, at 01:51 AM by Carlyn Maw -
November 02, 2006, at 01:51 AM by Carlyn Maw -
Changed lines 80-81 from:
to:
November 02, 2006, at 01:46 AM by Carlyn Maw -
Changed line 79 from:
[[ShftOut23 | Code Sample 2.3 - Dual Defined Arrays]]
to:
[[ShftOut23 | Code Sample 2.3 - Dual Defined Arrays]]\\
November 02, 2006, at 01:45 AM by Carlyn Maw -
Changed lines 3-4 from:
Carlyn Maw, Tom Igoe
to:
Started by Carlyn Maw and Tom Igoe Nov, 06
Changed line 73 from:
to:
Added lines 75-97:
November 02, 2006, at 01:41 AM by Carlyn Maw -
Added lines 53-74:
November 02, 2006, at 01:34 AM by Carlyn Maw -
Changed lines 50-51 from:
to:
November 02, 2006, at 01:32 AM by Carlyn Maw -
Added line 51:
November 02, 2006, at 01:27 AM by Carlyn Maw -
Added lines 43-50:
November 02, 2006, at 01:25 AM by Carlyn Maw -
Changed lines 36-42 from:
to:
November 02, 2006, at 01:19 AM by Carlyn Maw -
Changed lines 3-4 from:
by Carlyn Maw
to:
Carlyn Maw, Tom Igoe
Changed line 36 from:
to:
November 02, 2006, at 01:18 AM by Carlyn Maw -
Deleted lines 27-49:
Changed line 36 from:
to:
November 02, 2006, at 01:17 AM by Carlyn Maw -
Changed lines 51-52 from:
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 might 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.
>>>>>>>
to:
November 02, 2006, at 01:13 AM by Carlyn Maw -
Added lines 2-4:

by Carlyn Maw
Deleted line 6:
<<<<<<<
November 02, 2006, at 01:13 AM by Carlyn Maw -
Added line 4:
<<<<<<<
Changed lines 26-50 from:
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 might 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.
to:
November 02, 2006, at 01:13 AM by Carlyn Maw -
Added lines 11-25:

!!Example 1: One Shift Register

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

!!!The Circuit
!!!!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 might 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.
November 02, 2006, at 01:09 AM by Carlyn Maw -
Added lines 1-10:

Share