74HC595 with Arduino: How it Works & How to Use [Full Guide]

/*
 Modified on 13 July 2021
 By Amirmohammad Shojaei
 
Home

 based on www.Arduino.cc Example
*/

//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 dataRED;
byte dataGREEN;
byte dataArrayRED[33];
byte dataArrayGREEN[33];

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] = 0b11111111;
 dataArrayRED[1] = 0b11111110;
 dataArrayRED[2] = 0b11111100;
 dataArrayRED[3] = 0b11111000;
 dataArrayRED[4] = 0b11110000;
 dataArrayRED[5] = 0b11100000;
 dataArrayRED[6] = 0b11000000;
 dataArrayRED[7] = 0b10000000;
 dataArrayRED[8] = 0b00000000;
 dataArrayRED[9] = 0b00000000;
 dataArrayRED[10] = 0b00000000;
 dataArrayRED[11] = 0b00000000;
 dataArrayRED[12] = 0b00000000;
 dataArrayRED[13] = 0b00000000;
 dataArrayRED[14] = 0b00000000;
 dataArrayRED[15] = 0b00000000;
 dataArrayRED[16] = 0b00000000;
 dataArrayRED[17] = 0b00000000;
 dataArrayRED[18] = 0b00000000;
 dataArrayRED[19] = 0b00000000;
 dataArrayRED[20] = 0b00000000;
 dataArrayRED[21] = 0b00000000;
 dataArrayRED[22] = 0b00000000;
 dataArrayRED[23] = 0b00000000;
 dataArrayRED[24] = 0b00000000;
 dataArrayRED[25] = 0b00000000;
 dataArrayRED[26] = 0b10000000;
 dataArrayRED[27] = 0b11000000;
 dataArrayRED[28] = 0b11100000;
 dataArrayRED[29] = 0b11110000;
 dataArrayRED[30] = 0b11111000;
 dataArrayRED[31] = 0b11111100;
 dataArrayRED[32] = 0b11111110;
 dataArrayRED[33] = 0b11111111;

 //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] = 0b11111111;
 dataArrayGREEN[1] = 0b11111111;
 dataArrayGREEN[2] = 0b11111111;
 dataArrayGREEN[3] = 0b11111111;
 dataArrayGREEN[4] = 0b11111111;
 dataArrayGREEN[5] = 0b11111111;
 dataArrayGREEN[6] = 0b11111111;
 dataArrayGREEN[7] = 0b11111111;
 dataArrayGREEN[8] = 0b11111111;
 dataArrayGREEN[9] = 0b11111110;
 dataArrayGREEN[10] = 0b11111100;
 dataArrayGREEN[11] = 0b11111000;
 dataArrayGREEN[12] = 0b11110000;
 dataArrayGREEN[13] = 0b11100000;
 dataArrayGREEN[14] = 0b11000000;
 dataArrayGREEN[15] = 0b10000000;
 dataArrayGREEN[16] = 0b00000000;
 dataArrayGREEN[17] = 0b10000000;
 dataArrayGREEN[18] = 0b11000000;
 dataArrayGREEN[19] = 0b11100000;
 dataArrayGREEN[20] = 0b11110000;
 dataArrayGREEN[21] = 0b11111000;
 dataArrayGREEN[22] = 0b11111100;
 dataArrayGREEN[23] = 0b11111110;
 dataArrayGREEN[24] = 0b11111111;
 dataArrayGREEN[25] = 0b11111111;
 dataArrayGREEN[26] = 0b11111111;
 dataArrayGREEN[27] = 0b11111111;
 dataArrayGREEN[28] = 0b11111111;
 dataArrayGREEN[29] = 0b11111111;
 dataArrayGREEN[30] = 0b11111111;
 dataArrayGREEN[31] = 0b11111111;
 dataArrayGREEN[32] = 0b11111111;
 dataArrayGREEN[33] = 0b11111111;
 
 //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 < 34; 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(30);
 }
}

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