Hello,
is it possible to build a 48x24 led matrix with 5mm leds using 74HC595 shift register using leds with theses specs Forward Voltage(V):2.8-3.6V current:15-20mA.................I would like some opinions on doing this
Yes you can. 74HC595 not good for much current tho, 70mA total per device, so you must limit current to 8-9mA per pin. Better option is to use 74HC595 to control transistors or transistor arrays to source & sink current.
What is your multiplexing plan? Whole rows? Whole columns? One LED at a time?
With that many LEDs, you may want to consider a MAX7219 per 8x8 block, $1.25 at taydaelectronics.com.
Will also make for a brighter display with 8 LEDs on per 8x8 block instead of 1 row or 1 column with traditional multiplexing.
not exactly sure what my plan is yet I am still doing my home work I have realized that the messages I want to display are big and I need a large matrix with individual led control..........Crossroads what would you do????? I have just discovered this bad boy and am thinking this may be an option TPIC6B595 or I was thinking of making several 10x10 matrices and daisy chaining them together
48x24 = 1152, if RGB, than 1152 x3 = 3456, check memory size. What kind of board?
using uno r3 and only blue led for now what your thinking I will run out of room for programming???
I'd go with MAX7219s, just for the brightness.
24 LEDs is too much current for TCIP6B595 to sink (24 * .02 = .48A)
With standard multiplexing you will only have one column of 24 on for 1/48th of the time, or one column of 48 on for 1/24th of the time. With MAX7219, you'll have 1/8 of the LEDs on and multiplexing controlled by the MAX7219s, which multipexes at 800 Hz. Then your processing time can be spent sending data via SPI to update the display.
48x24 = 6x3 = 18 matrices, 8 bytes of memory for each, so 144 bytes to hold the next image or whatever to be displayed.
Crossroads do you know of a good tutorial or example of a matrix using MAX7219 I am familiar with the 595's but I don't think I am going to use those as I would need a ton of them for that size matrix
Yes I do - check out this one
http://forum.arduino.cc//index.php?topic=171056.0
Should be just what you need.
what do you think of using this and expanding it I have all of the hardware for this as wee speak it may be more work but would not require me to spend more money............... http://www.instructables.com/id/Make-a-24X6-LED-matrix/step3/Schematics/
Your call.
ok next question would be how to connect 3 4017 decade counters together to scan 24 rows on a 48x24 matrix
OK I have read several thing stating this isnt possible but then I found this example what do y'all think of doing this to control 24 rows of leds
even better look at this option............ I believe this is what should be done I don't think I need the logic gates for this project anyone see an issue controlling 24 rows of leds like this
Looks like homework to me. What else reason could be to choose 4017 over 595?
The another issue you may encounter except memory limits (which isn't the case for single color led's and UNO), is a refresh rate in case you need to control a brightness as well.
what is the difference in using a 4017 as a decade counter or used in a sequential counting method???? how do I tell the difference between the to options??? all I want to do is link 3 4017 together to scan 24 rows of leds
4017s are not directly linkable
You have a microcontroller on hand - you don't need any extra logic.
Can clock them all in parallel, reset them all in parallel, but need to use a Clock Enable with each one individually similar to having a Chip Select for each one.
You have HC595's? Daisy chain them and SPI in 9 bytes of anode data and 6 bytes of cathode data
So for example you have 3 HC595s holding anode data, and 6 TPIC6B595s (or equivalent high current sink - HC595 with transistors, or ULN2803) holding cathode data (or vice versa):
dataArray[144]; // 3 bytes x 48 coluns = 144 bytes, displayed 3 bytes at a time
// arranged as 48 columns of 24 LEDs. See attached schematic
cathodeArray[] = { // 288 bytes of cathode data
0x01,0,0,0,0,0, // cathode shift register 0
0x02,0,0,0,0,0, // Rats! Need 1 output Low, not High - invert all this data!
0x04,0,0,0,0,0 // so 11111110, FE; 11111101, FD; 11111011, FB; 11110111, F7; 11101111, EF; 11011111, DF; 10111111, BF; 01111111,7F
0x08,0,0,0,0,0, // and FF in place of 0s
0x10,0,0,0,0,0,
0x20,0,0,0,0,0,
0x40,0,0,0,0,0,
0x80,0,0,0,0,0,
0,0x01,0,0,0,0, // cathode shift register 1
0,0x02,0,0,0,0,
0,0x04,0,0,0,0,
0,0x08,0,0,0,0,
0,0x10,0,0,0,0,
0,0x20,0,0,0,0,
0,0x40,0,0,0,0,
0,0x80,0,0,0,0,
0,0,0x01,0,0,0, // cathode shift register 2
0,0,0x02,0,0,0,
0,0,0x04,0,0,0,
0,0,0x08,0,0,0,
0,0,0x10,0,0,0,
0,0,0x20,0,0,0,
0,0,0x40,0,0,0,
0,0,0x80,0,0,0,
0,0,0,0x01,0,0, // cathode shift register 3
0,0,0,0x02,0,0,
0,0,0,0x04,0,0,
0,0,0,0x08,0,0,
0,0,0,0x10,0,0,
0,0,0,0x20,0,0,
0,0,0,0x40,0,0,
0,0,0,0x80,0,0,
0,0,0,0,0x01,0, // cathode shift register 4
0,0,0,0,0x02,0,
0,0,0,0,0x04,0,
0,0,0,0,0x08,0,
0,0,0,0,0x10,0,
0,0,0,0,0x20,0,
0,0,0,0,0x40,0,
0,0,0,0,0x80,0,
0,0,0,0,0,0x01,// cathode shift register 5
0,0,0,0,0,0x02,
0,0,0,0,0,0x04,
0,0,0,0,0,0x08,
0,0,0,0,0,0x10,
0,0,0,0,0,0x20,
0,0,0,0,0,0x40,
0,0,0,0,0,0x80,
}
void loop(){
currentTime = micros(); // all time elements are unsigned long
elapsedTime = currentTime - nextTime; // see how much time passed
if (nextTime >= onDuration){ // time to update the (column or row)
nextTime = nextTime + onDuration
columnCount = columnCount +1
if (columnCount == 48){ columnCount = 0;} // reached end, reset: 0,8,16,24,32,40
// now, send out new data
digitalWrite (latchPin, LOW); // replace with direct port manipulation for speed gain, same with going high
// cathode data
SPI.transfer (cathodeArray[(columnCount*8)+0]); // don't use loops, just slows things down
SPI.transfer (cathodeArray[(columnCount*8)+1]);
SPI.transfer (cathodeArray[(columnCount*8)+2]);
SPI.transfer (cathodeArray[(columnCount*8)+3]);
SPI.transfer (cathodeArray[(columnCount*8)+4]);
SPI.transfer (cathodeArray[(columnCount*8)+5]);
//anode data
SPI.transfer (dataArray[(columnCount*3)+0]);
SPI.transfer (dataArray[(columnCount*3)+1]);
SPI.transfer (dataArray[(columnCount*3)+2]);
digitalWrite (latchPin, HIGH); // Low to High edge clocks it all from input register to output register
} // end time check
//
// in non-shifting time, updata dataArray[] with next thing to be displayed
// perhaps another time check, and move all data along by 3 bytes for moving across the screen
// or move along 48 bytes for moving down the screen
// or bring in new stuff from serial port
// or new data from progmem
// or ...
//
//
} //end loop
