Druckbare Version
Wenn man mehrere LEDs ansteuern will, wäre da eine Widerstandsreihe/Netzwerk besser oder eine Art (ich nenns jetzt mal Verstärker-, ka obs das richtige Wort ist) IC besser, welcher die Stromlast (der LEDs auf den uC) übernimmt?
Wenn ich mich recht erinnere kann man ja pro Pin max 40mA anzapfen, allerdings nicht bei allen gleichzeitig oder?! Gesamthaft halt nur 160mA glaubs, habs irgendwo mal aufgeschnappt, finds aber nimmer.
Also das sogenannte Verstärker-IC ist ein Transistor, bzw ein Spannungsregler (Bsp LM317) als Stromquelle geschaltet. Die Stromaufnahme, bzw maximale Abgabe sollte im Datenblatt des entsprechenden Controllers stehen. Je nach leds, reicht auch nur ein R und ein Transistor...
Eine Möglichkeit wäre auch noch ein ULN2803 o.ä., da sind 8 "Verstärker" (NPN-Darlingtons) drin, die man normal über nen µC füttern kann und die aber trotzdem stark genug für Relais sind.
Alternative: Low-Current-LEDs, bei 2mA pro Stück lässt sich ein ganzer Port damit durch den µC allein betreiben.
Hallo
"Mehrere" ist relativ, ich spiele zur Zeit mit 12 LEDs an 4 AVR-Ports. Die "Technik" dazu wird hier ganz gut beschrieben:Zitat:
Wenn man mehrere LEDs ansteuern will...
http://www.josepino.com/pic_projects...ntrol_leds.jpc
Es wird dabei die Tri-State-Fähigkeit der AVR-Ausgänge genutzt. Da immer nur eine LED eingeschaltet wird ist der Strom unkritisch:
http://www.youtube.com/watch?v=ZPYhrQl-d4M
http://www.youtube.com/watch?v=r54xOzr0VDA
Das Programm dazu gibt per Interrupt ein Bitmuster aus, die ISR sieht so aus:
Nicht wirklich elegant, funktioniert aber zufriedenstellend.Code:ISR (TIMER0_COMP_vect)
{
static uint8_t bit=0;
if((bitmuster & (1<<bit))==1){
DDRC|=SL1; PORTC|=SL1; //SL1 high
DDRC|=SL2; PORTC&=~SL2; //SL2 low
DDRB&=~SL4; PORTB&=~SL4; //SL4 off
DDRB&=~SL5; PORTB&=~SL5; //SL5 off
}
if((bitmuster & (1<<bit))==2){
DDRC|=SL1; PORTC|=SL1; //SL1 high
DDRB|=SL4; PORTB&=~SL4; //SL4 low
DDRC&=~SL2; PORTC&=~SL2; //SL2 off
DDRB&=~SL5; PORTB&=~SL5; //SL5 off
}
if((bitmuster & (1<<bit))==4){
DDRC|=SL1; PORTC|=SL1; //SL1 high
DDRB|=SL5; PORTB&=~SL5; //SL5 low
DDRC&=~SL2; PORTC&=~SL2; //SL2 off
DDRB&=~SL4; PORTB&=~SL4; //SL4 off
}
if((bitmuster & (1<<bit))==8){
DDRC|=SL2; PORTC|=SL2; //SL2 high
DDRC|=SL1; PORTC&=~SL1; //SL1 low
DDRB&=~SL4; PORTB&=~SL4; //SL4 off
DDRB&=~SL5; PORTB&=~SL5; //SL5 off
}
if((bitmuster & (1<<bit))==16){
DDRC|=SL2; PORTC|=SL2; //SL2 high
DDRB|=SL4; PORTB&=~SL4; //SL4 low
DDRC&=~SL1; PORTC&=~SL1; //SL1 off
DDRB&=~SL5; PORTB&=~SL5; //SL5 off
}
if((bitmuster & (1<<bit))==32){
DDRC|=SL2; PORTC|=SL2; //SL2 high
DDRB|=SL5; PORTB&=~SL5; //SL5 low
DDRC&=~SL1; PORTC&=~SL1; //SL1 off
DDRB&=~SL4; PORTB&=~SL4; //SL4 off
}
if((bitmuster & (1<<bit))==64){
DDRB|=SL4; PORTB|=SL4; //SL4 high
DDRC|=SL1; PORTC&=~SL1; //SL1 low
DDRC&=~SL2; PORTC&=~SL2; //SL2 off
DDRB&=~SL5; PORTB&=~SL5; //SL5 off
}
if((bitmuster & (1<<bit))==128){
DDRB|=SL4; PORTB|=SL4; //SL4 high
DDRC|=SL2; PORTC&=~SL2; //SL2 low
DDRC&=~SL1; PORTC&=~SL1; //SL1 off
DDRB&=~SL5; PORTB&=~SL5; //SL5 off
}
if((bitmuster & (1<<bit))==256){
DDRB|=SL4; PORTB|=SL4; //SL4 high
DDRB|=SL5; PORTB&=~SL5; //SL5 low
DDRC&=~SL2; PORTC&=~SL2; //SL2 off
DDRC&=~SL1; PORTC&=~SL1; //SL1 off
}
if((bitmuster & (1<<bit))==512){
DDRB|=SL5; PORTB|=SL5; //SL5 high
DDRC|=SL1; PORTC&=~SL1; //SL1 low
DDRC&=~SL2; PORTC&=~SL2; //SL2 off
DDRB&=~SL4; PORTB&=~SL4; //SL4 off
}
if((bitmuster & (1<<bit))==1024){
DDRB|=SL5; PORTB|=SL5; //SL5 high
DDRC|=SL2; PORTC&=~SL2; //SL2 low
DDRC&=~SL1; PORTC&=~SL1; //SL1 off
DDRB&=~SL4; PORTB&=~SL4; //SL4 off
}
if((bitmuster & (1<<bit))==2048){
DDRB|=SL5; PORTB|=SL5; //SL5 high
DDRB|=SL4; PORTB&=~SL4; //SL4 low
DDRC&=~SL1; PORTC&=~SL1; //SL1 off
DDRC&=~SL2; PORTC&=~SL2; //SL2 off
}
if(bit<11) bit++; else bit=0;
}
Gruß
mic
Kommt immer drauf an, wieviel Strom ne LED zieht.
Es gibt LEDs, die saugen 350mA, andere sind mit 1mA ausreichend hell...
Interessant sind auch Portexpander wie zB MAX6956 (I²C-Expander, 28 LEDs, individuell einstellbarer Konstantstrom).
In einem Projekt hab ich 27 LEDs ohne Treiber an einem ATmega8:
https://www.roboternetz.de/phpBB2/ze...ag.php?t=22760
In einem anderen 15 LEDs an einem ATtiny24:
http://www.gjlay.de/pub/eiuhr/index.html
@rideyourstyle:
Es ging ja darum, nicht tausend Einzelteile zu nehmen, sondern diese irgendwie in ein IC oder eben einem R-Netzwerk zusammenzufassen.
Dennoch danke! Das der LM317 neben einer Spannungsquelle auch den Strom einstellen lässt, hab ich nciht gewusst. :D
@Jaecko:
Mit dem ULN2803 kommen wir der Sache schon näher. Guter Tipp, in anbetracht dessen, das 9 Leds und 6 Relais angesteuert werden müssen!
@radbruch:
Hmm die Methode ist insofern interessant, wenn die Ports begrenzt sind.
Die Idee ansich ist nicht schlecht. Gibt in der Software nur bez mehr arbeit.
@SprinterSB:
Son Portexpander wäre auch eine gute Möglichkeit. Scheint aber nicht gerad billig. Muss ich noch suchen, bei meinem Elektroshop gibts den scheints nicht.
Bei deiner Uhr hast du das Matrixmässig gemacht, hab ich das richtig verstanden? Sprich: Gib Strom auf Reihe 2, Spalte 1?
Somit kann man mehrere LEDs über ein R laufen lassen.
Ihr habt mich gerad auf eine Idee gebracht...
Wäre es nicht möglich, die Dioden in einer Schleife der Reihe nach ein und abzuschalten?
Das quasi fürn Bruchteil einer Sekunde nur jeweils eine leuchtet?
Mit 16Mhz sollte es ja schnell genug sein, das die Dioden aussehen, als würden sie permanent leuchten?!
Würde das gehn?
Das Nacheinander ansteuern ist gerade der Trick bei der Matrix Methode. Man braucht dann aber wenigstens an der einen Seite Treiber wie den ULN2803, denn da laufen dann mehrere LEDs drüber und das auch noch mit mehr Strom um auf gleiche Helligkeit zu kommen.
... ist ziemlich pfiffig :)Zitat:
Zitat von M@tes
https://www.roboternetz.de/wissen/in...antstromquelle
Nachtrag zum ULN2803:
Hat gegenüber normalen NPN-Transistoren die Vorteile, dass man zum Einen keinen Basis-Vorwiderstand braucht, zum anderen sind bereits Freilaufdioden drin.
Ja, genau so mach ich das auch. Es leuchten bis zu 9 LEDs (1 Zeile) gleichzeitig, die Zeilen werden nacheinander angesteuert, also 1,2,3,1,2,...Zitat:
Zitat von M@tes
Das geht in dem Beispiel aber nur deshalb ohne Treiber, weil *alle* LEDs einer Zeile zusammen weniger als 20mA ziehen.
Die Lösunf mit einem ULN ist denkbar, etwas unpraktisch finde ich aber, daß man dann pro LED einen Port braucht. In einer Matrix braucht man Zeilen+Spalten Ports und hat denn Zeilen*Spalten LEDs. In dem Fall müssen die LEDs im Zeilmultiplex angesteuert werden, also zeilen- oder spaltenweise. Dadurch verliert man etwas helligkeit, aber in der Praxis aber idR kein Problem. Je nachdem, was der µC an Strom liefern/versenken lann, braucht man Anoden und/oder Kathodentreiber.
Bei zeilenweiser Ansteuerung brauch man pro Spalte einen Vorwiderstand, falls die LEDs baugleich sind. Sind die nicht baugleich, dann braucht jede LED nen individuellen Strombegrenzer.
In einer Matrix ist auch auf die Sperrspannung der LEDs zu achten; es gibt zB LEDs, die in Rückwärtsrichtung nur einige 100mV sperren. In einer Matrix braucht man dann noch Reihendioden zu diesen LEDs, weil ansonsten der Strom ungewollte Pfade läuft und dadurch LEDs leuchten, die es nicht sollten.
Also Portexpander gehen auch Schieberegister wie 74*595, die sind billiger und leichter zu bekommen, belegt weniger Ports am µC (nur 3-4), sind einfacher uns schneller anzusteuern als I²C-Portexpander und können auch low-current-LEDs treiben. Zudem können die LEDs einfach per PWM gedimmt werden.
Hallo!
Das PWM Signal wird dann parallel an "Output Enable" von allen 74*595 gelegt.
MfG