Pour éditer le wiki, il faut demander un compte à un Lapin !
Difference between revisions of "LedFloor"
(→Solution #4) |
(→Solution #6) |
||
Line 59: | Line 59: | ||
== Solution #6 == | == Solution #6 == | ||
+ | So, the goal is to achieve a 1024 led screen, with, if possible, PWM on each led, for a total price <150€ (connectors, leds not included) ? | ||
+ | My proposal would be to mix #1 (eg use TLC5940 chips, for their ability to PWM their outputs) and #4 (actually, only reuse the 4 to 16 demuxes (74HC154) idea, with two additionnal GPIO from the uC to achieve a 5 to 32 demux). That is : | ||
+ | * two TLC5940 | ||
+ | ** drive each row in PWM mode | ||
+ | ** can be daisy chained, and they take 8 I/O (or possibly less than that) | ||
+ | ** cost about 3€ each at www.mouser.fr | ||
+ | * two 74HC154 | ||
+ | ** drive each column (one after each other) | ||
+ | ** cost less than 1€ each | ||
+ | * some power stage: | ||
+ | ** worst case is all 32 rows ON with 100mA each. So each column power driver should be able to sustain a 3.2 A continuous current. | ||
+ | ** the evilmadscientist schematic proposes 1.5A pnp transistors ;) | ||
+ | ** it'd be a better idea to get some (any) tougher pnp transistors (maybe few € total) | ||
+ | * This requires about 18 I/O for control | ||
+ | ** it is out of reach of an Arduino (true only when all the features of the TLC5940 are used. There are solutions to use an Arduino anyway. Note that I consider UNO and similar boards, not mega ones - which are too expensive) | ||
+ | ** it is quite doable with a Teensy (http://www.pjrc.com/teensy/ about $30, similar in functionalities to an arduino otherwise) | ||
+ | * some power input is required | ||
+ | ** I suggest a computer PSU (reuse a standard connector to get 5v on the circuit) | ||
+ | * some connectors are required | ||
+ | ** I suggest using standard RJ45 connectors (which stand 1.5A if I remember well. Meh...) | ||
+ | * some passives are required. As usual. | ||
+ | |||
+ | Total cost: O{100€ ?). Sounds good to me :) | ||
+ | |||
+ | ==== issues/open questions ==== | ||
+ | * will the TLC be well adapted to drive each column only 1/16th of the time ? That is, still work well when asked to somehow refresh data at (total refresh rate)*(number of columns) | ||
+ | ** according to datasheet, the max required clock speed is 4096*(refresh frequency). Even with a *16 factor, it isn't out of reach of a simple uC | ||
+ | ** will the leds give enough light when pulsed at max 1/16th of the time at 100mA ? | ||
+ | *** my guess would be: yes | ||
+ | * how to make the board ? | ||
+ | ** it can be done on a standard protoboard (quite small, I would even say) | ||
+ | *** Check if standard PC power connectors fit on these. If not, use a wire + standard connector. | ||
+ | *** Check if there are thru hole RJ45 connectors available. Looks like there are some (quite cheap, O{10€} for a 8 port version) but pins won't fit on a protoboard. | ||
+ | * if one want to really use 12 bit resolution for each of the 1024 leds, using a 8bit uC with 8k of RAM is... probably not the best choice | ||
+ | ** I guess it'd be okay to downgrade the resolution to few bits per led, eg never drive LSBs for each led and use only 4bits resolution. | ||
+ | |||
+ | => I cannot see any big flaw in this solution. Does anyone have a better view here ? --cq | ||
+ | == Solution #7 == | ||
* 42 ? | * 42 ? |
Revision as of 23:33, 3 February 2011
Contents
Led Floor
How to turn the 11 windows of the hacklab into a big led display ?
- what have we got to do it ?
- Windows that are H189xW95.5 centimeters
- 1000 red leds
- loads of RJ45 and old IDE/SCSI/floppy buses
- what we need ?
- a system to control each diode (or group of diodes) independantly
- that is not too expensive
Question: do we need on/off for each led, or more advanced modes (eg PWM for various intensities).
- on/off:
- is simpler as regard to schematics
- is simpler as regard to driving code (led bits per image, obviously)
- isn't as cool
- can still, to some extend, allow some variable intensities
PWM "natural" ability is prefered, but choice will be made depending on total cost of solution.
Solution #1
use a TLC5940NT that can control about 16 LED each
- datasheet: http://datasheet.octopart.com/TLC5940NT-Texas-Instruments-datasheet-153017.pdf
- schematic: http://webhome.csc.uvic.ca/~mcheng/samples/led_wheel/images/hack_schematic.jpg
- O(price) = $180 for the 64*TLC5940NT, so we'll need also several protoboard to be cut to bind them on.
Naturally leads to a PWM version
Solution #2
use the snootlab's i2c led driver solution that can control 16 LED each
- 64*i2c led driver = 9.95*64 = 636.80
- 1*i2c shield = 17.95
- 1 ardunio = 20
- O(price) = 674.75 euros
Solution #3
- use shift registers... ?
Solution #4
use two Peggy 2 board :
- 2* http://evilmadscience.com/tinykitlist/157
- O(price) = 95*2 = $180 --or far less as you won't need the giant PCB. They have a "parts kit" that includes the 328 and the IC's for $15. you'd still need LED's and transistors and other support components. --cw
looking at the peggyLE schematics, they are not using several of the outputs, it looks like a 32x30 grid is possible with the IC's included, and by adding another IC in place of the buttons 32x45 is possible. --cw => they use two 4 to 16 demux for highside driving. They therefore *have* to keep one output not connected, to allow an "off" state for each of these chips. One solution would be to use two such chips, plus two generic I/O, leading to a (quite ugly) 10 to 32 demux functionality. -- cq
Solution #5
- Check with Electrolab, where another similar project is ongoing :-)
=> actually, the (current) project there is about a 8x8x8 led cube. Which is a bit different.
Solution #6
So, the goal is to achieve a 1024 led screen, with, if possible, PWM on each led, for a total price <150€ (connectors, leds not included) ?
My proposal would be to mix #1 (eg use TLC5940 chips, for their ability to PWM their outputs) and #4 (actually, only reuse the 4 to 16 demuxes (74HC154) idea, with two additionnal GPIO from the uC to achieve a 5 to 32 demux). That is :
- two TLC5940
- drive each row in PWM mode
- can be daisy chained, and they take 8 I/O (or possibly less than that)
- cost about 3€ each at www.mouser.fr
- two 74HC154
- drive each column (one after each other)
- cost less than 1€ each
- some power stage:
- worst case is all 32 rows ON with 100mA each. So each column power driver should be able to sustain a 3.2 A continuous current.
- the evilmadscientist schematic proposes 1.5A pnp transistors ;)
- it'd be a better idea to get some (any) tougher pnp transistors (maybe few € total)
- This requires about 18 I/O for control
- it is out of reach of an Arduino (true only when all the features of the TLC5940 are used. There are solutions to use an Arduino anyway. Note that I consider UNO and similar boards, not mega ones - which are too expensive)
- it is quite doable with a Teensy (http://www.pjrc.com/teensy/ about $30, similar in functionalities to an arduino otherwise)
- some power input is required
- I suggest a computer PSU (reuse a standard connector to get 5v on the circuit)
- some connectors are required
- I suggest using standard RJ45 connectors (which stand 1.5A if I remember well. Meh...)
- some passives are required. As usual.
Total cost: O{100€ ?). Sounds good to me :)
issues/open questions
- will the TLC be well adapted to drive each column only 1/16th of the time ? That is, still work well when asked to somehow refresh data at (total refresh rate)*(number of columns)
- according to datasheet, the max required clock speed is 4096*(refresh frequency). Even with a *16 factor, it isn't out of reach of a simple uC
- will the leds give enough light when pulsed at max 1/16th of the time at 100mA ?
- my guess would be: yes
- how to make the board ?
- it can be done on a standard protoboard (quite small, I would even say)
- Check if standard PC power connectors fit on these. If not, use a wire + standard connector.
- Check if there are thru hole RJ45 connectors available. Looks like there are some (quite cheap, O{10€} for a 8 port version) but pins won't fit on a protoboard.
- it can be done on a standard protoboard (quite small, I would even say)
- if one want to really use 12 bit resolution for each of the 1024 leds, using a 8bit uC with 8k of RAM is... probably not the best choice
- I guess it'd be okay to downgrade the resolution to few bits per led, eg never drive LSBs for each led and use only 4bits resolution.
=> I cannot see any big flaw in this solution. Does anyone have a better view here ? --cq
Solution #7
- 42 ?