Mikrocontroller.net - Benutzerbeiträge [de]

LED-Fading

2012-06-05T12:28:09Z

84.167.173.75: /* FAQ */

== Das Problem ==

Die Aufgabe klingt eigentlich recht einfach. Eine [[LED]] soll mittels [[PWM]] in ihrer Helligkeit gesteuert werden. Und weils so schön ist, möchte man sie geheimnisvoll aufleuchten lassen, sprich langsam heller und dunkler werden lassen. Der Fachmann nennt das Fading. Das Problem zeigt sich allerdings recht schnell. Wenn man eine 8-Bit PWM linear zwischen 0..255 laufen lässt, dann scheint die LED nicht linear gedimmt zu werden. Sie wird relativ schnell hell und bleibt lange hell.

== Die Erklärung ==

Des Rätsels Lösung liegt in der Kennline des menschlichen Auges. Diese ist nichtlinear, genauer gesagt: sie ist nahezu logarithmisch. Das ermöglicht die Wahrnehmung eines sehr großen Helligkeitsbereichs, angefangen von Vollmond mit ~1/4 [http://de.wikipedia.org/wiki/Lux_%28Einheit%29 Lux] über eine normale Schreibtischbeleuchtung mit ca. 750 Lux bis zu einem hellen Sommertag mit bis zu 100.000 Lux. Solche hochdynamischen Signale sind nur mit einer logarithmischen Kennlinie in den Griff zu kriegen, auch von Mutter Natur und Erfinder Papa.

=== Die Kennlinie des Auges genau betrachtet ===

Die Kennlinie des menschlichen Auges ist annähernd logarithmisch. Das wurde vor langer Zeit durch das [http://de.wikipedia.org/wiki/Weber-Fechner-Gesetz Weber-Fechner-Gesetz] beschrieben. Genauere Untersuchungen zur [http://de.wikipedia.org/wiki/Gammakorrektur Gammakorrektur] führten jedoch zur [http://de.wikipedia.org/wiki/Stevenssche_Potenzfunktion Stevenschen Potenzfunktion]. Diese beschreibt das menschliche Auge etwas besser. (s. auch [[Talk:LED-Fading#Diskussion wissenschaftl.-technischer Hintergrund|Diskussionsseite]]). Die Unterschiede sind jedoch marginal.

Praktisch heißt das, daß wir unserem Auge große physikalische Helligkeitsunterschiede präsentieren müssen, damit es das als lineare Helligkeitsteigerung erkennt. Etwas wissenschaftlicher formuliert heißt das, wir müssen durch Verkettung der logarithmischen Kennlinie des Auges mit einer exponentiellen Kennlinie eine physiologisch lineare Helligkeitsverteilung erzielen.

Berechnet werden kann eine passende Tabelle beispielsweise mit folgender Funktion:

<math>y=\frac{b^{\frac{x}{r_x}}-1}{b-1}\cdot r_y</math>

Dabei sind x und y die Ein-, bzw. Ausgabewerte der Funktion, jeweils im Bereich von 0 bis r-1. b ist die Basis der Exponentialfunktion und bestimmt, wann und wie stark die Kurve ansteigen soll. Hier ist etwas ausprobieren erforderlich, gute Ergebnisse liefern Werte im Bereich 10-100.

== Das Demoprogramm ==

Das wird in dem unten gezeigten Beispielprogramm gemacht. Dabei wird die Wirkung verschiedener PWM-Auflösungen demonstriert. Eine 8-Bit PWM wird mit 4/8/16 und 32 nichtlinearen Stufen betrieben, welche über eine Exponentialfunktion berechnet wurden. Dazu dient die [[media:pwm_table.zip|Exceltabelle]] (Anmerkung: Bitte die Exceltabelle nochmal erklären, die Werte in der Tabelle stimmen nicht mit denen im Programm überein). Die einzelnen benachbarten Werte haben zueinander ein konstantes Verhältnis, das in der Exceltabelle als 'Factor' berechnet wird. Ausserdem werden eine 10-Bit PWM mit 64 Stufen sowie, als die Königsklasse, eine 16-Bit PWM mit 256 Stufen betrieben.

Das Programm ist ursprünglich auf einem [[AVR]] vom Typ '''ATmega32''' entwickelt und getestet. Aber es ist leicht auf jeden AVR portierbar, welcher eine PWM zur Verfügung hat. Der AVR muss mit etwa 8 MHz getaktet werden, egal ob mit internem Oszillator oder von aussen mit Quarz. Man muss nur noch eine LED mittels Vorwiderstand von ca. 1 kOhm an Pin PD5 anschliessen und los gehts. Es sollte hier noch erwähnt werden, dass das Programm mit eingeschalteter Optimierung compiliert werden muss, sonst stimmen die Zeiten der Warteschleifen nicht.

Bei Verwendung der LEDs auf dem STK500 bzw. bei der Verwendung von invertierenden Treiberstufen ist das "#define STK500 false" durch "#define STK500 true" zu ersetzen.

Das Programm durchläuft alle 6 PWMs und lässt dabei die LED jeweils 3 mal glimmen. Mit 4 Schritten Auflösung ist das natürlich ruckelig, mit 8 schon wesentlich besser. Mit 16 Stufen sieht man bei langsamen Änderungen noch Stufen, dreht man die Ein- und Ausblendzeiten runter ist der Übergang schon recht flüssig. Die 8-Bit PWM mit 32 Stufen unterscheidet sich praktisch nicht von der 10-Bit PWM mit 64 Stufen, es sei denn, man macht extrem langsame Einblendungen. Hier schlägt die Stunde der 16-Bit PWM. Diese wird bewußt sehr langsam ausgeführt um zu demonstrieren, daß hiermit praktisch keine Stufen mehr sichtbar sind, egal wie langsam gedimmt wird. Wie man auch sieht sind die drei höherauflösenden PWMs im unteren Bereich an ihrer Auflösungsgrenze, da einige PWM-Werte mehrfach vorkommen. Da heißt gleichzeitig, daß eine Steigerung der Stufenanzahl relativ sinnlos ist.

<c>
//*****************************************************************************
//*
//* LED fading test
//* uses exponential PWM settings to achive visual linear brightness
//*
//* ATmega32 @ 8 MHz
//*
//*
//*****************************************************************************

#define F_CPU 8000000L

#define true 1
#define false 0

#define STK500 false

#include <inttypes.h>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>

// global variables

uint16_t pwmtable_8A[4] PROGMEM = {0, 16, 64, 255};
uint16_t pwmtable_8B[8] PROGMEM = {0, 4, 8, 16, 32, 64, 128, 255};
uint16_t pwmtable_8C[16] PROGMEM = {0, 2, 3, 4, 6, 8, 11, 16, 23, 32, 45, 64,
90, 128, 181, 255};
uint16_t pwmtable_8D[32] PROGMEM = {0, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 10, 11,
13, 16, 19, 23, 27, 32, 38, 45, 54, 64, 76,
91, 108, 128, 152, 181, 215, 255};

uint16_t pwmtable_10[64] PROGMEM = {0, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5,
5, 6, 6, 7, 8, 9, 10, 11, 12, 13, 15, 17,
19, 21, 23, 26, 29, 32, 36, 40, 44, 49, 55,
61, 68, 76, 85, 94, 105, 117, 131, 146, 162,
181, 202, 225, 250, 279, 311, 346, 386, 430,
479, 534, 595, 663, 739, 824, 918, 1023};

uint16_t pwmtable_16[256] PROGMEM = {0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6,
6, 7, 7, 7, 8, 8, 8, 9, 9, 10, 10, 10, 11,
11, 12, 12, 13, 13, 14, 15, 15, 16, 17, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 31, 32, 33, 35, 36, 38, 40, 41, 43, 45,
47, 49, 52, 54, 56, 59, 61, 64, 67, 70, 73,
76, 79, 83, 87, 91, 95, 99, 103, 108, 112,
117, 123, 128, 134, 140, 146, 152, 159, 166,
173, 181, 189, 197, 206, 215, 225, 235, 245,
256, 267, 279, 292, 304, 318, 332, 347, 362,
378, 395, 412, 431, 450, 470, 490, 512, 535,
558, 583, 609, 636, 664, 693, 724, 756, 790,
825, 861, 899, 939, 981, 1024, 1069, 1117,
1166, 1218, 1272, 1328, 1387, 1448, 1512,
1579, 1649, 1722, 1798, 1878, 1961, 2048,
2139, 2233, 2332, 2435, 2543, 2656, 2773,
2896, 3025, 3158, 3298, 3444, 3597, 3756,
3922, 4096, 4277, 4467, 4664, 4871, 5087,
5312, 5547, 5793, 6049, 6317, 6596, 6889,
7194, 7512, 7845, 8192, 8555, 8933, 9329,
9742, 10173, 10624, 11094, 11585, 12098,
12634, 13193, 13777, 14387, 15024, 15689,
16384, 17109, 17867, 18658, 19484, 20346,
21247, 22188, 23170, 24196, 25267, 26386,
27554, 28774, 30048, 31378, 32768, 34218,
35733, 37315, 38967, 40693, 42494, 44376,
46340, 48392, 50534, 52772, 55108, 57548,
60096, 62757, 65535};

// long delays

void my_delay(uint16_t milliseconds) {
for(; milliseconds>0; milliseconds--) _delay_ms(1);
}

// 8-Bit PWM with only 4 different settings

void pwm_8_4(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC1; // inverted PWM on OC1A, 8 Bit Fast PWM
#else
TCCR1A = 0x81; // non-inverted PWM on OC1A, 8 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 4; // precaler 256 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=3; tmp++){
OCR1A = pgm_read_word(pwmtable_8A+tmp);
my_delay(delay);
}

for(tmp=3; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_8A+tmp);
my_delay(delay);
}
}

// 8-Bit PWM with 8 different settings

void pwm_8_8(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC1; // inverted PWM on OC1A, 8 Bit Fast PWM
#else
TCCR1A = 0x81; // non-inverted PWM on OC1A, 8 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 4; // precaler 256 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=7; tmp++){
OCR1A = pgm_read_word(pwmtable_8B+tmp);
my_delay(delay);
};

for(tmp=7; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_8B+tmp);
my_delay(delay);
}
}

// 8-Bit PWM with 16 different settings

void pwm_8_16(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC1; // inverted PWM on OC1A, 8 Bit Fast PWM
#else
TCCR1A = 0x81; // non-inverted PWM on OC1A, 8 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 4; // precaler 256 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=15; tmp++){
OCR1A = pgm_read_word(pwmtable_8C+tmp);
my_delay(delay);
}

for(tmp=15; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_8C+tmp);
my_delay(delay);
}
}

// 8-Bit PWM with 32 different settings

void pwm_8_32(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC1; // inverted PWM on OC1A, 8 Bit Fast PWM
#else
TCCR1A = 0x81; // non-inverted PWM on OC1A, 8 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 4; // precaler 256 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=31; tmp++){
OCR1A = pgm_read_word(pwmtable_8D+tmp);
my_delay(delay);
}

for(tmp=31; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_8D+tmp);
my_delay(delay);
}
}

// 10-Bit PWM with 64 different settings

void pwm_10_64(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC3; // inverted PWM on OC1A, 10 Bit Fast PWM
#else
TCCR1A = 0x83; // non-inverted PWM on OC1A, 10 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 3; // precaler 64 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=63; tmp++){
OCR1A = pgm_read_word(pwmtable_10+tmp);
my_delay(delay);
}

for(tmp=63; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_10+tmp);
my_delay(delay);
}
}

// 16-Bit PWM with 256 different settings

void pwm_16_256(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC2; // inverted PWM on OC1A, 16 Bit Fast PWM
#else
TCCR1A = 0x82; // non-inverted PWM on OC1A, 16 Bit Fast PWM
#endif
TCCR1B = 0x18;
ICR1 = 0xFFFF; // TOP for PWM, full 16 Bit

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 1; // precaler 1 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=255; tmp++){
OCR1A = pgm_read_word(pwmtable_16+tmp);
my_delay(delay);
}

for(tmp=255; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_16+tmp);
my_delay(delay);
}
}

int main(void)
{
int16_t i;
int16_t step_time=400; // delay in millisecond for one fading step

DDRD |= (1<<PD5); // LED uses OC1A

// test all fading routines

while(1) {

for(i=0; i<3; i++) pwm_8_4(step_time);
my_delay(1000);
for(i=0; i<3; i++) pwm_8_8(step_time/2);
my_delay(1000);
for(i=0; i<3; i++) pwm_8_16(step_time/4);
my_delay(1000);
for(i=0; i<3; i++) pwm_8_32(step_time/8);
my_delay(1000);
for(i=0; i<3; i++) pwm_10_64(step_time/16);
my_delay(1000);
for(i=0; i<3; i++) pwm_16_256(step_time/16);
my_delay(1000);

};

return 0;
}
</c>

== FAQ ==

=== Wieso geht die LED nie ganz aus? ===

Es ist normal, dass die LED selbst bei OCR1A = 0 immer noch ganz schwach leuchtet. Die Hardware PWM funktioniert so, dass bei einem Timerwert von 0 auf jeden Fall der Ausgang ein geschaltet wird. Danach kommt der Compare Match bei 0 und schaltet gleich wieder aus. Daher ist der Ausgang für einen [[PWM]]-Takt eingeschaltet. Um das zu ändern muss man entweder invertierte PWM nutzen, dann ist allerdings der Ausgang nie zu 100% High, sondern hat immer einen Takt Low beim maximalem PWM-Wert. Oder man schaltet bei 0 einfach die PWM-Funktion ab und und setzt den Ausgang normal auf Low. [http://www.mikrocontroller.net/topic/200173#1965686].

=== Wieso dimmt man eine LED nicht besser mit einer variablen Stromquelle? ===

=== Wieso flimmern LEDs bei Autorücklichtern? Wieso werden diese nicht mit Stromquellen betrieben? ===

== Siehe auch ==
* [[PWM]]
* [[AVR-GCC-Tutorial#PWM (Pulsweitenmodulation)|AVR-GCC-Tutorial: PWM]]
* [[Soft-PWM]] - optimierte Software-PWM in C
* [http://www.b-kainka.de/bastel108.htm Eine LED weich blinken lassen ohne Mikrocontroller]

[[Category:AVR-Projekte]]
[[Category:Displays und Anzeigen]]

LED

2012-06-05T12:02:18Z

84.167.173.75: /* Vorwiderstand */

== Beschreibung ==

[[Bild:Ledrgb.jpg|thumb|right|246px|Detailfoto einer RGB-LED [http://www.mikrocontroller.net/topic/109784#990685]]]

Eine LED (engl. Light Emitting Diode, ''Leuchtdiode'') besteht aus einem [[Halbleiter]]-PN-Übergang, der durch seine Zusammensetzung Licht eines stark begrenzten Wellenbereiches emittiert, wenn er in Durchlassrichtung von Strom durchflossen wird. Die Helligkeit einer LED ist in erster Näherung proportional zum Strom.

Die Farbe des emittierten Lichts hängt vom verwendeten Halbleitermaterial ab. Es existieren [[Halbleiter | Halbleitermaterialien]] für den gesamten sichtbaren Bereich als auch für den Infrarotbereich und den nahen Ultraviolettbereich. Für kurze Wellenlängen (Blau bis Ultraviolett) ist ein Halbleitermaterial wie z. B. InGaN oder GaN erforderlich. Für die ersten blauen LEDs wurde SiC verwendet, welche aber eine schlechte Effizienz hat (Quelle:Wikipedia).

Weißes Licht oder andere Farbmischungen können erzeugt werden, indem man eine Blau- oder Ultraviolett-LED mit einem Phosphormaterial beschichtet, welches durch das Licht der LED zur Emission angeregt wird. Die entstehende Farbe wird dabei von der Beschichtung bestimmt.

== Durchlassspannung ==

LEDs haben im Vergleich zu gewöhnlichen [[Diode|Dioden]] eine vergleichsweise hohe, vom Halbleitermaterial abhängige [[Durchlass-Spannung]]. Bevor diese erreicht wird, fließt nur sehr wenig Strom und die LED leuchtet fast nicht. Oberhalb der Durchlassspannung (Flußspannung) steigt der Strom schnell an (Diodenkennlinie). Die Flußspannung reicht von ca. 1,2 V bei Infrarot-LEDs bis zu etwa 4 V bei Ultraviolett-LEDs.

{| class="wikitable" style="text-align:center"
|-
! Farbe || typ. Flußspannung [V]
|-
| Infrarot || 1,2
|-
| Rot || 1,8
|-
| Gelb || 2,0
|-
| Grün || 2,2
|-
| Grün (Ultrahell) || 3,3
|-
| Blau || 3,6
|-
| Weiss || 3,6
|-
| Ultraviolett || 4
|}

== Durchlassstrom ==

Da LEDs durch einen zu hohen Strom zerstört werden, muss der Strom begrenzt werden. Typische Maximalwerte liegen abhängig von der LED z. B. bei 2 mA (low current) oder 20 mA. Genaue Angaben dazu finden sich in entsprechenden Datenblättern.

=== Vorwiderstand ===

Im einfachsten Fall und bei relativ geringfügig variierender Betriebsspannung kann man dazu einen Widerstand einsetzen.

[[bild:led_rv.png|right]]
Bei 6 V Betriebsspannung, einer Durchlassspannung der LED von 2,4 V und einem gewünschten Strom von 20 mA braucht man nach dem ohmschen Gesetz einen Widerstand von 180Ω, bei 12 V Betriebsspannung sind es 480Ω. In der Praxis wird jeweils der nächstgrößere Standardwert gewählt (E-Reihen).

:<math>RV=\frac{Vcc-U_\text{LED}}{I_\text{LED}}</math>

* RV: Vorwiderstand in Ohm
* Vcc: Betriebsspannung in Volt
* <math>U_{LED}</math>: Durchlassspannung der LED in Volt
* <math>I_{LED}</math>: Strom durch die LED in Ampere

Mit einem 480-Ohm-Widerstand, welcher für 12 V Betriebsspannung passend ist, würden bei 6 Volt statt 20 mA nur noch 7,5 mA fließen. Mit einem 180-Ohm-Widerstand, welcher für 6 V Betriebsspannung passend ist, würden bei 12 V statt der gewünschten 20 mA allerdings schon 53 mA fließen.

Beachten muss man auch die als Wärme abgegebene '''Verlustleistung''' über dem Vorwiderstand, vor allem wenn man LEDs an eine recht hohe Betriebsspannung von 12 V oder gar 24 V anschließt. Die Verlustleistung berechnet sich einfach aus

:<math>P_{RV} = (Vcc-U_\text{LED}) \cdot I_\text{LED} = I_\text{LED}^2 \cdot RV</math>

In diesem Beispiel mit der 2,4-V-LED und einem Strom von 20 mA heißt das, dass an dem 480-Ohm-Widerstand eine Verlustleistung von 192 mW abfällt. Ein kleiner SMD-Widerstand der Größe 0805 hält das nicht mehr aus (1/8 W = 125 mW maximal).

Wie man aus dem Beispiel erkennt, ist bei stark variierender Betriebsspannung ein Vorwiderstand weniger geeignet. Es sei denn, man nimmt sehr unterschiedliche LED-Ströme und damit LED-Helligkeiten oder möglicherweise die Zerstörung der LED in Kauf.

Bei Batteriebetrieb werden LEDs häufig ohne Vorwiderstand betrieben. So z.B. bei billigen Taschenlampen und Fahrradlampen. Dabei werden oft sogar zwei 1,5V Batterien in Reihe geschaltet und die LED direkt angeschlossen. Der Grund ist, dass das alles nichts kosten darf und man sich auf den Innenwiderstand der Batterie verlässt.

=== Konstantstromquelle ===

Bei stark schwankender Versorgungsspannung oder Umgebungstemperatur heißt der Ausweg [[Konstantstromquelle]]. Kriterien für die Auswahl einer Schaltung für die Konstantstromquelle sind hierbei z. B. Betriebsspannungsbereich, erforderliche Genauigkeit und Kosten. Auch hier ist zu beachten, daß die Verlustleistung der Konstantstromquelle von den Bauteilen abgeführt werden muss, mit einer gewissen Ausnahme der Lösungen mit Schaltregler.

=== Betriebsstrom ===

In der Praxis werden LEDs oft mit einem weit geringeren als dem maximal zulässigen Durchlassstrom betrieben. Insbesondere im Entwicklungs- und Experimentierumfeld kann eine für maximal 20 mA ausgelegte LED auch mit lediglich 3-5 mA betrieben werden. Der subjektiv wahrgenommene Helligkeitsverlust ist deutlich geringer, als der prozentuale Unterschied der Stromstärke vermuten lässt, siehe Artikel [[LED-Fading]].

== Mehrere LEDs zusammenschalten ==

Diese Frage bewegt immer wieder die Gemüter. Wie schaltet man mehrere LEDs '''richtig''' zusammen?

=== Reihenschaltung ===

In einer Reihenschaltung ist der Strom durch alle Verbraucher gleich. Ideal für LEDs. Hat man eine ausreichend hohe Versorgungsspannung, kann man mehrere LEDs in Reihe schalten. Dann reicht ein einziger Widerstand bzw. eine [[Konstantstromquelle]]. Allerdings sollte man das nicht übertreiben. 100-150 LEDs direkt an die Netzspannung zu hängen ist nicht möglich, da die LEDs zu viel Sperrspannung abbekommen würden. Auch bei gleichgerichteter Spannung besteht ein Sicherheitsproblem. Als Hobbybastler sollte man sich auch hier auf Spannungen kleiner als 40V beschränken.

=== Parallelschaltung ===

Das direkte Parallelschalten von LEDs ist sehr kritisch und muss vermieden werden. Grund ist die exponentielle Diodekennlinie, welche bewirkt, dass eine kleine Spannungsänderung eine grosse Stromänderung hervorruft. Schaltet man nun zwei LEDs mit verschiedenen Durchlassspannung parallel, bekommt die mit der niedrigeren Durchlassspannung DEUTLICH mehr Strom ab, dadurch wird sie nicht nur deutlich heller sondern auch wärmer. Das führt zum 2. Problem, denn mit steigender Temperatur sinkt die Durchlassspannung zusätzlich, wodurch sich der Effekt weiter verstärkt! LEDs verschiedender Farben haben sehr unterschiedliche Durchlassspannungen, hier ist ein direktes Parallelschalten vollkommen unmöglich. Aber selbst LEDs mit gleicher Farbe und aus einem Produktionsdurchlauf (Lot) weisen herstellungsbedingt bisweilen erhebliche Streuungen der Durchlassspannung auf!

Richtig Parallelschalten kann man LEDs aber durch

* Vorwiderstand/Konstantstromquelle für jede einzelne LED
* Auswählen von ausgemessenen LEDs mit sehr ähnlicher Flußspannung

Letztere Methode wird von professionellen Herstellern verwendet, um bei grösseren Anzeigen LEDs direkt parallel schalten zu können. Die Unterschiede in der Flußspannung bei Nennstrom sollten dabei kleiner als 10mV(?) sein. Das gilt natürlich auch für das Parallelschalten von LED-Strängen, also Reihenschaltungen von LEDs.

=== Reihen- plus Parallelschaltung ===

Eine Kombination aus Serien- und Parallelschaltung ist weniger kritisch, da sich die unterschiedlichen Kennlinien statistisch mitteln. Z.B. kann man 20 LEDs in Reihe und mehrere solcher Stränge parallel schalten. Eine einzelne Diode mit geringerer Durchlaßspannung wird im Strom durch 9 andere begrenzt. Der Stromanstieg infolge der Unterschiede der einzelnen Stränge erzeugt an allen Bahnwiderständen der Dioden einen Spannungsabfall, der die ungleiche Stromverteilung begrenzt.

== Siehe auch ==

* [[AVR-Tutorial: IO-Grundlagen#Hardware]]
* [[LED-Matrix]]
* [[LED-Fading]]
* [[Lichtsensor / Helligkeitssensor#LED]]
* [[Ambilight in Hardware]]
* [[Konstantstromquelle fuer Power LED]]
* [http://www.mikrocontroller.net/topic/goto_post/1553359 Forumsbeitrag]: LEDs an 230V Netzspannung mit Konstantstromquelle
* [http://www.mikrocontroller.net/topic/219681#2197034 Forumsbeitrag]: Darstellung der Toleranzen von LEDs und deren Wirkung, oder "Warum man einen Vorwiderstand braucht"
* [http://www.mikrocontroller.net/topic/74169#618682 Forumsbeitrag]: 16-Segment Ganganzeige ohne Mikrocontroller

== Weblinks ==
* [http://de.wikibooks.org/wiki/Arbeiten_mit_LEDs/_Grundlagen Wikibooks Arbeiten mit LEDs: Grundlagen] - Sehr gute Erklärung, auch für Anfänger
* [http://www.theledlight.com/technical.html www.theledlight.com] - LED Information and Technical Data (englisch)
* [http://forum.electronicwerkstatt.de/phpBB/faq/led/ LED FAQ für Anfänger]
* [http://members.misty.com/don/ledx.html Don Klipstein's LED Main Page (engl.)]
* [http://www.robotroom.com/LEDTester.html Selecting a LED] - LED Tester von David Cook (Beginnerprojekt)
* [http://www.evilmadscientist.com/article.php/throw Some thoughts on throwies] von Windell H. Oskay von www.evilmadscientist.com
*[http://www.led-rechner.de www.led-rechner.de]

[[Category:Bauteile]]
[[Category:Grundlagen]]
[[Category:Displays und Anzeigen| ]]