3x 74HC595 registers driving RGB LEDs with common anode---

Hey guys, new to Arduino and programming, but not to basic electronics. I'm 24 and I'm going to college for computer electronics and probably going to transfer to university for electrical engineering. We haven't covered digital circuits yet, or any kind of subject related to that matter (we're only on electromagnetism!) first semester as well, due to me taking wrong paths in life in the years before.

anywho. I'm trying to use 3x 74HC595 shift registers to control only 8 RGB LEDs. I know it may not seem optimal, or even logical to have such a mess of a breadboard for just 8 LEDs, but it's a learning experience.

I have each shift register dedicated to 1 color on each LED. that means, 1 for controlling red, 1 for blue, and 1 for green. I can see one problem with the whole circuit is that the LEDs are common anode... which means I'd have to drive the outputs low on the shift registers. I've tried using and modifying code available on the web, but I've just about pulled my hair out.

I've attached a schematic showing how I have it wired. The original image comes from the ShiftOut tutorial, but I modified it to reflect what's on my breadboard. Also, the schematic shows each individual LED, when in fact I'm using RGB LEDs.
note -- i chained all 3 of the ICs correctly -- it's not wired like this on the breadboard -- the data wire

Any kind of enlightenment would be greatly appreciated.

Thanks!

Also, for you guys who like to see wires and stuff--

Take the cap off the latchpin line, that is an error on the tutorial.
Add a 100nf/0.1uF cap across each shift registers +5/Gnd pins.

Check the current out of the HC595s, they are pretty low current.
(5V - Vforward_led)/220 = ??

May need to adjust by LED color, Red usually has lower Vforward than blue/green.

If common anode, then you need +5 on the anode line, and let the shift registers take the cathodes low to light them up - your LEDs are upside down on the schematic.

Your pin names are funny.
Make sure shiftclock goes to pin 11, and output latch goes to pin 12.

CrossRoads:
Take the cap off the latchpin line, that is an error on the tutorial.
Add a 100nf/0.1uF cap across each shift registers +5/Gnd pins.

Check the current out of the HC595s, they are pretty low current.
(5V - Vforward_led)/220 = ??

May need to adjust by LED color, Red usually has lower Vforward than blue/green.

If common anode, then you need +5 on the anode line, and let the shift registers take the cathodes low to light them up - your LEDs are upside down on the schematic.

Your pin names are funny.
Make sure shiftclock goes to pin 11, and output latch goes to pin 12.

I'll modify the circuit as you say, sir. I just need to add capacitors, everything else is fine. I didn't bother editing the resistors, so don't mind that part. Thanks for the prompt reply

I'm assuming I'll have to modify this somehow to be able to change colors... because right now, it just counts up like in the dataArrayCOLOR section..

1
11
111
1111
11111... etc, and then shuts off, and restarts, using all 3 colors. I should study more into it, but I'm typically a hands on learner... being able to see the effects of what I'm doing...

Sorry for the such newbieness...

//**************************************************************//
//  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 infromation you're going to pass to shifting function
byte dataRED;
byte dataGREEN;
byte dataBLUE;
byte dataArrayRED[10];
byte dataArrayGREEN[10];
byte dataArrayBLUE[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;

  //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] = 0xFE; //01111111
  dataArrayGREEN[2] = 0xFC; //00111111
  dataArrayGREEN[3] = 0xF8; //00011111
  dataArrayGREEN[4] = 0xF0; //00001111
  dataArrayGREEN[5] = 0xE0; //00000111
  dataArrayGREEN[6] = 0xC0; //00000011
  dataArrayGREEN[7] = 0x80; //00000001
  dataArrayGREEN[8] = 0x00;
  
  dataArrayBLUE[0] = 0xFF;
  dataArrayBLUE[1] = 0xFE;
  dataArrayBLUE[2] = 0xFC;
  dataArrayBLUE[3] = 0xF8;
  dataArrayBLUE[4] = 0xF0;
  dataArrayBLUE[5] = 0xE0;
  dataArrayBLUE[6] = 0xC0;
  dataArrayBLUE[7] = 0x80;
  dataArrayBLUE[8] = 0x00;

  //function that blinks all the LEDs
  //gets passed the number of blinks and the pause time
  blinkAll_2Bytes(2,1000); 
}

void loop() {


  for (int j = 0; j < 10; j++) {
    //load the light sequence you want from array
    dataRED = dataArrayRED[j];
    dataGREEN = dataArrayGREEN[j];
    dataBLUE = dataArrayBLUE[j];
    //ground latchPin and hold low for as long as you are transmitting
    digitalWrite(latchPin, 1);
    //move 'em out
    shiftOut(dataPin, clockPin, dataGREEN);   
    shiftOut(dataPin, clockPin, dataRED);
    shiftOut(dataPin, clockPin, dataBLUE);
    //return the latch pin high to signal chip that it 
    //no longer needs to listen for information
    digitalWrite(latchPin, 0);
    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�
  //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);
  }
}

//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
Serial.begin(9600);

How about the other 2 control pins also?

" //Arduino doesn't seem to have a way to write binary straight into the code"
This is how:
dataArrayRED[0] = B11111111; // 0xFF

I'll leave the color changing decisions up to you

CrossRoads:
//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
Serial.begin(9600);

How about the other 2 control pins also?

" //Arduino doesn't seem to have a way to write binary straight into the code"
This is how:
dataArrayRED[0] = B11111111; // 0xFF

I'll leave the color changing decisions up to you

Thanks a ton, bro. You are a scholar. I'll save this thread and the rest of the project for tomorrow, I'm quite tired at 12:30AM

Same here, 1:30AM, off to bed.