74HC595를 사용한 직렬에서 병렬로의 이동

 

74HC595를 사용한 직렬에서 병렬로의 이동

 

언젠가는 Arduino 보드의 핀이 부족하여 시프트 레지스터로 확장해야 할 수 있습니다.

 

 Shift Out & 595 IC

 

언젠가는 Arduino 보드의 핀이 부족하여 시프트 레지스터로 확장해야 할 수 있습니다. 이 예는 74HC595를 기반으로 합니다. 데이터시트에서는 74HC595를 "출력 래치가 있는 8비트 직렬 입력, 직렬 또는 병렬 출력 시프트 레지스터; 3상태"라고 합니다. 즉, 마이크로컨트롤러에서 몇 개의 핀만 차지하면서 한 번에 8개의 출력을 제어하는 ​​데 사용할 수 있습니다. 여러 레지스터를 연결하여 출력을 더욱 확장할 수 있습니다. (사용자는 또한 부품 번호에 "595" 또는 "596"이 있는 다른 드라이버 칩을 검색하고 싶어할 수 있습니다. 많은 칩이 있습니다. 예를 들어 STP16C596은 16개의 LED를 구동하고 내장된 정전류 소스로 직렬 저항을 제거합니다.)

 

이 모든 것이 작동하는 방식은 "동기 직렬 통신"이라고 하는 것을 통해 이루어집니다. 즉, 한 핀을 위아래로 펄스하여 데이터 바이트를 비트 단위로 레지스터에 통신할 수 있습니다. 두 번째 핀인 클록 핀을 펄스하여 비트 사이를 구분합니다. 이는 송신자와 수신자가 합의된 지정된 데이터 속도로 독립적으로 설정되어야 하는 Serial.begin() 함수의 "비동기 직렬 통신"을 사용하는 것과 대조적입니다. 전체 바이트가 레지스터로 전송되면 각 비트에 보관된 HIGH 또는 LOW 메시지가 각 개별 출력 핀으로 분할됩니다. 이것이 "병렬 출력" 부분으로, 모든 핀이 한 번에 원하는 작업을 수행하도록 합니다.

 

이 구성 요소의 "직렬 출력" 부분은 마이크로컨트롤러에서 수신한 직렬 정보를 변경하지 않고 다시 전달할 수 있는 추가 핀에서 나옵니다. 즉, 16비트(2바이트)를 연속으로 전송할 수 있으며 처음 8비트는 첫 번째 레지스터를 통해 두 번째 레지스터로 흘러 들어가 표현됩니다. 두 번째 예제에서 이를 수행하는 방법을 배울 수 있습니다.

 

"3가지 상태"는 출력 핀을 높음, 낮음 또는 "높은 임피던스"로 설정할 수 있다는 사실을 나타냅니다. HIGH 및 LOW 상태와 달리 핀을 개별적으로 높은 임피던스 상태로 설정할 수 없습니다. 전체 칩을 함께 설정할 수만 있습니다. 이것은 매우 특수한 작업입니다. 프로젝트에 내장된 특정 모드 설정에 따라 완전히 다른 마이크로컨트롤러로 제어해야 할 수 있는 LED 어레이를 생각해 보세요. 어느 예제도 이 기능을 활용하지 않으며 일반적으로 이 기능이 있는 칩을 얻는 것에 대해 걱정할 필요가 없습니다.

 

다음은 Phillip의 데이터시트에서 수정한 핀아웃을 설명하는 표입니다.

 

595 핀 다이어그램

 

 

PINS 1-7, 15	Q0 - Q7	Output Pins
PIN 8	GND	Ground, Vss
PIN 9	Q7	Serial Out
PIN 10	MR	Master Reclear, active low
PIN 11	SH_CP	Shift register clock pin
PIN 12	ST_CP	Storage register clock pin (latch pin)
PIN 13	OE	Output enable, active low
PIN 14	DS	Serial data input
PIN 16	Vcc	Positive supply voltage

 

 

예 1: 시프트 레지스터 하나

 

첫 번째 단계는 Arduino를 시프트 레지스터 하나로 확장하는 것입니다. 회로는 아래에 있으며 다음과 같이 연결합니다.

 

1. 켜기

• GND(핀 8)를 접지에,
• Vcc(핀 16)를 5V에
• OE(핀 13)를 접지에
• MR(핀 10)을 5V에

 

이 설정은 모든 출력 핀을 항상 활성화하고 주소 지정할 수 있게 합니다. 이 설정의 한 가지 단점은 프로그램이 실행되기 전에 회로에 처음 전원을 켤 때마다 조명이 마지막 상태나 임의의 상태로 켜진다는 것입니다. Arduino 보드에서 MR 및 OE 핀을 제어하여 이를 해결할 수도 있지만 이 방법이 효과가 있고 더 많은 개방형 핀이 남습니다.

 

 

2. Arduino에 연결

 

• DS(핀 14)에서 Ardunio DigitalPin 11(파란색 전선)
• SH_CP(핀 11)에서 Ardunio DigitalPin 12(노란색 전선)
• ST_CP(핀 12)에서 Ardunio DigitalPin 8(녹색 전선)

 

이제부터는 각각 dataPin, clockPin, ladderPin이라고 합니다. 래치핀에 0.1"f 커패시터가 있는지 확인하세요. 래치핀이 펄스할 때 깜박임이 있으면 커패시터를 사용하여 균등하게 만들 수 있습니다.

 

 

3. LED 8개를 추가합니다.

 

이 경우 각 LED의 캐소드(짧은 핀)를 공통 접지에 연결하고 각 LED의 애노드(긴 핀)를 해당 시프트 레지스터 출력 핀에 연결해야 합니다. 이와 같이 시프트 레지스터를 사용하여 전원을 공급하는 것을 소싱 전류라고 합니다. 일부 시프트 레지스터는 전류를 소싱할 수 없고 싱킹 전류라고 하는 작업만 할 수 있습니다. 이러한 레지스터 중 하나가 있는 경우 LED 방향을 뒤집어 애노드를 전원에 직접 연결하고 캐소드(접지 핀)를 시프트 레지스터 출력에 연결해야 합니다. 595 시리즈 칩을 사용하지 않는 경우 특정 데이터시트를 확인해야 합니다. LED가 과부하되지 않도록 470옴 저항을 직렬로 추가하는 것을 잊지 마세요.

 

 

ShftOut Schm1

 

 

코드

 

다음은 세 가지 코드 예입니다. 첫 번째는 단순히 0에서 255까지의 바이트 값을 출력하는 "hello world" 코드입니다. 두 번째 프로그램은 한 번에 하나의 LED를 켭니다. 세 번째는 배열을 순환합니다.

 

595 논리 표: 논리 표

595 타이밍 다이어그램: 논리 표

 

코드는 데이터시트의 두 가지 정보, 즉 타이밍 다이어그램과 논리 표에 기반합니다. 논리 표는 기본적으로 모든 중요한 일이 상향 비트에서 발생한다는 것을 알려줍니다. 클록 핀이 로우에서 하이로 이동하면 시프트 레지스터가 데이터 핀의 상태를 읽습니다. 데이터가 시프트되면 내부 메모리 레지스터에 저장됩니다. 래치 핀이 로우에서 하이로 이동하면 전송된 데이터가 앞서 언급한 시프트 레지스터의 메모리 레지스터에서 출력 핀으로 이동하여 LED를 켭니다.

 

코드 샘플 1.1 Hello World

코드 샘플 1.2 One by One

코드 샘플 1.3 배열 사용

 

예제 2

 

이 예제에서는 두 번째 시프트 레지스터를 추가하여 Arduino에서 동일한 수의 핀을 사용하면서 출력 핀 수를 두 배로 늘립니다.

 

회로

 

1. 두 번째 시프트 레지스터를 추가합니다.

 

이전 예제에서 시작하여 보드에 두 번째 시프트 레지스터를 넣어야 합니다. 전원과 접지에 동일한 리드가 있어야 합니다.

 

 

2. 두 레지스터를 연결합니다.

 

이 연결 중 두 개는 Arduino에서 두 번째 시프트 레지스터(노란색과 녹색 전선)로 동일한 클록 및 래치 신호를 확장합니다. 파란색 전선은 첫 번째 시프트 레지스터의 직렬 출력 핀(핀 9)에서 두 번째 레지스터의 직렬 데이터 입력(핀 14)으로 연결됩니다.

 

 

3. 두 번째 LED 세트를 추가합니다.

 

이 경우 녹색을 추가했으므로 코드를 읽을 때 어떤 바이트가 어떤 LED 세트로 가는지 명확하게 알 수 있습니다.

 

회로도

 

 

ShftOut Schm2

 

 

 

코드

 

다음은 세 가지 코드 샘플입니다. 궁금하다면 이 회로를 설정한 첫 번째 예제의 샘플을 시도하여 무슨 일이 일어나는지 확인해 보세요.

 

코드 샘플 2.1 이중 바이너리 카운터 예제 1의 첫 번째 코드 샘플과 비교하면 코드가 한 줄 더 있습니다. 두 번째 바이트를 보냅니다. 이렇게 하면 Arduino에 직접 연결된 첫 번째 시프트 레지스터가 전송된 첫 번째 바이트를 두 번째 레지스터로 전달하여 녹색 LED를 켭니다. 그러면 두 번째 바이트가 빨간색 LED에 표시됩니다.

 

코드 샘플 2.2 2바이트 하나씩 이 코드를 예제 1의 비슷한 코드와 비교하면 약간 더 많은 것을 변경해야 했다는 것을 알 수 있습니다. blinkAll() 함수는 이제 제어할 LED가 16개라는 사실을 반영하기 위해 blinkAll_2Bytes() 함수로 변경되었습니다. 또한 버전 1에서 래치핀의 펄싱은 하위 함수 lightShiftPinA와 lightShiftPinB() 내부에 위치했습니다. 여기서는 각 하위 함수를 녹색 LED에 한 번, 빨간색 LED에 한 번, 두 번 연속으로 실행해야 하는 필요성을 수용하기 위해 메인 루프로 다시 옮겨야 합니다.

 

코드 샘플 2.3 - 이중 정의된 배열 샘플 2.2와 마찬가지로 샘플 2.3도 새로운 blinkAll_2bytes() 함수를 활용합니다. 샘플 1.3과 2.3의 큰 차이점은 "data"라는 단일 변수와 "dataArray"라는 단일 배열 대신 dataRED, dataGREEN, dataArrayRED, dataArrayGREEN을 미리 정의해야 한다는 것입니다. 즉, 다음 줄

 

data = dataArray[j];

 

이 다음과 같이 됩니다.

 

dataRED = dataArrayRED[j];dataGREEN = dataArrayGREEN[j];

 

및 ShiftOut(dataPin, clockPin, 데이터);

 

ShiftOut(dataPin, clockPin, dataGREEN);shiftOut(dataPin, clockPin, dataRED);

 

 

위에서 예로 든 모든 코드들이 아래에 있습니다.

 

ShftOut11

 

//**************************************************************//
//  Name    : shiftOutCode, Hello World
//  Author  : Carlyn Maw,Tom Igoe, David A. Mellis
//  Date    : 25 Oct, 2006
//  Modified: 23 Mar 2010
//  Version : 2.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;
void setup() {
//set pins to output so you can control the shift register
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
void loop() {
// count from 0 to 255 and display the number
// on the LEDs
for (int numberToDisplay = 0; numberToDisplay < 256; numberToDisplay++) {
// take the latchPin low so
// the LEDs don't change while you're sending in bits:
digitalWrite(latchPin, LOW);
// shift out the bits:
shiftOut(dataPin, clockPin, MSBFIRST, numberToDisplay);
//take the latch pin high so the LEDs will light up:
digitalWrite(latchPin, HIGH);
// pause before next value:
delay(500);
}
}

 

ShftOut12

 

/*
Shift Register Example
for 74HC595 shift register
This sketch turns reads serial input and uses it to set the pins
of a 74HC595 shift register.
Hardware:
* 74HC595 shift register attached to pins 8, 12, and 11 of the Arduino,
as detailed below.
* LEDs attached to each of the outputs of the shift register.
Created 22 May 2009
Created 23 Mar 2010
by Tom Igoe
*/
//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;
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
Serial.begin(9600);
Serial.println("reset");
}
void loop() {
if (Serial.available() > 0) {
// ASCII '0' through '9' characters are
// represented by the values 48 through 57.
// so if the user types a number from 0 through 9 in ASCII,
// you can subtract 48 to get the actual value:
int bitToSet = Serial.read() - 48;
// write to the shift register with the correct bit set high:
registerWrite(bitToSet, HIGH);
}
}
// This method sends bits to the shift register:
void registerWrite(int whichPin, int whichState) {
// the bits you want to send
byte 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);
// shift the bits out:
shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend);
// turn on the output so the LEDs can light up:
digitalWrite(latchPin, HIGH);
}

 

ShftOut13

 

/*

  Shift Register Example

  Turning on the outputs of a 74HC595 using an array

 Hardware:

 * 74HC595 shift register

 * LEDs attached to each of the outputs of the shift register

 */
//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 information you're going to pass to shifting function
byte data;
byte dataArray[10];

void setup() {

  //set pins to output because they are addressed in the main loop

  pinMode(latchPin, OUTPUT);

  Serial.begin(9600);

  //Binary notation as comment

  dataArray[0] = 0xFF; //0b11111111

  dataArray[1] = 0xFE; //0b11111110

  dataArray[2] = 0xFC; //0b11111100

  dataArray[3] = 0xF8; //0b11111000

  dataArray[4] = 0xF0; //0b11110000

  dataArray[5] = 0xE0; //0b11100000

  dataArray[6] = 0xC0; //0b11000000

  dataArray[7] = 0x80; //0b10000000

  dataArray[8] = 0x00; //0b00000000

  dataArray[9] = 0xE0; //0b11100000

  //function that blinks all the LEDs

  //gets passed the number of blinks and the pause time

  blinkAll_2Bytes(2,500);
}

void loop() {

  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);

  }
}

// 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&#xFFFD;

  //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);
}

//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);

  }
}

 

ShftOut21

 

//**************************************************************//
//  Name    : shiftOutCode, Dual Binary Counters                 //
//  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;
void setup() {
//Start Serial for debugging purposes
Serial.begin(9600);
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
}
void loop() {
//count up routine
for (int j = 0; j < 256; j++) {
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//count up on GREEN LEDs
shiftOut(dataPin, clockPin, j);
//count down on RED LEDs
shiftOut(dataPin, clockPin, 255-j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
}
}
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&#xFFFD;
//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);
}

 

ShftOut22

 

//**************************************************************//
//  Name    : shiftOutCode, Dual One By One                           //
//  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;
//holder for information you're going to pass to shifting function
byte data = 0;
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
}
void loop() {
//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(1,500);
// light each pin one by one using a function A
for (int j = 0; j < 8; j++) {
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//red LEDs
lightShiftPinA(7-j);
//green LEDs
lightShiftPinA(j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
}
// light each pin one by one using a function A
for (int j = 0; j < 8; j++) {
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//red LEDs
lightShiftPinB(j);
//green LEDs
lightShiftPinB(7-j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(1000);
}
}
//This function uses bitwise math to move the pins up
void lightShiftPinA(int p) {
//defines a local variable
int pin;
//this is line uses a bitwise operator
//shifting a bit left using << is the same
//as multiplying the decimal number by two.
pin = 1<< p;
//move 'em out
shiftOut(dataPin, clockPin, pin);
}
//This function uses that fact that each bit in a byte
//is 2 times greater than the one before it to
//shift the bits higher
void lightShiftPinB(int p) {
//defines a local variable
int pin;
//start with the pin = 1 so that if 0 is passed to this
//function pin 0 will light.
pin = 1;
for (int x = 0; x < p; x++) {
pin = pin * 2;
}
//move 'em out
shiftOut(dataPin, clockPin, pin);
}
// 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&#xFFFD;
//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);
}
//blinks both registers 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);
}
}

 

ShftOut23 

 

//**************************************************************//
//  Name    : shiftOutCode, Predefined Dual 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 information you're going to pass to shifting function
byte dataRED;
byte dataGREEN;
byte dataArrayRED[10];
byte dataArrayGREEN[10];
void setup() {
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
Serial.begin(9600);
//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.
dataArrayRED[0] = 0xFF; //11111111
dataArrayRED[1] = 0xFE; //11111110
dataArrayRED[2] = 0xFC; //11111100
dataArrayRED[3] = 0xF8; //11111000
dataArrayRED[4] = 0xF0; //11110000
dataArrayRED[5] = 0xE0; //11100000
dataArrayRED[6] = 0xC0; //11000000
dataArrayRED[7] = 0x80; //10000000
dataArrayRED[8] = 0x00; //00000000
dataArrayRED[9] = 0xE0; //11100000
//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.
dataArrayGREEN[0] = 0xFF; //11111111
dataArrayGREEN[1] = 0x7F; //01111111
dataArrayGREEN[2] = 0x3F; //00111111
dataArrayGREEN[3] = 0x1F; //00011111
dataArrayGREEN[4] = 0x0F; //00001111
dataArrayGREEN[5] = 0x07; //00000111
dataArrayGREEN[6] = 0x03; //00000011
dataArrayGREEN[7] = 0x01; //00000001
dataArrayGREEN[8] = 0x00; //00000000
dataArrayGREEN[9] = 0x07; //00000111
//function that blinks all the LEDs
//gets passed the number of blinks and the pause time
blinkAll_2Bytes(2,500);
}
void loop() {
for (int j = 0; j < 10; j++) {
//load the light sequence you want from array
dataRED = dataArrayRED[j];
dataGREEN = dataArrayGREEN[j];
//ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, 0);
//move 'em out
shiftOut(dataPin, clockPin, dataGREEN);
shiftOut(dataPin, clockPin, dataRED);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, 1);
delay(300);
}
}
// 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&#xFFFD;
//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);
}
//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);
}
}