Tutorial.ShftOut13 History

Hide minor edits - Show changes to output

November 05, 2013, at 08:11 PM by Scott Fitzgerald -
Changed lines 2-3 from:

[@
to:
(:source lang=arduino tabwidth=4:)
Changed lines 5-9 from:
for two 74HC595 shift registers

This sketch turns on each of the LEDs attached to two 74HC595 shift registers,
in sequence from output 0 to output 15.
to:
Turning on the outputs of a 74HC595 using an array
Changed lines 8-9 from:
* 2 74HC595 shift register attached to pins 2, 3, and 4 of the Arduino,
as detailed below.
to:
* 74HC595 shift register
Changed lines 10-14 from:

Created 22 May 2009
Modified 23 Mar 2010
by Tom Igoe
to:
Changed lines 12-21 from:

//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 8;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 12;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 11;

char inputString[2];
to:
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;

//holders for infromation you're going to pass to shifting function
byte data;
byte dataArray[10];
Deleted lines 25-26:
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
Changed lines 27-43 from:
Serial.println("reset");
to:

//Arduino doesn't seem to have a way to write binary straight into the code
//so these values are in HEX. Decimal would have been fine, too.
dataArray[0] = 0xFF; //11111111
dataArray[1] = 0xFE; //11111110
dataArray[2] = 0xFC; //11111100
dataArray[3] = 0xF8; //11111000
dataArray[4] = 0xF0; //11110000
dataArray[5] = 0xE0; //11100000
dataArray[6] = 0xC0; //11000000
dataArray[7] = 0x80; //10000000
dataArray[8] = 0x00; //00000000
dataArray[9] = 0xE0; //11100000

//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(2,500);
Changed lines 47-60 from:
// iterate over the 16 outputs of the two shift registers
for (int thisLed = 0; thisLed < 16; thisLed++) {
// write data to the shift registers:
registerWrite(thisLed, HIGH);
// if this is not the first LED, turn off the previous LED:
if (thisLed > 0) {
registerWrite(thisLed - 1, LOW);
}
// if this is the first LED, turn off the highest LED:
else {
registerWrite(15, LOW);
}
// pause between LEDs:
delay(250);
to:

for (int j = 0; j < 10; j++) {
//load the light sequence you want from array
data = dataArray[j];
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//move 'em out
shiftOut(dataPin, clockPin, data);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(300);
Deleted line 59:
Changed lines 62-86 from:
// This method sends bits to the shift registers:

void registerWrite(int whichPin, int whichState) {
// the bits you want to send. Use an unsigned int,
// so you can use all 16 bits:
unsigned int bitsToSend = 0;

// turn off the output so the pins don't light up
// while you're shifting bits:
digitalWrite(latchPin, LOW);

// turn on the next highest bit in bitsToSend:
bitWrite(bitsToSend, whichPin, whichState);

// break the bits into two bytes, one for
// the first register and one for the second:
byte registerOne = highByte(bitsToSend);
byte registerTwo = lowByte(bitsToSend);

// shift the bytes out:
shiftOut(dataPin, clockPin, MSBFIRST, registerTwo);
shiftOut(dataPin, clockPin, MSBFIRST, registerOne);

// turn on the output so the LEDs can light up:
digitalWrite(latchPin, HIGH);
to:


// the heart of the program
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
// This shifts 8 bits out MSB first,
//on the rising edge of the clock,
//clock idles low

//internal function setup
int i=0;
int pinState;
pinMode(myClockPin, OUTPUT);
pinMode(myDataPin, OUTPUT);

//clear everything out just in case to
//prepare shift register for bit shifting
digitalWrite(myDataPin, 0);
digitalWrite(myClockPin, 0);

//for each bit in the byte myDataOut´┐Ż
//NOTICE THAT WE ARE COUNTING DOWN in our for loop
//This means that %00000001 or "1" will go through such
//that it will be pin Q0 that lights.
for (i=7; i>=0; i--) {
digitalWrite(myClockPin, 0);

//if the value passed to myDataOut and a bitmask result
// true then... so if we are at i=6 and our value is
// %11010100 it would the code compares it to %01000000
// and proceeds to set pinState to 1.
if ( myDataOut & (1<<i) ) {
pinState= 1;
}
else {
pinState= 0;
}

//Sets the pin to HIGH or LOW depending on pinState
digitalWrite(myDataPin, pinState);
//register shifts bits on upstroke of clock pin
digitalWrite(myClockPin, 1);
//zero the data pin after shift to prevent bleed through
digitalWrite(myDataPin, 0);
}

//stop shifting
digitalWrite(myClockPin, 0);
Changed lines 111-135 from:
@]
to:

//blinks the whole register based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll_2Bytes(int n, int d) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(200);
for (int x = 0; x < n; x++) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 255);
shiftOut(dataPin, clockPin, 255);
digitalWrite(latchPin, 1);
delay(d);
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(d);
}
}
(:sourceend:)
March 25, 2010, at 12:10 AM by Tom Igoe -
Changed lines 68-69 from:
digitalWrite(latchPin, HIGH);
to:
digitalWrite(latchPin, LOW);
Changed line 83 from:
digitalWrite(latchPin, LOW);
to:
digitalWrite(latchPin, HIGH);
March 25, 2010, at 12:10 AM by Tom Igoe -
Changed line 23 from:
const int latchPin = 4;
to:
const int latchPin = 8;
Changed line 25 from:
const int clockPin = 3;
to:
const int clockPin = 12;
Changed lines 27-28 from:
const int dataPin = 2;
to:
const int dataPin = 11;
March 24, 2010, at 01:42 PM by Tom Igoe -
Changed lines 4-23 from:
//**************************************************************//
// Name : shiftOutCode, Predefined Array Style //
// Author : Carlyn Maw, Tom Igoe //
// Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255 //
//****************************************************************

//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;

//holders for infromation you're going to pass to shifting function
byte data;
byte dataArray[10];
to:
/*
Shift Register Example
for two 74HC595 shift registers

This sketch turns on each of the LEDs attached to two 74HC595 shift registers,
in sequence from output 0 to output 15.

Hardware:
* 2 74HC595 shift register attached to pins 2, 3, and 4 of the Arduino,
as detailed below.
* LEDs attached to each of the outputs of the shift register

Created 22 May 2009
Modified 23 Mar 2010
by Tom Igoe

*/

//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 4;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 3;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 2;

char inputString[2];
Added lines 34-35:
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
Changed lines 37-53 from:

//Arduino doesn't seem to have a way to write binary straight into the code
//so these values are in HEX. Decimal would have been fine, too.
dataArray[0] = 0xAA; //10101010
dataArray[1] = 0x55; //01010101
dataArray[2] = 0x81; //10000001
dataArray[3] = 0xC3; //11000011
dataArray[4] = 0xE7; //11100111
dataArray[5] = 0xFF; //11111111
dataArray[6] = 0x7E; //01111110
dataArray[7] = 0x3C; //00111100
dataArray[8] = 0x18; //00011000
dataArray[9] = 0x00; //00000000

//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll(2,500);
to:
Serial.println("reset");
Changed lines 41-53 from:


for (int j = 0; j < 10; j++) {
//load the light sequence you want from array
data = dataArray[j];
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//move 'em out
shiftOut(dataPin, clockPin, data);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
to:
// iterate over the 16 outputs of the two shift registers
for (int thisLed = 0; thisLed < 16; thisLed++) {
// write data to the shift registers:
registerWrite(thisLed, HIGH);
// if this is not the first LED, turn off the previous LED:
if (thisLed > 0) {
registerWrite(thisLed - 1, LOW);
}
// if this is the first LED, turn off the highest LED:
else {
registerWrite(15, LOW);
}
// pause between LEDs:
delay(250);
Added line 56:
Changed lines 59-105 from:
to:
// This method sends bits to the shift registers:

void registerWrite(int whichPin, int whichState) {
// the bits you want to send. Use an unsigned int,
// so you can use all 16 bits:
unsigned int bitsToSend = 0;

// turn off the output so the pins don't light up
// while you're shifting bits:
digitalWrite(latchPin, HIGH);

// turn on the next highest bit in bitsToSend:
bitWrite(bitsToSend, whichPin, whichState);

// break the bits into two bytes, one for
// the first register and one for the second:
byte registerOne = highByte(bitsToSend);
byte registerTwo = lowByte(bitsToSend);

// shift the bytes out:
shiftOut(dataPin, clockPin, MSBFIRST, registerTwo);
shiftOut(dataPin, clockPin, MSBFIRST, registerOne);

// turn on the output so the LEDs can light up:
digitalWrite(latchPin, LOW);
Deleted lines 85-105:

//blinks the whole register based on the number of times you want to
//blink "n" and the pause between them "d"
//starts with a moment of darkness to make sure the first blink
//has its full visual effect.
void blinkAll(int n, int d) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(200);
for (int x = 0; x < n; x++) {
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 255);
digitalWrite(latchPin, 1);
delay(d);
digitalWrite(latchPin, 0);
shiftOut(dataPin, clockPin, 0);
digitalWrite(latchPin, 1);
delay(d);
}
}
November 02, 2006, at 01:35 AM by Carlyn Maw -
Added lines 1-2:
[[ShiftOut | Back to ShiftOut Tutorial]]
November 02, 2006, at 01:35 AM by Carlyn Maw -
Added lines 1-132:

Share