Mikrocontroller.net - Benutzerbeiträge [de]

LED-Fading

2021-07-26T15:30:40Z

Ingo k2: /* 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 Theorie ==

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, dass 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^{\,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 folgende Beispielprogramm demonstriert die Wirkung verschiedener PWM-Auflösungen. 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]]<ref>Anmerkung: Bitte die Exceltabelle nochmal erklären, die Werte in der Tabelle stimmen nicht mit denen im Programm überein</ref> - überarbeitet, inkl. neuer Varianten der Berechnung als [[media:pwm_table-r101.ods|LibreOffice Calc Sheet]] / [[media:pwm_table-r101.pdf|PDF Vorschau]]<ref>Download alternativ von ftp://ftp.fl.priv.at/pub/mikrocontroller.net/led-fading/</ref>. 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 eine 16-Bit PWM mit 256 Stufen betrieben.

Eine neue [[media:LED-PWM.xlsm|Excel 2000 Tabelle]] ist ebenfalls verfügbar. Die Schaltflächen kopieren die Arraywerte in die Zwischenablage.

Das Programm ist ursprünglich auf einem [[AVR]] vom Typ ATmega32 entwickelt und getestet worden. 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 kΩ an Pin D5 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 aus <tt>util/delay.h</tt> nicht.

Bei Verwendung der LEDs auf dem STK500 bzw. bei der Verwendung von invertierenden Treiberstufen ist das
#define STK500 0
durch
#define STK500 1
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.

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

#include <avr/io.h>
#include <avr/pgmspace.h>

#define F_CPU 8000000L
#include <util/delay.h>

#define STK500 0

#if STK500
// inverted PWM on OC1A for STK500
#define INVERT_PWM (1 << COM1A0)
#else
// non-inverted PWM on OC1A
#define INVERT_PWM 0
#endif // STK500

const uint16_t pwmtable_8A[4] PROGMEM = { 0, 16, 64, 255 };
const uint16_t pwmtable_8B[8] PROGMEM =
{
0, 4, 8, 16, 32, 64, 128, 255
};

const uint16_t pwmtable_8C[16] PROGMEM =
{
0, 2, 3, 4, 6, 8, 11, 16, 23, 32, 45, 64, 90, 128, 181, 255
};

const 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
};

const 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
};

const 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
};

/*

Diese Tabellen sind nicht nach der Theorie (s. oben) berechnet, sondern wie folgt:
a = Anzahl an Schritte (4, 8, 16, 32, 64, 256)
b = Auflösung des PWM's (256, 1024, 65536)
y = Errechneter Wert an einer stelle x
y = 0 wenn x = 0
y = pow(2, log2(b-1) * (x+1) / a) wenn x > 0

Gerne wird auch diese alternative Formel genutzt:
y = pow(2, log2(b) * (x+1) / a) - 1

Obige Funktionen wurden in den LibreOffice Calc Sheet eingearbeitet.
*/

// long, variable delays

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

void pwm_up_down (const uint16_t pwm_table[], int16_t size, uint16_t delay)
{
int16_t tmp;

for (tmp = 0; tmp < size; tmp++)
{
OCR1A = pgm_read_word (& pwm_table[tmp]);
my_delay (delay);
}

for (tmp = size-1; tmp >= 0; tmp--)
{
OCR1A = pgm_read_word (& pwm_table[tmp]);
my_delay (delay);
}
}

// 8-Bit PWM with only 4 different settings

void pwm_8_4 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = 0x81 | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | 4;

pwm_up_down (pwmtable_8A, 4, delay);
}

// 8-Bit PWM with 8 different settings

void pwm_8_8 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = 0x81 | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | 4;

pwm_up_down (pwmtable_8B, 8, delay);
}

// 8-Bit PWM with 16 different settings

void pwm_8_16 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = 0x81 | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | 4;

pwm_up_down (pwmtable_8C, 16, delay);
}

// 8-Bit PWM with 32 different settings

void pwm_8_32 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = 0x81 | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | 4;

pwm_up_down (pwmtable_8D, 32, delay);
}

// 10-Bit PWM with 64 different settings

void pwm_10_64 (uint16_t delay)
{
// 10 Bit Fast PWM
TCCR1A = 0x83 | INVERT_PWM;
// prescaler 64 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | 3;

pwm_up_down (pwmtable_10, 64, delay);
}

// 16-Bit PWM with 256 different settings

void pwm_16_256 (uint16_t delay)
{
// 16 Bit Fast PWM
TCCR1A = 0x82 | INVERT_PWM;
// stop timer
TCCR1B = 0;
// TOP for PWM, full 16 Bit
ICR1 = 0xFFFF;
// prescaler 1 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << WGM13) | 1;

pwm_up_down (pwmtable_16, 256, delay);
}

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

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

// 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;
}
</syntaxhighlight>

== 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 eingeschaltet 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 setzt den Ausgang normal auf Low. [http://www.mikrocontroller.net/topic/200173#1965686].

; Wieso dimmt man eine LED nicht besser mit einer variablen Stromquelle?: Nur so ist es möglich, die LEDs von nahezu 0 bis 100% zu dimmen, ohne dass es zu Farbänderungen kommt, was besonders bei RGB-Anwendungen wichtig ist.

; Wie stimmen die Werte im LibreOffice Calc Sheet mit denen im Programm überein?: Basis = (Max/Factor)^(1/(Steps-1)) pwmtable_xx[0] = 0 pwmtable_xx[Index] = Round(Factor * Basis^Index); for Index=1..Steps-1 pwmtable_8A - Max=255,   Steps=4,   Factor=4 pwmtable_8B - Max=255,   Steps=8,   Factor=2 pwmtable_8C - Max=255,   Steps=16,   Factor=1.435 pwmtable_8D - Max=255,   Steps=32,  Factor=1.21 pwmtable_10 - Max=1023,  Steps=64,  Factor=1.118 pwmtable_16 - Max=65535, Steps=256, Factor=1.04427 Anmerkung 1: Dies ist nur ein Reverse-Engineering, es ist derzeit nicht bekannt, warum der jeweilige Faktor so gewählt wurde wie oben angeführt. Anmerkung 1.1: Mit der gefitteten Funktion Faktor(Steps) = 0,983118 + 18,061952 / ( 1+ (LOG10(steps)/0,3515028)^2,985948 ) lassen sich die Faktor-Werte für beliebige Schrittzahlen ausreichend genau berechnen, auch wenn sie keinen zusätzlichen Erklärungsgehalt bietet. Anmerkung 2: Für das LibreOffice Calc Sheet siehe oben [[#Das_Demoprogramm|Das Demoprogramm]]. Anmerkung 3: Der für die Tabelle benötigte EEPROM-Speicher entspricht log_2(MAX+1)*steps bit.

== Fußnoten ==
<references/>

== Siehe auch ==
* [[PWM]]
* [[AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe#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]
* [http://www.solstice.de/cms/upload/pdf/Veroeffentlichungen/Weber-Fechner-PHidS-1994.pdf [PDF<nowiki>]</nowiki> "Experimente zur logarithmischen Empfindlichkeitsskala - Das Weber-Fechnersche Gesetz"] - Download Nr. 50 von [http://www.solstice.de/initiatoren/werner-schneider/veroeffentlichungen.html Solstice - Veröffentlichungen von Prof. Dr. Werner B. Schneider]

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

Transistor

2019-04-21T20:23:05Z

Ingo k2: /* Wann setzt man einen MOSFET, Bipolartransistor, IGBT oder Thyristor ein ? */

Kunstwort aus "transfer resistor", was etwa so viel bedeutet wie "übertragener [[Widerstand]]".

In den 1950-ern als praktische Anwendung des [[Halbleiter]]-Effekts erfundenes "solid state" Schalt- und Verstärkerelement, welches sehr klein ist, ohne bewegte Teile auskommt (anders als ein klassisches Relais) und keine energiefressende Heizung benötigt (anders als eine Röhre).

Vom "bipolaren Transistor" (PNP, NPN) weiterentwickelt zum "Feldeffekt-Transistor" ([[FET]]), der heute - gefertigt mit einem preiswerten Verfahren unter Verwendung von Metall-Oxid-Schichten (MOS) - ein wesentliches Element integrierter Schaltkreise (ICs, integrated circuits) darstellt, und damit natürlich auch von [[Mikrocontroller]]n, um die es in diesem Wiki hauptsächlich geht (bzw. gehen sollte).

== Schaltzeichen ==
https://electronicsclub.info/images/transbce.gif

* E: Emitter
* B: Basis
* C: Collector

In ASCII Schaltplänen sehen Transistoren so aus:
<pre>
|> |/
NPN |> oder -| oder -|
|\ |>

|< |/
PNP: |< oder -| oder -|
|\ |<
</pre>

Um zu erkennen, ob ein NPN oder PNP Transistor im Schaltplan verwendet wird, gibt es Eselsbrücken:
*Für Dichter: '''Tut der Pfeil der Basis weh, handelt's sich um PNP.'''
*Für Praktiker: '''PNP heisst "Pfeil Nach Platte"'''.
*Mit Dialekt: '''NPN "'naus, Pfeil, 'naus"'''.
*..und für Gleichberechtigungsverfechter: '''NPN means "Not Pointing iN"'''.

JFET: [[Bild:Transistor_JFET.png]]

MOSFET: [[Bild:Transistor_MOSFET.png]]

* S: Source
* G: Gate
* D: Drain

Eigentlich haben MOSFETs noch einen vierten Anschluss namens Bulk. Der ist aber nur bei Spezialtypen als Pin herausgeführt. Im Normalfall kann man ihn vergessen, da er nicht gesondert beschaltet werden muss, er ist praktisch und auch im Symbol mit Source verbunden.

'''Achtung:''' Die NPN/PNP Eselsbrücken funktionieren bei FETs nicht, denn bei einem P-Kanal FET zeigt der Pfeil weg vom FET!
Ein Bipolartransistor, im Englischen als bipolar junction transistor (BJT) bezeichnet, ist ein Transistor, bei dem Ladungsträger – negativ geladene Elektronen und positiv geladene Defektelektronen – zum Stromtransport durch den Bipolartransistor beitragen. Der BJT wird mittels eines elektrischen Stroms gesteuert und wird zum Schalten und Verstärken von Signalen ohne mechanisch bewegte Teile eingesetzt.

Bipolare Leistungstransistoren sind für das Schalten und Verstärken von Signalen höherer Stromstärken und Spannungen ausgelegt.

== Typbezeichnungen ==

Neben den Typbezeichnungen wie 2Nxxxx, TIPxxx, MJxxx, MJExx gibt es noch die in Europa geläufigere Kennzeichnung bestehend aus zwei Buchstaben und drei Ziffern. Die diversen Kennzeichnungsmöglichkeiten sind in einem eigenen Artikel ([[Kennzeichnung von Halbleitern]]) zusammengefasst.

== Kenndaten/Parameter ==

Im [http://www.mikrocontroller.net/topic/197676#1938546 Beitrag: Transistorparameter Erklärung] sind Links zu Erläuterungen spezieller Kürzel.

== Transistor Grundschaltungen ==

Generell gilt, dass Strom vom Kollektor zum Emitter nur dann fließen kann, wenn die Basis positiver (NPN) bzw. negativer (PNP) wird als der Emitter. Dabei darf die Basis nicht direkt mit Vcc (NPN) oder GND (PNP) verbunden werden, da der Basisstrom sonst zu gross wird. Es muss jeweils ein geeigneter Basiswiderstand (R_Basis) gewählt werden.

'''Weitere Links:'''
* Artikel [[Basiswiderstand]]
* [http://www.elektronik-kompendium.de/sites/slt/0203111.htm Transistor Grundschaltungen im ElKo]
* [http://www.roboternetz.de/wissen/index.php/Transistor Transistor bei RoboterNetz.de]

Es gibt drei Grundschaltungen. Der Name beschreibt den Anschluss, welcher sich auf einem festen Potential (Spannung) befindet. Die beiden anderen Anschlüsse haben bedingt durch die Schaltung ein veränderliches Potential.

=== Kollektorschaltung (Emitterfolger)===

'''Anwendung:'''
* Impedanzwandler
* Darlington-Schaltung
* Schalter

'''Eigenschaften:'''
* Keine Phasendrehung
* Hohe Stromverstärkung
* Keine Spannungsverstärkung

'''Beispiel: Transistor als Schalter'''

* NPN: Kollektor mit Vcc verbinden, Last an Emitter
* PNP: Kollektor mit GND verbinden, Last an Emitter

In diesem Fall regelt der Transistor die Spannungen am Emitter, daher wird die Last am Emitter angeschlossen. Die Spannung am Emitter entspricht immer der an der Basis minus 0,6V, sie folgt der Basisspannung, deswegen auch der Name Emitterfolger. Daher ist diese Schaltung nicht geeignet, um 12V mit 5V zu schalten.

[[Bild:NPN_Collector.gif | framed | center | NPN Transistor in Kollektorschaltung]]

Wird <math>R_{Poti}</math> (Spannungsteiler) erhöht, steigt die Spannung <math>U_{Last}</math> letztlich bis auf Vcc-0,6V (Basis-Emitter-Übergang).

[[Bild:PNP_Collector.gif | framed | center | PNP Transistor in Kollektorschaltung]]

Wird <math>R_{Poti}</math> (Spannungsteiler) erhöht, sinkt Spannung an <math>U_{Last}</math> letztlich bis auf 0,6V (Basis-Emitter-Übergang).

'''Weitere Links:'''
* [http://www.elektronik-kompendium.de/sites/slt/0204133.htm Kollektorschaltung im ElKo]

=== Emitterschaltung ===

Die Emitterschaltung bietet hohe Spannungs- und Stromverstärkung.

'''Anwendung:'''
* NF- und HF-Verstärker
* Leistungsverstärker
* Transistor als Schalter

'''Eigenschaften:'''
* Phasendrehung 180°
* Hohe Spannungsverstärkung
* Hohe Stromverstärkung

'''Beispiel: Transistor als Schalter'''

Die Last liegt am Kollektor. Der Strom durch den Schalter oder an U_Schalt steuert den Strom zwischen Kollektor und Emitter. Wird der Schalter geschlossen, fließt ein Strom.

[[Bild:NPN_Schalter.gif | framed | center | NPN Transistor als Schalter]]
<pre>
___ ___
Vcc/+ o-----------------------+ Vcc/+ o-----------------------+
| |
___ |< U_schalt (-) ___ |< PNP
+------|___|---| PNP o------------|___|----|
| R_Basis |\ R_Basis |\
Schalter \ | |
| ___ | ___ |
GND/- o------+------|___|-----+ GND/- o-------------|___|-----+
R_Last R_Last

</pre>

'''Weitere Links:'''
* [http://www.elektronik-kompendium.de/sites/slt/0204302.htm Emitterschaltung im ElKo]

=== Basisschaltung ===

Die Basisschaltung findet sich vor allem in Eingangsstufen in der HF-Technik. Im Schaltbetrieb wird sie praktisch nur zur [[Pegelwandler#STEP-UP: 5V -> 9..15V | Pegelwandlung]] für nachfolgende Stufen verwendet.

'''Eigenschaften:'''
* Geringe Eingangsimpedanz
* Keine Phasenverschiebung
* Hohe Bandbreite

'''Weitere Links:'''
* [http://www.elektronik-kompendium.de/sites/slt/0205081.htm Basisschaltung im ElKo

== FAQ aus dem Forum ==

=== PNP/NPN als Schalter, wohin mit der Last? ===
Für viele einfache Anwendungen kann man sich merken: '''Bei Schaltanwendungen darf der Basisstrom nicht durch die Last fließen'''. Normalerweise kommt dabei die Emitterschaltung zum Einsatz, die Last kommt also an den Kollektor.

<pre>
Vcc o-------------+ Vcc o-----------+
| |
.-. An: GND ___ |<
| | R_Last o---|___|--| PNP
'-' Aus: Vcc |\
| |
An: Vcc ___ |/ .-.
o---|___|----| NPN | | R_Last
Aus: GND |> '-'
| |
GND o-------------+ GND o-----------+
</pre>

Siehe [[Basiswiderstand]] zur Berechnung des notwendigen Basiswiderstandes bei gegebener Last R_Last für einen Transistor als Schalter.

Siehe auch Threads im Forum:
* http://www.mikrocontroller.net/topic/58567
* http://www.mikrocontroller.net/topic/119841
* oder im [http://www.elektronik-kompendium.de/sites/slt/0208031.htm Elektronik-Kompendium-Forum]

=== Wie kann ich mit 5V vom Mikrocontroller 12V und mehr schalten? ===
Schau mal hier:
* Wikiartikel [[Pegelwandler]]
* [http://www.elektronik-kompendium.de/sites/praxis/bausatz_pegelwandler-mit-transistoren.htm Pegelwandler im ElKo]
* [http://dl6gl.de/grundlagen/schalten-mit-transistoren schalten-mit-transistoren]

oder in diesen Threads:
*[http://www.mikrocontroller.net/topic/17899 Transistor als Schalter]
*[http://www.mikrocontroller.net/topic/14437 Vcc schalten mit MOSFET]
*[http://www.mikrocontroller.net/topic/29830 Schalten mit PNP-Transistor]
*[http://www.mikrocontroller.net/topic/104027 Transistorschalter für Versorgungsspannung]
*[http://www.mikrocontroller.net/topic/104951#921417 7-50V strombegrenzt schalten]
*[http://www.mikrocontroller.net/topic/103116#900247 P-Kanal MOSFET ansteuern]
*[https://www.mikrocontroller.net/topic/383039#4367479 5V/15mA mit 3,3V schalten]
*[https://www.mikrocontroller.net/topic/401317#4638354 High Side Treiber mit Ladungspumpe]
*[https://www.mikrocontroller.net/topic/347885?goto=3855574#3855574 minus -12V mit 3,3V schalten]

Bei der Kollektor-Schaltung entspricht die Spannung am Emitter immer der an der Basis, daher ist sie nur bedingt geeignet. Zum Schalten können die folgenden Emitter-Schaltungen verwendet werden. Achtung: In der zweiten davon arbeitet T1 in Basisschaltung.

Schalten gegen GND

<pre>
+12V o------------------------+
|
.-.
( X )
'-'
|
___ |/ T1,NPN
uC PIN o---|___|-----| BC547
R2,4K7 |>
|
GND o---------o--------------+
</pre>

Schalten gegen +12V

<pre>
+12V o--------------+----------------------+
| |
| ____ |< T2, PNP
+--|____|----+--------| BC557
R1,4K7 | |\
|/T1,NPN |
Vcc/+5V o--------------| BC547 |
|> |
___ | .-.
uC PIN o-----|___|------+ ( X )
R2,4K7 '-'
|
GND o----------o--------------------------+
</pre>

=== Transistor an µC ohne Vorwiderstand ===

Normalerweise sind IO Pins vom µC nicht in der Lage, große Ströme zu treiben, beim AVR maximal ~20mA. Für einen kleinen Transistor ist das immer noch zu viel und es wäre auch Stromverschwendung.

Deshalb kann man den IO-Pin des AVRs einfach als Tristate Eingang einstellen (Portpin als Eingang und Pullup deaktivieren), damit kein Basisstrom fließt.

Aktiviert man nun den internen Pullup-Widerstand des AVRs, agiert dieser als Basisvorwiderstand, und es fließt nur ein geringer Basisstrom (die Pullups eines AVRs liegen irgendwo bei 50k bis 100k Ohm - siehe Datenblatt).

Nur sollte man bei kleinen Transistoren aufpassen, dass man den Portpin in der Software nie als aktiven Ausgang schaltet.

Wenn der verwendete µC zuschaltbare Pulldown-Widerstände an seinen Pins besitzt, kann man das gleiche auch mit einem PNP-Transistor machen (natürlich nur den Pulldown aktivieren).

Eine Anwendung wären z. B. Nixie-Röhren-Kathodentreiber (geringe Stromverstärkung nötig).

=== Wann bipolare (NPN/PNP) und wann FETs (insbesonders, wenn LEDs im Spiel sind)?===
Oft sind bipolare Transistoren (NPN/PNP) schon ausreichend, vor allem wenn "normale" LEDs (20mA) verwendet werden. FETs sind u.a. dann gut, wenn mit geringen Eingangsströmen hohe Ausgangsströme (über 300 mA) geschaltet werden sollen, also bei den Power-LEDs (Luxeon...).

Ein Grenzfall: 500mA/5V schalten, siehe http://www.mikrocontroller.net/topic/62327.

=== Wieso gehen bei einer Multiplex-Anzeige mit Schieberegister 74HC595 und (Darlington-)Transistor als Zeilentreiber die LED nicht ganz aus? ===
Das liegt an der '''Miller-Kapazität''' des übersteuerten (Darlington-)Transistors. Der braucht erst mal einige 10µs, um zu sperren. Du mußt also erstmal beide Zeilen ausschalten, dann etwas warten und dann die nächste Zeile an. Oder Du ersetzt die Darlington durch P-FETs. [http://www.mikrocontroller.net/topic/132545]

=== Wie steuert man ein Relais? ===
Normalerweise verwendet man zur Ansteuerung von Relais NPN-Transistoren in Emitterschaltung. Freilaufdiode nicht vergessen!

Siehe auch:
* [[Relais mit Logik ansteuern]]
* [http://www.mikrocontroller.net/attachment/22023/Relaisanteuerung.png Schaltbilder aus dem Forum]

=== Was ist die Spannung <math>U_{BE\_sat}</math> (lt. Datenblatt max. 1,2V)? ===
Bekanntlich verhält sich die Basis-Emitter Strecke eines Transistors wie eine Diode und <math>U_{BE\_sat}</math> ist die bei maximal zulässigem Basisstrom anliegende Vorwärtsspannung.

=== Was bewirkt ein Kondensator (100µF-1nF) parallel zur Basis-Emitter-Strecke nach Masse? ===
Er wirkt mit dem Basisvorwiderstand als RC-Tiefpass. Damit wird der Transistor eigentlich nicht mehr als Schalter, sondern als Linearregler betrieben. Manche Verstärker-Schaltungen sind, gerade bei hohen Lasten, sehr schwingfreudig. Deswegen ist bei PWM so ein C nicht sinnvoll.

=== Gibt es einen IC, der wie mehrere Transistoren funktioniert? ===

Gibt es! Beispielsweise der '''ULN2803''' ist ein 8-fach Darlington Transistor Array mit [[Ausgangsstufen_Logik-ICs#Open_Collector|Open-Collector Ausgang]]. Damit lässt sich z. B. ein Leistungstreiber zur Ansteuerung von Schrittmotoren, Relais und anderen induktiven Lasten aufbauen.

=== Gibt es ein Transistor-Array wie ULN28xx, das gegen Vcc schaltet? ===

Such mal nach UDN29xx, z. B. UDN2981, UDN2987 ...

Allegro hat zwischenzeitlich seinen Source-Treiber umbenannt. Die Bauteile heißen jetzt A2981, A2982 usw... Die Datenblätter sind identisch geblieben.

Nachteil eines Darlington-Source-Treibers ist die hohe Sättigungsspannung (VceSat) von typisch 1,2 V. Die Eingangsspannung sollte dementsprechend höher ausgelegt werden oder gleich ein Source-Treiber mit MOSFET-Transistoren gewählt werden (z.B. Infineon ProFETs).

=== Wann setzt man einen MOSFET, Bipolartransistor, IGBT oder Thyristor ein? ===
siehe [[Leistungselektronik]]

Die Summe allen Übels ist konstant. Man muss wissen, welches Bauteil sich wofür besonders eignet.

====[[FET | MOSFET]]====

Vorteile
* Bei niedrigen Spannungen <100V sehr gut geeignet, <200V gut geeignet, sehr geringe R_DS-ON Widerstände möglich (einstelliger mOhm-Bereich)
* Hohe Schaltgeschwindigkeiten möglich
* Geringe An- und Ausschaltverluste
* Statisch praktisch leistungslos steuerbar
* Bodydiode kann als Freilaufdiode in H-Brücken verwendet werden
* 2. Durchbruch bei Überschreiten der max. Drain-Source Sperrspannung zerstört das Bauteil nicht, wenn der Strom sowie die Energie begrenzt werden. (Verhalten wie [[Diode | Z-Diode]])

Nachteile
*Antiparallele Diode (Bodydiode) ist in nahezu allen MOSFETs unvermeidlich, daduch Sperren nur in einer Polarität möglich, Stromfluss über den MOSFET aber in beiden Richtungen möglich (Inversbetrieb, Synchrongleichrichter)
* Bei Sperrspannungen >100V deutlich steigende Einschaltwiderstände (R_DS-ON)
* Schnelles Umschalten erfordert hohe Lade-und Entladeströme ([[MOSFET-Übersicht#Mosfet-Treiber|MOSFET-Treiber]])
* Leitverluste quadratisch proportional zum Strom, Pv = I²*R_DS-ON

====[[Transistor | Bipolartransistor]]====

Vorteile
* Hohe Spannungsfestigkeiten möglich, bis zu 2000V
* Sehr hohe Schaltgeschwindigkeiten möglich
* Leitverluste etwa linear proportional zum Strom und Kollektor-Emitter-Sättigungsspannung, Pv = I * Uce-sat, U_CEC-sat typ 0,1...2.5 V

Nachteile
* Stromgesteuert, damit wird immer eine gewisse Ansteuerleistung benötigt
* Bei grossen Kollektorströmen nimmt die Stromverstärkung deutlich ab, dann wird ein großer Basisstrom benötigt
* 2. Durchbruch bei Überschreiten der max. Kollektor-Emitter Sperrspannung zerstört das Bauteil

====[[IGBT]]====

Vorteile
* Hohe Spannungsfestigkeiten möglich, bis zu 6600V, in üblichen Bauformen bis ca 1700V gut verfügbar
* Statisch praktisch leistungslos steuerbar
* Mit oder ohne antiparallele Diode zur Kollektor-Emitter-Strecke verfügbar
* Leitverluste linear proportional zum Strom und Kollektor-Emitter-Sättigungsspannung, Pv = I * Uce-sat, U_CE-sat typ. 2V

Nachteile
* Nur mäßige Schaltfrequenzen möglich (typ. <30..50kHz)
* Schnelles Umschalten erfordert hohe Lade-und Entladeströme ([[MOSFET-Übersicht#Mosfet-Treiber|MOSFET-Treiber]])
* 2. Durchbruch bei Überschreiten der max. Kollektor-Emitter Sperrspannung zerstört das Bauteil

====[[TRIAC]]/Thyristor====

Vorteile:
* Sehr hohe Spannungsfestigkeiten möglich (800V...mehrere kV, Thyristoren bis 12kV)
* Mit kurzen Pulsen einschaltbar, danach Selbsthaltung des Stromflusses
* Leitverluste linear proportional zum Strom, Pv = I * Uak, Uak typ. 0,8...1,5 V

Nachteile
* Auf niedrige Schaltfrequenzen beschränkt (kHz-Bereich, Schaltzeit im Bereich von µs)
* Anstiegsgeschwindigkeit des Stromes muss begrenzt werden, sonst kommt es zu Bauteilschäden
* Anstiegsgeschwindigkeit der Spannung muss begrenzt werden, sonst kommt es zum ungewollten Zünden
* Stromfluss kann nicht ausgeschaltet werden, damit meist nur Einsatz an Wechselspannung

{| class="wikitable"
|-
! Bauteil || optimales Einsatzgebiet || Kommentar
|-
| MOSFET || 0..200V, 0..500A || im Kleinspannungsbereich meist die beste Wahl als Schalter
|-
| Bipolartransistor || 0..1000V, 0..10A || wird mehr und mehr von MOSFETs verdrängt
|-
| IGBT || 200..1700V, 0..500A || optimal für hohe Spannungen und hohe Ströme
|-
| Triac/Thyristor || 230V, 400V, 680V, bis mehrere kV, 0..100A || meist für Wechselspannung, im Pulsbetrieb einige kA. Thyristoren bis 1000A im Dauerbetrieb (Scheibenzelle)
|}

=== Wie finde ich den richtigen Transistor für eine LED-Ansteuerung? ===

Quelle: Beiträge [http://www.mikrocontroller.net/topic/157763#1493623] und [http://www.mikrocontroller.net/topic/157763#1494972] von yalu

Um am Anfang wenigstens ein bisschen den Durchblick im Transistordschungel zu behalten, kannst du folgendermaßen vorgehen:

'''Nomenklatur'''

Nach der amerikanischen Nomenklatur beginnen die Transistornamen meist mit 2N (z. B. 2N2222 oder 2N3055) und nach der japanischen mit 2S (z. B. 2SC1815). Für den Anfang kann man sich auf europäische Transistoren beschränken, da es diese in ausreichender Auswahl gibt und die Bezeichnungen relativ gut den Transistortyp wiedergeben:

Der erste Buchstabe bezeichnet das Halbleitermaterial (A=Germanium, B=Silizium). Germaniumtransistoren werden heute nur noch selten verwendet.

Der zweite Buchstabe steht für den Einsatzzweck (C=Universal, D=hohe Leistung, F=Hochfrequenz, U=hohe Spannung).

So ist also ein ACxxx ein Germaniumuniversaltransistor und ein BDxxx ein Siliziumleistungstransistor.

'''Auswahl'''

Wenn du dich für einen Grundtyp entschieden hast (für die LED ist ein BC-Typ das Richtige), gehst du auf die Webseite eines Elektronikhändlers (Reichelt, Kessler usw.), schlägst die Seite mit den BC-Transistoren auf. Da gibt es natürlich sehr viele davon, und du brauchst jetzt eine
Suchreihenfolge. Als erstes Auswahlkriterium nimmst du den Preis, denn:

* Zuviel Geld hast wahrscheinlich nicht einmal du.
* Billig ist meist das, was in großen Stückzahlen hergestellt wird. Was für die Masse gut ist, ist (zumindest in diesem Fall) meist auch für dich gut.
* Was billig und damit in Massen verkauft wird, bekommst du auch bei anderen Händlern und auch noch in 10 Jahren. Das ist wichtig, wenn deine Schaltung irgendwann einmal in Serie gefertigt werden soll.

Gleich als nächstes überlegst du, ob du einen NPN- oder einen PNP-Typ brauchst. Das ergibt sich aus der Anordnung der Bauteile in deiner Schaltung. Hast du die Möglichkeit, die Schaltung wahlweise für einen NPN- oder einen PNP-Typ auszulegen, wählst du die Variante mit dem NPN-Typ. Um einfach eine LED über einen Mikrocontroller einzuschalten, ist i.Allg. ein NPN-Typ in Emitterschaltung richtig.

Ein weiteres wichtiges Kriterium ist die Befestigungstechnik: Wenn dir die SMD-Löterei etwas suspekt ist, lässt du die entsprechenden Modelle erst einmal alle außen vor. Ein typisches Nicht-SMD-Gehäuse für Universaltransistoren ist TO-92. Es gibt im Internet bebilderte Listen mit den einzelnen Gehäuseformen ([[IC-Gehäuseformen#Weblinks]])

Wenn du jetzt also bei Reichelt die BC-Transistoren nach Preis aufsteigend sortiert hast, siehst du erst einen Schwung SMD-Tranistoren. Dann kommen ein paar Transistoren im TO-92-Gehäuse, die sind aber PNP. Etwas weiter unten kommt der erste NPN-Transistor in TO-92, nämlich der BC547C. Netterweise stehen gleich ein paar Eckdaten dabei:

<pre>
BC547C 45V 0,1A 0,5W
</pre>

Die 45V sind die maximale Kollektor-Emitter-Spannung, in deinem Fall also die Spannung, die du maximal schalten kannst. Da die LED bei Weitem keine 45V braucht und deine Versorgungsspannung eher in der Gegend von 5V liegt, bist du auf jeden Fall auf der sicheren Seite.

Deine LED wird typisch mit 20mA (max. 30mA) betrieben. Der BC547C kann 100mA, also ist auch hier noch Luft.

Zur maximalen Verlustleistung (0,5W): Wenn deine LED eingeschaltet ist, fließen bspw. 20mA. Ist der Transistor voll durchgesteuert (in Sättigung) beträgt die Kollektor-Emitter-Spannung bei diesem geringen Strom typischerweise zwischen 0,1V und 0,2V (Genaueres steht im Datenblatt). Am Transistor wird also maximal die Leistung 20mA·0,2V=4mW in Wärme umgesetzt. Bis zu 500mW dürfen es sein, also ebenfalls ok.

Nachdem du den Transistor in engere Auswahl gezogen hast, lohnt sich auf jeden Fall ein Blick ins Datenblatt. Aus den Tabellen und Diagrammen erfährst du bspw., wie hoch der Basisstrom sein muss, um den Kollektorstrom von mindestens 20mA bei ausreichend geringer CE-Spannung bereitzustellen. Dort ist auch erklärt warum es einen BC547A, BC547B und BC547C gibt. Der letzte Buchstabe gibt nämlich die Stromverstärkungsklasse an. Da eine hohe Stromverstärkung meist wünschenswert ist und in diesem Fall keinen Aufpreis kostet, ziehst du den BC547C den anderen beiden vor.

Da in deiner Anwendung HF- und Rauschverhalten keine Rolle spielen, bist du schon am Ziel angelangt.

Würde deine LED 100mA statt 20mA benötigen, wären die max. 100mA des BC547 etwas knapp bemessen. Du blätterst also in der Reichelt-Liste weiter und stößt auf den BC337-40 mit 45V, 0,5A und 0,525W. Das ist genau das, wonach du suchst. Bei diesem Transistor sind die Stromverstärkungsklassen durch die Endungen -16, -25 und -40 gekennzeichnet. Es wäre ja auch
zu einfach, wenn immer nur A, B und C verwendet würde ;-)

Bei Strömen ab etwa 500mA kommt man an die Grenze der Leistungsfähigkeit der BC-Typen. Dann geht es weiter mit BD. Der BD135 geht bspw. schon bis 1,5A. Das Problem bei solchen größeren Transistoren: Die Stromverstärkung ist nicht besonders hoch, so dass irgendwann der Mikrocontroller nicht mehr den benötigten Basisstrom liefern kann. Dann muss dem großen Transistor ein kleiner vorangeschaltet werden, um den erhöhten Basisstrom bereitszustellen. Man kann diese Kombination von zwei Transistoren auch fertig als Darlington-Transistor kaufen, von denen ebenfalls einige in der BD-Reihe zu finden sind (z. B. BD647). Ein Transistortyp, der sich sehr gut zum Schalten höherer Ströme eignet, ist der [[FET | MOSFET]].

Wie schon oben angedeutet: Wenn die 30-80V die die meisten BC- und BD-Transistoren abkönnen, nicht ausreichen, suchst du weiter bei BU.

Steigst du in die HF-Technik ein, sind BF-Transistoren eher das Richtige, wobei bei HF-Anwendungen die Auswahl der Transistoren nicht mehr das Schwierigste ist ;-)

'''Und wie geht's weiter?'''

Man könnte natürlich noch viel mehr zu diesem Thema schreiben. Ich hoffe aber, dass das Geschriebene dir wenigstens grob zeigt, wie man bei nicht allzu speziellem Anforderungen relativ schnell zu einem gewünschten Transistortyp kommt, der nicht nur die technischen Anforderungen erfüllt, sondern auch leicht beschaffbar ist.

Werden die Anforderungen spezieller, helfen oft die Selektionstabellen auf den Webseiten der einschlägigen Hersteller weiter. Auch Händler wie Farnell haben teilweise ganz gute Auswahlwerkzeuge.

Wenn du dich intensiv mit Elektronik beschäftigst, wirst du wahrscheinlich noch viele Schaltungen von Leuten zu Gesicht bekommen, die vielleicht schon etwas weiter fortgeschritten sind. Dabei wirst du immer wieder auf bestimmte Standardtypen von Transistoren (und auch anderen Bauteilen wie Operationsverstärker u.ä.) stoßen und sehen, welche [[Standardbauelemente]] "man" üblicherweise für bestimmte Anwendungen einsetzt. Mit der Zeit setzt sich dann eine Auswahl von bspw. 10 oder 20 verschiedenen Transistoren und 5 bis 10 verschiedenen OpAmps im Kopf fest, von denen man die wesentlichen Parameter auswendig kennt, so dass man ohne aufwendige Suche eine schnelle Auswahl treffen kann. Auch hier in der Artikelsammlung gibt es eine solche [[Transistor-Übersicht]].

=== Wo ist die Antwort auf meine Frage? ===

Vielleicht im Forum? Falls du sie da findest, dann pack das ganze doch hier rein.

[http://www.mikrocontroller.net/topic/165580 Gegen Vcc oder GND schalten]

== Siehe auch ==
* [[Basiswiderstand]]
* [[Transistor-Übersicht]]
* [[AVR_Transistortester]] - neu (Weiterentwickelt von Karl-Heinz Kübbeler)
* [[AVR-Transistortester]] - alte (von Markus Frejek)
* [[Leistungselektronik]]

== Gehäusebauformen von Transistoren ==

=== TO-92 ===
Ein kleiner Aufsatz über TO-92 Transistorgehäuse und Footprints findet sich unter: [[Media:TO-92-Gehaeuse_RevB2.pdf]].

== Weblinks ==
* [http://de.wikipedia.org/wiki/transistor "Transistor" bei Wikipedia]
* [http://www.elektronik-kompendium.de www.elektronik-kompendium.de]
** [http://www.elektronik-kompendium.de/sites/bau/0201291.htm Elko/Transistor]
* http://www.elektronikinfo.de/strom/bipolartransistoren.htm
* http://www.ferromel.de/tronic_1870.htm
* [http://www.DieElektronikerseite.de Die Elektronikerseite] Lehrgang: Der Transistor - Ein Tausendsassa
* [http://www.infoplease.com/encyclopedia/science/transistor-types-transistors.html Transistortypen]
* [http://electronics-electrical.exportersindia.com/electronic-components/transistors.htm Transistoren Industrieunternehmen Geschäftsauflistungen]

[[Category:Bauteile]]
[[Category:Grundlagen]]

4000 Stellen von Pi mit ATtiny2313

2019-04-12T20:48:50Z

Ingo k2: /* Die Formel */

[[Bild:attiny2313.jpg|thumb|right|ATtiny2313 im [[IC-Gehäuseformen|DIL]]-Gehäuse]]
Als neulich im Foren nach einem
: ''"rechenintensiven Beispielprogramm für den kleinen ATtiny2313 in C oder ASM"''<ref>[http://www.mikrocontroller.net/topic/248373 Forum: AVR Atiny2313: ''"Suche rechenintensivs Beispielprogramm für ATtiny2313"'']</ref>
gesucht wurde und als Vorschlag ein
: ''"Pi auf 1000 Stellen"''<ref>[http://www.mikrocontroller.net/topic/248373#2544249 Forum: AVR Atiny2313: ''"Pi auf 1000 Stellen"'']</ref>
kam, wolle ich es genauer wissen. Auch wenn der Vorschlag eher als Scherz aufzufassen ist — sind C-Compiler inzwischen so gut, daß damit π auf tausende Stellen berechnet werden kann? Bei einem Assembler-Programm hätte ich da keine Bedenken; aber C?

Der [[AVR]] ATtiny2313 ist bekanntlich ein 8-Bit [[Mikrocontroller]] mit 2048 Bytes an Programmspeicher und 128 Bytes RAM. Die Aufgabe erfordert also eine spezielle Herangehensweise, denn nicht alle zu berechnenden Stellen sind gleichzeitig im RAM des µC speicherbar: bereits berechnete Stellen sollen ausgegeben werden, und an der Ausgabe-Schnittstelle sollen Ziffernweise die Nachkommastellen von π heraus purzeln.

== Die Formel ==

Das theoretisch-algorithmische Rüstzeug dafür ist lange bekannt und das Web ist voll davon: Eine 1995 von Simon Plouffe gefundene Reihendarstellung<ref>Für einen Beweis siehe [http://www.pi314.net/eng/plouffe.php The World of π: Proof: Formula BBP].</ref> für π:
:<math>
\pi=\sum_{k=0}^\infty \frac1{16^k}
\left(\frac4{8k+1}-\frac2{8k+4}-\frac{1}{8k+5}-\frac1{8k+6}\right)
</math>
Die Anwendung der Darstellung besteht dabei nicht in stupidem Auswerten bis zur gewünschten Genauigkeit, sondern es wird die n-te Nachkommastelle von π damit bestimmt ''ohne'' vorherige oder nachfolgende Ziffern der Darstellung zu bestimmen.
Der einzige Wermutstropfen ist, daß die Darstellung zur Basis 16 erhalten wird und nicht wie gewohnt zur Basis 10 — aber immerhin liefert die Formel ''überhaupt'' erst einen Weg, um die Berechnung auf einer kleinen Hardware mit 2k Programmspeicher ausführen zu können.
Auch dieser Weg ist hinreichend oft im Internet erklärt — je nach Seite mehr oder weniger gut. Eine gute Erklärung findet sich etwa in der Wikipedia<ref>[http://fr.wikipedia.org/wiki/Formule_BBP#Exploitation_de_la_formule_pour_calculer_les_chiffres_apr.C3.A8s_la_virgule_de_.CF.80 Wikipédia: Formule BBP]: Exploitation de la formule pour calculer les chiffres après la virgule de π</ref>

Die ganze Aufgabe besteht also nur noch darin, den Algorithmus hinzuschreiben und zu compilieren — und zu hoffen, dass das erzeugte Programm in den kleinen Programmspeicher eines ATtiny hineinpasst.

Gerade der letzte Punkt ist nicht selbstverständlich, denn die Anwendung der obigen Formel verlangt den Einsatz von Fließkomma-Arithmetik. Zwar ist auch eine
Implementierung mittels Festkomma-Zahlen möglich, aber ich wollte mit den Bordmitteln der C-Sprache auskommen: Ohne Inline-Assembler Hacks, ohne umständliches Hin-und-Herwandeln und Skalieren, ohne Implementierung eigener Divisionroutinen, etc. Das Programm kann daher auch als Stresstest für die Tools verstanden werden.

Als Sprache wählte ich C99 und als Compiler avr-gcc<ref>[http://gcc.gnu.org/ GCC]: The GNU Compiler Collection</ref> 4.7 oder neuer, so daß ein Executable erzeugen wird, das in die 2k Programmspeicher eines ATtiny2313 hineinpasst.

== Der Quelltext: C99 ==

Zur Implementierung ist hier nicht viel zu sagen; die Quellen sind ausführlich kommentiert. Nur noch einige Anmerkungen:
* Die Quellen sind so allgemein gehalten, dass das Programm auch für einen PC übersetzt und dort ausgeführt werden kann.
* Wird für AVR übersetzt, erfolgt die Ausgabe der berechneten Ziffern auf der UART-Schnittstelle. Für Compiler- und Linker-Optionen siehe die Quellkommentare.
* Bei einer Taktfrequenz von 20 MHz dauert die Berechnung der ersten 1000 hex-Ziffern etwa 3–4 Minuten. Verdoppelt man die Anzahl der Ziffern, ist die 4-fache Rechenzeit zu erwarten.
* Der Algorithmus liefert brauchbare Resultate für die ersten 4096 Nachkommastellen von π. Danach reichten die verwendeten 16-Bit int für ganze Zahlen nicht mehr aus, und für 32-Bit Zahlen ist der Programmspeicher des ATtiny2313 zu klein.
* Der Algorithmus berechnet wie gesagt Nachkommastellen der Hexadezimaldarstellung von π. 4000 hex-Nachkommastellen entsprechen übrigens ca. 4800 Dezimalstellen: log 16 / log 10 ≈ 6/5.
* Die Ausgabe lässt sich etwa vergleichen mit "First 8366 Hex Digits of PI"<ref>[http://www.herongyang.com/Cryptography/Blowfish-First-8366-Hex-Digits-of-PI.html www.herongyang.com]: First 8366 Hex Digits of π</ref>
* Den Quelltext gibt es auch hier als bereits fertig kompiliertes Atmel Studio 6.1 SP2 Project (inkl. Hex und ELF): [[Medium:4000Pi.zip]] (60KB)

<pre>
/* pi.c: Compute the first 4000 hexadecimal digits of pi
on an AVR ATtiny2313 microcontroller. */
/*
Language: C99
Compiler: An AVR toolchain based on avr-gcc 4.7 or newer and AVR-Libc
if you like to compile for AVR ATtiny2313, or a C99-compliant
compiler if you like to run this program on a PC.

Hardware: AVR ATtiny2313 which is an 8-bit microcontroller with
128 Bytes of RAM and 2048 Bytes of program memory.
http://www.atmel.com/Images/doc2543.pdf (Manual, PDF, 4 MB)
http://www.atmel.com/Images/doc2543S.pdf (Summary, PDF, 500 kB)

Compile: You need a reasonably optimizing compiler and floating point
implementation, or otherwise the program won't fit into the
tiny silicon. Notice that the code below is *vanilla* C with
IEEE-754 floating point arithmetic and without assembler or
fixed-point hacks.

The program is generic enough to run on a PC. If you use GCC,
just compile with the following command line and run pi.exe

gcc pi.c -o pi.exe -std=c99 -O2 -lm

The only compiler that produces code small enough for the
AVR ATtiny2313 is avr-gcc 4.7+ together with AVR-Libc.

avr-gcc pi.c -o pi.elf $(CFLAGS) $(OPT) $(DEFS) $(LDFLAGS)

with the following abbreviations for convenience:

CFLAGS = -std=c99 -mmcu=attiny2313
OPT = -Os -mcall-prologues -fno-split-wide-types
-fno-caller-saves -fno-tree-loop-optimize
LDFLAGS = -Wl,--relax -Wl,--gc-sections -lm
DEFS = -DF_CPU=22118400 -DBAUDRATE=115200 -DHOST_WINDOWS

For documentation of GCC see http://gcc.gnu.org/onlinedocs

DEFS represents the UART setup. In my circuit I use a
22.1184 MHz quartz which is a bit of overclocking but is so
convenient with baud rates. Depending on your configuration,
you will use other values for F_CPU and BAUDRATE, see below.

The first 1000 digits of pi take about 3 minutes at 22 MHz.
For 4000 digits, multiply this time by 16.

The time to get the first n digits of pi with this method is roughly

T(n) = K * n^2

so that, given the time for the computation of n digits, you can easily
compute K and estimate how long the computation will take for other
values of n. K will depend on the clock speed you use, for example.

Some software metrics for the AVR binary compiled as above:

Program Size: Less than 2000 of 2048 bytes

RAM Usage:
Static storage : 0 bytes
Static stack usage : ~ 50 bytes
Dynamic : 0 bytes
Total : 40% of 128 bytes

Coding Style: Stroustrup
Indentation: 4 Space
*/

#include <stdlib.h>
#include <stdint.h>
#include <math.h>

// Factor out some platform/compiler dependencies

#if defined (__AVR__) && defined (__GNUC__)

// Running on AVR
# include <avr/io.h>
# include <avr/wdt.h>
# define cput(C) uart_putc(C)
static void uart_init (void);
static void uart_putc (const char);

#else // ! avr-gcc

// Running on PC
# include <stdio.h>
# define wdt_reset() (void) 0
# define uart_init() (void) 0
static void cput (char c)
{
fputc (c, stdout);
fflush (stdout);
}

#endif // avr-gcc

// return a * b mod n
//
// 0 <= a < n
// 0 <= b < n
//
// This is a school-book implementation of multiplication that allows for
// larger moduli compared to (a * b) % n.
//
// The implementation widens the range of valid moduli from
// \sqrt{1+UINT_MAX} to (1+UINT_MAX)/2. Or vice versa, it allows us
// to use a smaller type for the modulus -- 16 bits in the AVR case.
//
// Moreover, ATtiny2313 has no hardware multiplyer or divider, anyway.
// We have to cope with 2048 bytes of program memory and are happy
// to avoid dragging in library routines if possible.

static unsigned mod_mul (unsigned a, unsigned b, unsigned n)
{
unsigned ab = 0;

while (1)
{
if (a % 2 == 1)
{
ab += b;
if (ab >= n)
ab -= n;
}

a = a / 2;
if (a == 0)
return ab;

b = b * 2;
if (b >= n)
b -= n;
}
}

// Return 16^k mod n
//
// Exponentiation with the same approach as above except
// that we binary-expand the exponent instead of a factor.

static unsigned mod_pow16 (unsigned k, unsigned n)
{
unsigned p = 1;
unsigned _16 = 16;

if (n == 1)
return 0;

while (_16 >= n)
_16 -= n;

while (1)
{
if (k % 2 == 1)
p = mod_mul (_16, p, n);

k = k / 2;
if (k == 0)
break;

_16 = mod_mul (_16, _16, n);
}

return p;
}

// Helper for the function below. Return a value in (-2,2) that
// is equivalent to s mod 1.

static float tame (float s)
{
int8_t si = (int8_t) lrintf (s);

if (si <= -2 || si >= 2)
s -= si;

return s;
}

// The finite part mod 1 of sigma_j, i.e. partial sum where the exponent
// of 16 is >= 0. By "mod 1" we always mean "up to some integer",
// i.e. the result needs not to be normalized to [0,1).

static float sigma_a (unsigned n, uint8_t j)
{
float s = 0.0f;

for (unsigned k = n-1; k+1 != 0; k--)
{
unsigned j_8k = j + 8*k;

s += mod_pow16 (n-k, j_8k) / (float) j_8k;

// Cut down the sum and don't let it grow too big.
// The bigger the number grows the less precision is
// left for the fractional part we are interested in.

s = tame (s);

wdt_reset();
}

return s;
}

#define MARGIN 10

static float sigma_b (unsigned n, uint8_t j)
{
float s = 0;
float _16 = 1.0f;

for (unsigned k = n; k <= n + MARGIN; k++)
{
s += _16 / (8*k + j);
_16 /= 16;

wdt_reset();
}

return s;
}

// Compute an approximation of 16^n * sigma(j) mod 1
// where
//
// sigma_j = \sum_0^oo 1 / (16^k * (8k + j))
//
// The sum is split into two parts:
// sigma_a is the finite sum up to n.
// sigma_b is the finite sum from n+1 to oo
// and approximated by a sum from n+1 to n+MARGIN

float sigma (unsigned n, uint8_t j)
{
return sigma_a (n, j) + sigma_b (n, j);
}

// Compute pi * 16^n up to some integer
// using a Bailey-Borwein-Plouffe formula for pi:
//
// pi = 4*sigma_1 - 2*sigma_4 - sigma_5 - sigma_6
//
// with the definition of sigma_j from above. All this
// is explained very nicely in the French wikipedia at
// http://fr.wikipedia.org/wiki/Formule_BBP
//
// For a proof define the power series
//
// sigma_j (x) = \sum x^{8k} / (8k + j)
//
// write the sum as an integral and evaluate it at
// x = sqrt(1/2), see http://www.pi314.net/eng/plouffe.php

float pi_n (unsigned n)
{
float s = 0.0;

for (uint8_t i = 0; i < 4; i++)
{
// j[i] = 1, 4, 5, 6
uint8_t j = i ? i + 3 : 1;

// c[i] = 4, -2, -1, -1
int8_t c = -1;
if (i == 0) c = 4;
if (i == 1) c = -2;

s += c * sigma (n, j);
}

return s;
}

// We computed pi_n = 16^n * pi mod 1.
// Get the first fractional hexadecimal digit by multiplying
// with 16 and extracting digit 0 of the result. Voila!

static uint8_t pi_dig16 (unsigned n)
{
return 15 & lrintf (floorf (16 * pi_n (n)));
}

// Map 0 <= n < 16 to its hexadecimal ASCII digit
// '0', '1', ... 'F'

static uint8_t hexdigit (uint8_t n)
{
n += '0';
return n > '9' ? n + 'A'-'0'-10 : n;
}

int main (void)
{
uart_init();

cput ('\n');
cput ('3');
cput ('.');

// As explained above, 16-bit integers limitate us to moduli <= 2^15.
// The biggest modulus for n is 8n+6 so that for n >= 4096 we expect
// garbage from the implementation if 16-bit integers are used like
// with avr-gcc. In fact, we get garbage for n > 4100.
// It's not exacly 4095 because of the denominators in sigma_a that
// delay the garbage for some values of n.

// Easy going 4000 hex-digits of pi.

for (unsigned n = 0; n < 4000; n++)
{
// Print a line break after every 64 digits. That way the output
// can easily be compared with, e.g. the hexadecimal representation
// of pi from blowfish listed in "First 8366 Hex Digits of PI" from
// http://www.herongyang.com/Cryptography/

if (n % 64 == 0)
cput ('\n');

// Get the n+1-th hexadecimal digit of pi and
// output it as ASCII character.

cput (hexdigit (pi_dig16 (n)));
}

cput ('\n');

return 0;
}

/************************************************************************/
// We are running on ATtiny2313 bare metal, of course.
// Provide some minimalist output routine that writes to UART.
/************************************************************************/

#ifdef __AVR__

// !!! You must have set the fuses appropriately to run the !!!
// !!! controller at desired F_CPU. Defining F_CPU is needed !!!
// !!! to get correct values to set up the UART. !!!
// !!! !!!
// !!! DEFINING F_CPU WILL NOT CHANGE THE FREQUENCY! !!!

void uart_init (void)
{
// Define F_CPU and BAUDRATE depending on your hardware setup.
// For my setup, it's the followin defines in avr-gcc's command line:
// -DF_CPU=22118400 -DBAUDRATE=115200

unsigned ubrr = -.6 + F_CPU / (8L * BAUDRATE);

UBRRH = ubrr >> 8;
UBRRL = ubrr;

// Enable UART transmitter, data mode 8N1, asynchronous.

UCSRA = (1 << U2X) | (1 << TXC);
UCSRB = (1 << TXEN);
UCSRC = (1 << UCSZ1) | (1 << UCSZ0);
}

/////////////////////////////////////////////////////////////////

// Write one char to UART (non-buffered, blocking version).

void uart_putc (char c)
{
while (!(UCSRA & (1 << UDRE)))
wdt_reset();
UDR = c;

#ifdef HOST_WINDOWS
if (c == '\n')
uart_putc ('\r');
#endif // HOST_WINDOWS
}

void exit (int x)
{
(void) x;

while (1)
wdt_reset();
}
#endif // __AVR__
</pre>

== Weblinks ==
<references/>

[[Kategorie:AVR-Projekte]]
[[Kategorie:AVR-Arithmetik]]
[[Kategorie:PC-Programmierung]]