Mikrocontroller.net - Benutzerbeiträge [de]

LED-Fading

2009-09-19T14:51:01Z

Philipp burch: /* Die Kennlinie des Auges genau betrachtet */ Formel ergänzt

== 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 Kennline 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 duch das [http://de.wikipedia.org/wiki/Weber-Fechner-Gesetz Weber-Fechner-Gesetz] beschrieben. Genauere Untersuchungen zur [http://de.wikipedia.org/wiki/Gamma-Korrektur Gammakorrektur] führten jedoch zur [http://de.wikipedia.org/wiki/Stevenssche_Potenzfunktion Stevenschen Potenzfunktion]. Diese beschreibt das menschliche Auge etwas besser. Die Unterschiede sind jedoch marginal. Vorsicht! Der Artikel Gamma-Korrektur in Wikipedia verweist fälschlicherweise auf das Weber-Fechner Gesetz.

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 urprü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>
[[Category:AVR]]
[[Category:Displays und Anzeigen]]

LPC2000

2009-05-18T14:12:24Z

Philipp burch: /* Weblinks */ typos

Die LPC2000 von NXP (ehemals Philips) waren die ersten wegen ihrer einfachen Handhabung hobbytauglichen [[ARM]]-basierten Mikrocontroller. Entsprechend sind auch zum LPC2000 mehr Informationen verfügbar als z.B. zum [[AT91SAM]]7, und man findet leichter Hilfe bei Problemen. Ein weiterer Vorteil des LPC2000 ist der einfach zu benutzende serielle Bootloader, mit dem sich der Controller auch ohne JTAG-Interface einfach programmieren lässt. Ansonsten ist die Hardwareausstattung recht ähnlich im Vergleich zum AT91SAM7. Hervorzuhebende Unterschiede sind das schnellere Flash-ROM des LPC2000, die etwas höhere Taktfrequenz, beim gleichen Gehäuse mehr I/O-Pins und die größere Auswahl von Modellen im Low-End-Bereich (LPC2103).

* 2-64 kB [[RAM|SRAM]].
* bis zu 512 kB [[Flash-ROM]]-Programmspeicher (LPC2138/2148/2368/2378)
* vorinstallierter serieller [[Bootloader]] mit automatischer [[Baud]]rate-Erkennung
* [[JTAG]]-Interface
* ETM Trace-Interface
* 2-4 [[UART]]-Schnittstellen (bei einigen Modellen auch mit allen "Modem"-Leitungen (Handshake, Ring, DTR etc.)
* 1-2 [[SPI]]-Schnittstelle(n), bei einigen Modellen auch SSP-Schnittstelle(n) (erweiterte Konfigurationsmöglichkeiten und Funktionen)
* Hardware-[[I2C]](I²C)-Schnittstelle(n)
* teilw. mit CAN-Schnittstellen
* Mit Ausnahme der ersten Chips LPC2104/5/6 haben alle Typen einen integrierten A/D-Wandlern
* teilw. mit D/A-Wandler (LPC2132/34/36/38, LPC2142/44/46/48)
* 2 32 Bit [[Timer]], zusätzlicher 32-bit [[Timer]] mit 6 [[Pulsweitenmodulation|PWM]]-Ausgängen, RTC, [[Watchdog]]
* bis 75 MHz Taktfrequenz
* [[IC-Gehäuseformen|LQFP48]]-Gehäuse (LPC210x) bis LQFP144 (LPC22xx)
* LPC213x und LPC214x benötigen zum Betrieb 3V
* Für die anderen Typen werden Core-Spannung 1,65-1,95V und IO-Spannung 3,0-3,6V benötigt (d.h. zum Betrieb sind 2 Versorgungsspannungen erforderlich)
* geringe Leistungsaufnahme (ca. 60 mW bei 60 MHz und Endlosschleife)
* 5V-tolerante IOs
* USB 2.0 (LPC214x und LPC23xx/24xx)
* Ethernet MAC (LPC23xx/24xx)
* Jeweils eigene DMA und eigener AHB-Bus für Ethernet, USB und sonstige schnelle Schnittstellen (LPC23xx und LPC24xx)
* RTC (teilweise mit eigenem Oszillator)

== Verwendung des Bootloaders ==

Benötigte Software gibt es unter http://groups.yahoo.com/group/lpc21isp
(Registrierung nötig, Source Code und Binaries in der File Section dieser Gruppe)

# BSL-Jumper setzen
# Reset-Knopf drücken
# lpc21isp starten
#* Linux: lpc21isp programm.hex /dev/ttyS0 115200 14746
#* Windows: lpc21isp programm.hex com1 115200 14746

Die Übertragung des Programms zum Controller sollte jetzt beginnen. Um das Programm zu starten den '''BSL-Jumper entfernen''' und Reset drücken.

Alternativ kann unter MS-Windows das von Philips bereitgestellte "Flash-Tool" oder Flash Magic von Embedded Systems Academy genutzt werden. Diese Programmiersoftware bieten eine grafische Benutzeroberfläche.

Sowohl lpc21isp also auch das Philips-Tool und Flash Magic können Reset und BSL per DTR/RTS-Signal steuern, bei entsprechender Beschaltung auf dem Board muss man somit keine Jumper setzen (vgl. z.B. Schaltpläne der Evaluation-Boards von [http://www.keil.com Keil]).

Eine weitere Alternative ist [http://home.arcor.de/bernhard.michelis/LPC/index.html LPCProg 0.3], welches speziel für auf die Verwendung eines FTDI-232 Chips hin optimiert wurde. Auf der Website gibt es auch ein Layout für einen USB-zu-Seriel-Adapter. Die Software/Hardware ist zu den obigen Programmen Pinkompatibel und kann beliebig damit gemixt werden.

== Allgemeine Hinweise ==
* Der Softwareschutz bei den LPC2104/5/6 ist nicht implementiert (Stand 4/2005). Dies wird Anfang 2007 geändert. Ein Schutz des geistigen Eigentums ist also bei diesen 3 Controllern derzeit nicht gewährleistet. Andere Controller aus der LPC2000-Serie sind davon nicht betroffen.
* Auf vielen (Stand 4/2005) LPC2000 existiert ein Fehler bei der Verwaltung der Interrupt-Flags ("race condition", "timer issue"). Der Fehler und mögliche Abhilfen sind in den Errata von NXP erläutert.
* Die CAN Controller in den LPC2100,2200 sind so gründlich mit Bugs und Designfehlern gespickt, dass letztlich nur ein kleiner Bruchteil der dokumentierten Funktionen nutzbar ist. Die Bugs finden sich im Errata Sheet, die Konstruktionsfehler darf man selber finden.
* Bei Nutzung des SPI-Interfaces im "Master-Mode" ist bei einigen LPC2000-Typen auf die richtige Beschaltung des "Chip-Select"-Pins zu achten (vgl. Manuals und Erratas).
* Viele Fehler in der "ersten Generation" der ICs wurden bei neueren Versionen behoben. Vgl. Datenblätter/Errata zu LPC2xxx/01.
* Bei neueren LPCs (LPC213x/4x) sollte die aktuelle Fassung der NXP ISP-Software genutzt werden (Stand 3/2006: V2.2.2, erhältlich auf der NXP Web-Site). Ältere Versionen funktionieren nicht zuverlässig oder garnicht.
* LPC23xx/24xx werden von der Philips ISP-Software nicht unterstützt. Alternativen: Flashmagic oder lpc21isp.
* Bei Problemen immer auch das Archiv der LPC2000 yahoo-Gruppe absuchen. Dort finden sich, leider oft etwas zerstreut, sehr nützliche Hinweise. Die Anmeldung bei der Gruppe (yahoo-Account erforderlich) gewährt Zugang zum Download-Bereich der Gruppe. Dort finden sich sehr nützliche Beispielprogramme, Libraries und Dokumente.
* Bei Entwicklungen mit der GNU-Toolchain erweisen sich Beispiele von kommerziellen Compiler/IDE-Anbietern, die ebenfalls den GNU-Compiler nutzen, oft als gute Informationsquelle vor allem bei Einstellungen zum Startup-Code oder im Linker-Script. (vgl. u.a. Rowley, Keil, Anglia-Designs)
* siehe auch: [http://www.open-research.org.uk/ARMuC/index.cgi?LPC2100Tips LPC2100-Tips] im ARMuC Wiki (englisch)

== Siehe auch ==

* [[ARM-elf-GCC-Tutorial]]
* [[Linksammlung#ARM|Linksammlung Abschnitt ARM]]
* [[LPC2000-Boards von Olimex]]

== Weblinks ==
* [http://www.standardics.nxp.com/products/lpc2000/all/ Philips / NXP LPC2000]
* [http://groups.yahoo.com/group/lpc2000/ LPC2000 Yahoo Group]
* [http://www.dreamislife.com/arm/ LPC210x ARM7 Microcontroller Tutorial]
* [http://www.dontronics-shop.com/tutorials.html Dontronics Tutorials] u.a. "ARM Cross Development with Eclipse Version 3" von James P. Lynch
* [http://www.hitex.co.uk/arm/lpc2000book/free_downloadpage.html The Insider's Guide To The Philips ARM7-Based Microcontrollers (LPC21xx)] bei http://www.hitex.co.uk
* [http://groups.yahoo.com/group/lpc21isp lpc21isp] - Kommandozeilen-ISP-Tool für Linux und MS-Windows
* [http://www.esacademy.com/software/flashmagic/ Flash Magic] ISP-Tool
* [http://www.pjrc.com/arm/lpc2k_pgm/ LPC2K_PGM] - ISP-Tool mit GUI für Linux/GTK
* [http://www.sandring-systems.de/index.php5?lang=en&p=lf4l lpcflash4linux] - ISP-Tool für Linux (Kommandozeile)
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/ ARM projects] - LPC2000-Projekte und -Beispiele von Martin Thomas
* [http://www.jandspromotions.com/philips2005/DE-list.htm LPC2138 Design Contest] - Viele Beispiele mit Hard- and Software
* [http://www.ixbat.de/index.php?page_id=94 LPC2103 unter Linux entwickeln] - LED blink mit gcc unter Linux
* [http://www.thegnar.org/nav/LPCgettingstarted.html Bringing up the LPC-P212x] - Bauen einer Toolchain mit Newlib, ISP, JTAG
* [http://home.arcor.de/bernhard.michelis/LPC/index.html LPCProg 0.3] - Geschwindigkeitsoptimierte Version für USB-zu-Seriell-Wandler, Kommandozeilen-ISP-Tool für MS-Windows; Einfaches Demo-Board verfügbar

[[Category:ARM]] [[Category:Mikrocontroller]]
__NOTOC__

Versorgung aus einer Zelle

2009-05-17T08:01:06Z

Philipp burch: /* ICs */ ATtiny43U ergänzt

Bei batteriebetriebenen Anwendungen stellt sich oft das Problem der Spannungsversorgung. Darauf soll hier näher eingegangen werden.

= Erste Ideen =

=== 9V-Block mit Linearregler ===

Die erste Idee, einen 9V-Block herzunehmen und einen Linearregler a la 7805 hinzuhängen mag zwar einfach erscheinen, hat aber jedoch einen extrem schlechten Wirkungsgrad (bei Runterregelung auf 5V muss der Regler immerhin 45% verbraten => 55% Wirkungsgrad, bei 3,3V nur noch 36%), und auch der Platzbedarf ist vergleichsweise alles andere als gering. Auch braucht der klassische 7805 ca. 5mA für sich selber. Das ist meist mehr als ein Mikrocontroller! Bei weitem besser sind hier Low Power Linearregler wie z.B. der [http://www.national.com/mpf/LP/LP2950.html LP2950]. Dieser benötigt ca. 75μA. Als Extrembeispiel sei hier der [http://focus.ti.com/docs/prod/folders/print/tps71501.html TPS715xx] von [http://www.ti.com Texas Instuments] genannt, der mit unglaublichen 3,2 μA auskommt!
Statt des Linearreglers könnte man natürlich auch einen Step-Down-Schaltregler benutzen, dann hätte man zumindest einen besseren Wirkungsgrad von 80-90%. Last but not least muss man auch sagen, dass die Energiedichte von 9V-Blocks eher gering ist im Verhältnis zu Mignonzellen.

http://data.energizer.com/ (Auf Technical Info oben rechts clicken, dann die Batteriefamilie links auswählen, z.B. Alkaline)

{| border ="1"
|-
! width="18%" | Batterietyp
! Volumen [cm³]
! Kapazität [mAh]
! mittlere Ausgangs- spannung [V]
! Energiegehalt [mWh]
! Energiedichte [mWh/cm³]
! Masse [g]
|-
|9V Alkaline
| align="center" | 21,1
| align="center" | 625
| align="center" | 7
| align="center" | 4375
| align="center" | 207
| align="center" | 45,6
|-
|Mono Alkaline [D]
| align="center" | 56
| align="center" | 20500
| align="center" | 1,3
| align="center" | 26650
| align="center" | 475
| align="center" | 148
|-
|Baby Alkaline [C]
| align="center" | 26,9
| align="center" | 8350
| align="center" | 1,3
| align="center" | 10855
| align="center" | 404
| align="center" | 26,2
|-
|Mignon Alkaline [AA]
| align="center" | 8,1
| align="center" | 2850
| align="center" | 1,3
| align="center" | 3705
| align="center" | 457
| align="center" | 23
|-
|Micro Alkaline [AAA]
| align="center" | 3,8
| align="center" | 1250
| align="center" | 1,3
| align="center" | 1625
| align="center" | 428
| align="center" | 11,5
|-
|Lithiumzelle, 2032
| align="center" | 1
| align="center" | 240
| align="center" | 2,9
| align="center" | 496
| align="center" | 653
| align="center" | 3
|}

=== Vier Mignonzellen mit LowDrop-Linearregler ===

Als weitere Möglichkeit wären vier Mignonzellen (= 6V) zu verwenden und dahinter einen LowDrop-Linearregler zu schalten. Der Platzbedarf ist immer noch gross, der Wirkungsgrad besser (ca 90%). Allerdings bleibt ein Nachteil: Die Batterien werden nie wirklich geleert, nichtmal annähernd, weil sie bereits bei 1,25V pro Zelle zusammen gerade noch 5V ergeben, der Regler aber auch gern noch seinen Teil abhaben will (Dropout Voltage). Zu bedenken sind hierbei die Entladekennlinien von Batterien, oder noch schlimmer die von Akkus.

{| border="1"
|+ Sparsame Spannungsregler
|-
!Bezeichnung
!Ausgangsspannung [V]
!Stromverbrauch [uA]
|-
|LP2950
| align="center" |3/3,3/5
| align="center" |75
|-
|LF33
| align="center" |3,3
| align="center" |500
|-
|LF50
| align="center" |5
| align="center" |500
|-
|TPS715
| align="center" |1,2..5
| align="center" |3.2
|}

=== Drei Mignonzellen ohne Spannungsregler ===

Die meisten modernen [[Mikrocontroller]] haben einen sehr weiten Versorgungsspannungsbereich, teilweise von 1,8V bis 5,5V. Damit ist es möglich, sie direkt mit drei in Reihe geschalteten Zellen zu betreiben. Während der Entladung sinkt die Betriebsspannung (3x0,8V=2,4V), was der Mikrocontroller aber verkraftet, sofern er nicht mit maximalem Takt läuft. Wenn keine weiteren ICs in der Schaltung benötigt werden, oder diese ebenso tolerant bezüglich einer veränderlichen Versorgungsspannung sind, ist diese Methode die einfachste und günstigste (100% Wirkungsgrad). Vor allem bei [[Ultra low power | Low Power]] Anwendungen mit [[Sleep Mode]] wird hier kein Mikroampere für einen Spannungsregler verschwendet.

=== Lithiumzelle ===

Diese haben eine sehr geringe Selbstentladung und hohe Spannung von typisch 3V. Damit kann man einen sparsamen Mikrocontroller betreiben. Meist werden diese Zellen für Echtzeituhren und zum Datenerhalt von RAMs genutzt, da hier nur sehr geringe Ströme im Mikroamperebereich benötigt werden. Darauf sind diese Zellen ausgelegt. Aus den meisten kann man nur einige mA entnehmen, bei 10mA und mehr sinkt die verfügbare Kapazität rapide.

Um ein Gerät nur im Notfall mit einer Lithiumzelle zu betreiben (Pufferbetrieb, Netzausfallsicherung), braucht man eine unterbrechungsfrei Umschaltung zwischen Netzteilbetrieb und Batteriebetrieb. Kritisch ist das vor allem für die Lithiumzelle (damit ist kein Lithiumakku gemeint!), da diese nicht aufgeladen werden darf. Sie wird dabei mit heftiger Reaktion zerstört! Eine einfache Schaltung ist die Nutzung von zwei Schottkydioden zur Entkopplung von Batterie und Netzteil wie es im Artikel ''Speicher'' über [[Speicher#EEPROM_Schreibzugriffe_minimieren | EEPROM]] gezeigt wird. Der Nachteil dieser Lösung ist der relativ hohe Spannungsabfall von 300..400mV über den Dioden. Besser ist der Einsatz eines P-Kanal MOSFETs zum Schalten der Batteriespannung. Dadurch kann der Spannungsabfall auf wenige Millivolt gesenkt werden. Die Schaltung dazu ist im diesem [http://www.mikrocontroller.net/topic/72275#591483 Beitrag] zu finden.

= Bessere Lösungsansätze =

Wie man sehen kann sind oben dargestellte Methoden nur bedingt zufriedenstellend. Vor allem der Platzbedarf dürfte ein KO-Kriterium sein. Besser wäre es nur eine oder zwei Zellen zu verwenden.

== Step-Up-Schaltregler ==

Step-Up-Schaltregler bringen die Spannung, wie der Name schon sagt, 'einen Schritt nach oben'. Ideal also um aus 1,5V oder 3V z.B. 5V zu machen. Desweiteren sind sie auch geeignet, um höhere Ströme (bis 0,5A, je nach Aufbau und Spule) zu entnehmen. Das Arbeitsprinzip bei Step-Up-Schaltreglern ist immer gleich: Eine Spule wird ständig an- und abgeschaltet und durch Eigeninduktion eine höhere Spannung erzeugt. Um einen Step-Up-Schaltregler aufzubauen, gibt es verschiedene Möglichkeiten:

=== ICs ===

'''Vorteile:'''

* zuverlässig
* meist wenig Außenbeschaltung nötig
* geringe Größe, auch der Spule, da hohe Schaltfrequenzen verwendet werden

'''Nachteile:'''

* teuer, vor allem die ab 1V arbeiten
* teilweise schwer zu bekommen

'''Auflistung von Schaltregler-ICs:'''

[[Kategorie:Bauteile]]
* [http://www.tranzistoare.ro/datasheets/2300/57048_DS.pdf LT1073-5] (PDF): 1V (1 Zelle) auf 5V, 40mA
* [http://www.ortodoxism.ro/datasheets/lineartechnology/lt1301.pdf LT1301] (PDF): 2V (2 Zellen) auf 5V oder 12V, 250mA (erhältlich bei Conrad)
* [http://www.ortodoxism.ro/datasheets/lineartechnology/lt1302.pdf LT1302] (PDF): 2V (2 Zellen) auf 5V oder 12V, 250mA (erhältlich bei Reichelt und Conrad)
* [http://www.ortodoxism.ro/datasheets/lineartechnology/3401fa.pdf LTC3401] (PDF) - ziemlich geniales Teil, weil es mit hoher Schaltfrequenz arbeitet, dadurch kann eine kleine Spule verwendet und ein sehr hoher Wirkungsgrad erzielt werden.
* [http://www.linear.com/pc/downloadDocument.do?navId=H0,C1,C1003,C1042,C1031,C1060,P13393,D9338 LTC3525-5] (PDF)
* [http://www.ortodoxism.ro/datasheets/maxim/MAX1722-MAX1724.pdf MAX1724] (PDF)
* [http://www.ortodoxism.ro/datasheets/maxim/MAX1674-MAX1676.pdf MAX1674] (PDF) - bis zu ein Ampere, bei einer Zelle ist aber bei 100mA Schluss, und das auch nur, wenn die Spannung beim "Hochfahren" höher war und die richtige Spule verwendet wird
* [http://www.sipex.com/Files/DataSheets/sp6648.pdf SP6648] (PDF)
* [http://focus.ti.com/lit/ds/symlink/tps61200.pdf TPS61200/201/202] (PDF) - 1,8..5,5V out, Quellspannung bis herunter auf 0,3V, ?>90%, 0,5mm Pinabstand, 3,15*3,15mm
* TPS6030x, TPS6031x, [http://www.ortodoxism.ro/datasheets/lineartechnology/15023f.pdf LTC1502-3.3] (PDF) (typ. 3,x V bei 15-20 mA)
* [http://www.ortodoxism.ro/datasheets2/7/0y1y62f9lzj79rs7uuf28jq4xtwy.pdf LM2621] (PDF)
* [[MC34063]]
* [http://atmel.com/dyn/products/product_card.asp?part_id=4523 ATtiny43U] - AVR-Microcontroller, der einen Boost-Converter eingebaut hat und damit eine Batterie bis auf 0.7V aussaugen kann.

=== Diskrete Schaltungen ===

'''Vorteile:'''
* größtmögliche Anpassung an Verwendungszweck
* teilweise schon mit Standardhühnerfutter aufzubauen

'''Nachteile:'''

* kompliziert
* nicht garantierte Funktion (z.B. wegen gepulster Gleichspannung)
* schlechte EMV-Eigenschaften

'''Auflistung diskreter Step-Up-Schaltregler:'''

* http://www.elektronik-kompendium.de/forum/forum_entry.php?id=17395
* http://www.mikrocontroller.net/topic/73532#604774
* [http://www.nxp.com/acrobat_download/applicationnotes/AN10218_1.pdf NXP AN10218] (PDF) (Philips LPC900 microcontroller) single cell power supply
* [http://www.b-kainka.de/bastel36.htm Der LED-Spannungswandler] von B. Kainka
* [http://www.bigclive.com/joule.htm Make a Joule Thief] - Versorgung einer LED aus einer 1,5V Zelle
* Diskussionen von '''Joule-Thief''' Schaltungen im Forum
** [http://www.mikrocontroller.net/topic/47224 Sensor autark betreiben mit einem Thermogenerator]
** [http://www.mikrocontroller.net/topic/55041 LEDs mit Akku(s) effizient betreiben]
** [http://www.mikrocontroller.net/topic/38163 Wie kann man eine Knopfzellenspannung um ca. 1 Volt erhöhen]
** [http://www.mikrocontroller.net/topic/62158 Spannungsanhebung 1,2V -> 2V]
** [http://www.mikrocontroller.net/topic/77154 Step-Up Transistorschaltung für LED Lampe]
** [http://www.mikrocontroller.net/topic/56523 3x 2,9V LEDs mit 2xAAA versorgen]
** [http://www.mikrocontroller.net/topic/55962 Gibt es eine Möglichkeit LEDs bei 1V zu betreiben]
** [http://cappels.org/dproj/ledpage/leddrv.htm#Rusty_Nail_Night_Light Rusty Nail Night Light]

== Ladungspumpen ==

Ladungspumpen erhöhen die Spannung, indem sie Kondensatoren zyklisch parallel laden, umpolen und in Reihe entladen.

'''Vorteile:'''
* geringer Stromverbrauch, deshalb für Low-Power-Anwendungen gut geeignet
* keine Spulen, deshalb kein magnetisches Störfeld

'''Nachteile:'''
* nur geringe Ausgangsströme möglich (100mA)
* ICs nur für höhere Eingangspannungen erhältlich, ab 3V
* Teilweise starke Strompulse beim Umladen der Kondensatoren, womit empfinfdliche Analogschaltungen gestört werden können (Funkempfänger etc.)

'''Auflistung von Ladungspumpen:'''
* TPS60300 - Vin 0,9-1,8V
* TPS60100 - Vin 1,8-3,6V (200mA)
* MAX1759 - Vin 1,6-5,5V (2-3 Zellen)

= Forumsbeiträge zum Thema =

*[http://www.mikrocontroller.net/topic/45101#new 3v3 Volt aus einer 1v2 Volt Zelle]
*[http://www.mikrocontroller.net/topic/18789#new Stromversorgung aus einer Zelle]
*[http://www.mikrocontroller.net/topic/73532#new Step-Up Mignon zu 5V]

= Externe Links =

* [http://www.powerdesigners.com/InfoWeb/ Powerdesigners InfoWeb] - Free tools, resources and education for power electronics designers and students (engl.)
* http://www.ti.com/power
* [http://focus.ti.com/lit/an/slaa105/slaa105.pdf TI Application Report SLAA 105] Simple 1.5-V Boost Converter for MSP430
* http://www.maxim-ic.com/products/power/
* 2-6V DC nach 5V DC Konverter auf der Basis des '''LT1302''' als [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?cPath=83&products_id=195 Fertigmodul] bzw. [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?products_id=194 Platine] (Shop robotikhardware.de)

[[Kategorie:Bauteile]]

AVR-Tutorial: UART

2009-04-19T16:45:38Z

Philipp burch: /* UART konfigurieren */ Anmerkung über UDRE/TXC-Problematik ergänzt

Wie viele andere Controller besitzen die meisten AVRs einen '''[[UART]]''' ('''U'''niversal '''A'''synchronous '''R'''eceiver and '''T'''ransmitter). Das ist eine serielle Schnittstelle, die meistens zur Datenübertragung zwischen Mikrocontroller und PC genutzt wird. Zur Übertragung werden zwei Pins am Controller benötigt: '''TXD''' und '''RXD'''. Über '''TXD''' ("Transmit Data") werden Daten gesendet, '''RXD''' ("Receive Data") dient zum Empfang von Daten.

== Hardware ==

Um den UART des Mikrocontrollers zu verwenden, muss der Versuchsaufbau um folgende Bauteile erweitert werden:

[[Bild:AVR-RS232.png|640px]]

Auf dem Board vom [http://shop.mikrocontroller.net/ Shop] sind diese Bauteile bereits enthalten, man muss nur noch die Verbindungen zwischen MAX232 (IC2) und AVR herstellen wie im [http://shop.mikrocontroller.net/images/avrplat28-app.jpg Bild] zu sehen.

* Der MAX232 ist ein [[Pegelwandler]], der die -12V/+12V Signale an der seriellen Schnittstelle des PCs zu den 5V/0V des AVRs kompatibel macht.
* C1 ist ein kleiner Keramikkondensator, wie er immer wieder zur Entkopplung der Versorgungsspannungen an digitalen ICs verwendet wird.
* Die vier Kondensatoren C2..C5 sind Elektrolytkondensatoren (Elkos). Auf die richtige Polung achten! Minus ist der Strich auf dem Gehäuse. Der exakte Wert ist hier relativ unkritisch, in der Praxis sollte alles von ca. 1µF bis 47µF mit einer Spannungsfestigkeit von 16V und höher funktionieren.
* X1 ist ein weiblicher 9-poliger SUB-D-Verbinder.
* Die Verbindung zwischen PC und Mikrocontroller erfolgt über ein 9-poliges Modem-Kabel (also ein ''Verlängerungskabel'', '''kein [http://de.wikipedia.org/wiki/Nullmodem-Kabel Nullmodem]-Kabel!)''', das an den seriellen Port des PCs angeschlossen wird. Bei einem Modem-Kabel sind die Pins 2 und 3 des einen Kabelendes mit den Pins 2 und 3 des anderen Kabelendes durchverbunden. Bei einem Nullmodem-Kabel sind die Leitungen gekreuzt, sodass Pin 2 von der einen Seite mit Pin 3 auf der anderen Seite verbunden ist und umgekehrt.
* Als Faustregel kann man annehmen: Befinden sich an den beiden Enden des Kabels die gleiche Art von Anschlüssen (Männchen = Stecker; Weibchen = Buchse), dann benötigt man ein gekreuztes, also ein Nullmodem-Kabel. Am PC-Anschluss selbst befindet sich ein Stecker, also ein Männchen, sodaß am Kabel auf dieser Seite eine Buchse (also ein Weibchen) sitzen muss. Da am AVR laut obigem Schaltbild eine Buchse verbaut wird, muss daher an diesem Ende des Kabels ein Stecker sitzen. Das Kabel hat daher an einem Ende einen Stecker und am anderen Ende eine Buchse und ist daher ein normales Modem-Kabel ( = nicht gekreuzt).

[[Bild:USART_Kabel.gif]]

== Software ==

=== UART konfigurieren ===

Als erstes muss die gewünschte Baudrate im Register '''UBRR''' festgelegt werden. Der in dieses Register zu schreibende Wert errechnet sich nach der folgenden Formel:

<math>UBRR = \frac {Taktfrequenz} { 16 \cdot Baudrate } - 1</math>

Beim AT90S4433 kann man den Wert direkt in das Register '''UBRR''' laden, beim ATmega8 gibt es für '''UBRR''' zwei Register: '''UBRRL''' (Low-Byte) und '''UBRRH''' (High-Byte). Im Normalfall steht in '''UBRRH''' 0, da der berechnete Wert kleiner als 256 ist und somit in '''UBRRL''' alleine passt. Beachtet werden muss, dass das Register '''UBRRH''' vor dem Register '''UBRRL''' beschrieben werden muss. Der Schreibzugriff auf '''UBRRL''' löst das Neusetzen des internen Taktteilers aus.

----

'''WICHTIGER HINWEIS!'''

Auf Grund permanent wiederkehrender Nachfrage sei hier '''AUSDRÜCKLICH''' darauf hingewiesen, dass bei Verwendung des UART im asynchronen Modus dringend ein Quarz oder Ouarzoszillator verwendet werden sollte! Der interne RC-Oszillator der AVRs ist recht ungenau! Damit kann es in Ausnahmefällen funktionieren, muss es aber nicht! Auch ist der interne Oszillator temperaturempfindlich. Damit hat man dann den schönen Effekt, dass eine UART-Schaltung die im Winter noch funktionierte, im Sommer den Dienst verweigert.

Außerdem muss bei der Berechnung von '''UBRR''' geprüft werden, ob mit der verwendeten Taktfrequenz die gewünschte Baudrate mit einem Fehler von <1% generiert werden kann. Das Datenblatt bietet hier sowohl die Formel als auch Tabellen unter der Überschrift des U(S)ART an.

<math> Fehler_{Baudrate}[%] = (\frac{UBRR_{gerundet}+1}{UBRR_{genau}+1} -1 ) \cdot 100</math>

Siehe auch [[Baudratenquarz]]

Wer es ganz einfach haben will, nimmt die folgenden Macros. Die rechnen sogar den Fehler aus und brechen die Assemblierung ggf. ab. Das ist dann praktisch idiotensicher.

<avrasm>
.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif
</avrasm>

Wer dennoch den internen RC-Oszillator verwenden will, muss diesen kalibrieren. Näheres findet man dazu im Datenblatt, Stichwort Register OSCCAL.
----

Um den Sendekanal des UART zu aktivieren, muss das Bit '''TXEN''' im UART Control Register '''UCSRB''' auf 1 gesetzt werden.

Danach kann das zu sendende Byte in das Register '''UDR''' eingeschrieben werden - vorher muss jedoch sichergestellt werden, dass das Register leer ist, die vorhergehende Übertragung also schon abgeschlossen wurde. Dazu wird getestet, ob das Bit '''UDRE''' ("UART Data Register Empty") im Register '''UCSRA''' auf 1 ist.

Genaueres über die UART-Register findet man im Datenblatt des Controllers.

An dieser Stelle sei noch folgendes angemerkt: Das '''UDRE'''-Bit sagt nichts darüber aus, ob der Controller immer noch damit beschäftigt ist, Daten zu senden. Da das Senderegister mehrfach gepuffert ist, wird '''UDRE''' bereits gesetzt, obwohl das letzte Zeichen den AVR noch nicht komplett verlassen hat. Dies kann insbesondere bei der Verwendung von Sleep-Modes ein Problem werden, wenn der Controller schlafen gelegt wird, bevor das letzte Zeichen versendet wurde, da dies gezwungenermassen zu einem Frame-Error beim Empfänger führen wird. Um sicher zu gehen, dass der UART nicht mehr beschäftigt ist, kann das Bit '''TXC''' ("UART Transmit complete") getestet werden. Dieses wird jedoch wirklich erst nach dem Senden eines Zeichens gesetzt, beinhaltet also auch nach dem Systemstart eine 0, obwohl der Controller nichts sendet.

Der ATmega8 bietet noch viele weitere Optionen zur Konfiguration des UARTs, aber für die Datenübertragung zum PC sind im Normalfall keine anderen Einstellungen notwendig.

=== Senden von Zeichen ===

Das Beispielprogramm überträgt die Zeichenkette "Test!" in einer Endlosschleife an den PC.

'''Hinweis'''

Wenn man das nachfolgende Programm laufen lässt und Hyperterminal startet, scheint es problemlos zu funktionieren. Wenn man aber das RS232 Kabel zwischenzeitlich abzieht und wieder ansteckt wird es oft passieren, dass nur noch wirre Zeichen auf dem PC erscheinen. Das liegt daran, dass der PC aus einem ununterbrochen Zeichenstrom nicht den Anfang eines Zeichens erkennen kann. Darum muss in solchen Fällen periodisch eine kleine Pause von der Länge mindestens eines Zeichens eingelegt werden, damit der PC sich wieder synchronisieren kann.

Die folgenden Beispiele sind für den ATmega8 geschrieben.

<avrasm>
.include "m8def.inc"

.def temp = r16 ; Register für kleinere Arbeiten
.def zeichen = r17 ; in diesem Register wird das Zeichen an die
; Ausgabefunktion übergeben

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB,TXEN ; TX aktivieren

loop:
ldi zeichen, 'T'
rcall serout ; Unterprogramm aufrufen
ldi zeichen, 'e'
rcall serout ; Unterprogramm aufrufen
ldi zeichen, 's'
rcall serout ; ...
ldi zeichen, 't'
rcall serout
ldi zeichen, '!'
rcall serout
ldi zeichen, 10
rcall serout
ldi zeichen, 13
rcall serout
rcall sync
rjmp loop

serout:
sbis UCSRA,UDRE ; Warten bis UDR für das nächste
; Byte bereit ist
rjmp serout
out UDR, zeichen
ret ; zurück zum Hauptprogramm

; kleine Pause zum Synchronisieren des Empfängers, falls zwischenzeitlich
; das Kabel getrennt wurde

sync:
ldi r16,0
sync_1:
ldi r17,0
sync_loop:
dec r17
brne sync_loop
dec r16
brne sync_1
ret
</avrasm>

Der Befehl '''rcall serout''' ruft ein kleines Unterprogramm auf, das zuerst wartet bis das Datenregister '''UDR''' von der vorhergehenden Übertragung frei ist, und anschließend das in zeichen (=r17) gespeicherte Byte an '''UDR''' ausgibt.

Bevor serout aufgerufen wird, wird zeichen jedesmal mit dem ASCII-Code des zu übertragenden Zeichens geladen (so wie in Teil 4 bei der LCD-Ansteuerung). Der Assembler wandelt Zeichen in einfachen Anführungsstrichen automatisch in den entsprechenden ASCII-Wert um. Nach dem Wort "Test!" werden noch die Codes 10 (New Line) und 13 (Carriage Return) gesendet, um dem Terminalprogramm mitzuteilen, dass eine neue Zeile beginnt.

Eine Übersicht aller ASCII-Codes gibt es auf [http://www.asciitable.com/ www.asciitable.com].

Die Berechnung der Baudrate wird übrigens nicht im Controller während der Programmausführung durchgeführt, sondern schon beim Assemblieren, wie man beim Betrachten der Listingdatei feststellen kann.

Zum Empfang muss auf dem PC ein Terminal-Programm wie z.B. HyperTerminal gestartet werden. Der folgende Screenshot zeigt, welche Einstellungen im Programm vorgenommen werden müssen:

http://www.mikrocontroller.net/images/hyperterminal.gif

Linux-Benutzer können das entsprechende Device (z.B. /dev/ttyS0) mit stty konfigurieren und mit cat die empfangenen Daten anzeigen oder ein Terminalprogramm wie minicom nutzen.

=== Senden von Zeichenketten ===

Eine bequemere Methode um längere Zeichenketten (Strings) zu übertragen ist hier zu sehen. Dabei werden die Zeichenketten im Flash gespeichert. Als Abschluss des Strings wird der Wert 0x00 genutzt, so wie auch in der Programmiersprache C.

<avrasm>
.include "m8def.inc"

.def temp = r16 ; Register für kleinere Arbeiten
.def zeichen = r17 ; in diesem Register wird das Zeichen an die
; Ausgabefunktion übergeben

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; hier geht unser Programm los

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB,TXEN ; TX aktivieren

loop:
ldi zl,low(my_string*2); ; Z Pointer laden
ldi zh,high(my_string*2);
rcall serout_string
rjmp loop

; Ausgabe eines Strings aus dem Flash

serout_string:
lpm ; nächstes Byte aus dem Flash laden
and r0,r0 ; = Null?
breq serout_string_ende ; wenn ja, -> Ende
serout_string_wait:
sbis UCSRA,UDRE ; Warten bis UDR für das nächste
; Byte bereit ist
rjmp serout_string_wait
out UDR, r0
adiw zl:zh,1 ; Zeiger erhöhen
rjmp serout_string ; nächstes Zeichen bearbeiten
serout_string_ende:
ret ; zurück zum Hauptprogramm

; Hier wird jetzt der String definiert und im Flash gespeichert

my_string: .db "Test!",10,13,0
</avrasm>

=== Empfangen von Zeichen per Polling===

Der AVR kann nicht nur Daten seriell senden, sondern auch empfangen. Dazu muss man, nachdem die Baudrate wie oben beschrieben eingestellt wurde, das Bit '''RXEN''' setzen.

Sobald der UART ein Byte über die serielle Verbindung empfangen hat, wird das Bit '''RXC''' im Register '''UCSRA''' gesetzt, um anzuzeigen, dass ein Byte im Register '''UDR''' zur Weiterverarbeitung bereitsteht. Sobald es aus '''UDR''' gelesen wurde, wird '''RXC''' automatisch wieder gelöscht, bis das nächste Byte angekommen ist.

Das erste einfache Testprogramm soll das empfangene Byte auf den an Port D angeschlossenen LEDs ausgeben. Dabei sollte man daran denken, dass PD0 (RXD) bereits für die Datenübertragung zuständig ist, so dass das entsprechende Bit im Register PORTD keine Funktion hat und damit auch nicht für die Datenanzeige verwendet werden kann.

Nachdem der UART konfiguriert ist, wartet das Programm einfach in der Hauptschleife darauf, dass ein Byte über den UART ankommt (z.B. indem man im Terminalprogramm ein Zeichen eingibt), also '''RXC''' gesetzt wird. Sobald das passiert, wird das Register '''UDR''', in dem die empfangenen Daten stehen, nach temp eingelesen und an den Port D ausgegeben.

<avrasm>
.include "m8def.inc"

.def temp = R16

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Port D = Ausgang

ldi temp, 0xFF
out DDRD, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB, RXEN ; RX (Empfang) aktivieren

receive_loop:
sbis UCSRA, RXC ; warten bis ein Byte angekommen ist
rjmp receive_loop
in temp, UDR ; empfangenes Byte nach temp kopieren
out PORTD, temp ; und an Port D ausgeben.
rjmp receive_loop ; zurück zum Hauptprogramm
</avrasm>

=== Empfangen von Zeichen per Interrupt ===

Dieses Programm lässt sich allerdings noch verfeinern. Statt in der Hauptschleife auf die Daten zu warten, kann man auch veranlassen dass ein Interrupt ausgelöst wird, sobald ein Byte angekommen ist. Das sieht in der einfachsten Form so aus:

<avrasm>
.include "m8def.inc"

.def temp = R16

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

.org 0x00
rjmp main

.org URXCaddr ; Interruptvektor für UART-Empfang
rjmp int_rxc

; Hauptprogramm

main:

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Port D = Ausgang

ldi temp, 0xFF
out DDRD, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB, RXCIE ; Interrupt bei Empfang
sbi UCSRB, RXEN ; RX (Empfang) aktivieren

sei ; Interrupts global aktivieren

loop:
rjmp loop ; Endlosschleife

; Interruptroutine: wird ausgeführt sobald ein Byte über das UART empfangen wurde

int_rxc:
push temp ; temp auf dem Stack sichern
in temp, UDR ; empfangenes Byte lesen,
; dadurch wird auch der Interrupt gelöscht
out PORTD, temp ; Daten ausgeben
pop temp ; temp wiederherstellen
reti ; Interrupt beenden
</avrasm>

Diese Methode hat den großen Vorteil, dass das Hauptprogramm (hier nur eine leere Endlosschleife) andere Dinge erledigen kann, während der Controller Daten empfängt. Auf diese Weise kann man mehrere Aktionen quasi gleichzeitig ausführen, da das Hauptprogramm nur kurz unterbrochen wird, um die empfangenen Daten zu verarbeiten.

Probleme können allerdings auftreten, wenn in der Interruptroutine die gleichen Register verwendet werden wie im Hauptprogramm, da dieses ja an beliebigen Stellen durch den Interrupt unterbrochen werden kann. Damit sich aus der Sicht der Hauptschleife durch den Interruptaufruf nichts ändert, müssen alle in der Interruptroutine geänderten Register am Anfang der Routine gesichert und am Ende wiederhergestellt werden. Das gilt vor allem für das CPU-Statusregister ('''SREG''')! Sobald ein einziger Befehl im Interrupt ein einziges Bit im SREG beeinflusst, muss das SREG gesichert werden. Das ist praktisch fast immer der Fall, nur in dem ganz einfachen Beispiel oben ist es überflüssig, weil die verwendeten Befehle das SREG nicht beeinflussen. In diesem Zusammenhang wird der [[Stack]] wieder interessant. Um die Register zu sichern, kann man sie mit '''push''' oben auf den Stapel legen und am Ende wieder in der umgekehrten Reihenfolge(!) mit '''pop''' vom Stapel herunternehmen.

Im folgenden Beispielprogramm werden die empfangenen Daten nun nicht mehr komplett angezeigt. Stattdessen kann man durch Eingabe einer 1 oder einer 0 im Terminalprogramm eine LED (an PB0) an- oder ausschalten. Dazu wird das empfangene Byte in der Interruptroutine mit den entsprechenden ASCII-Codes der Zeichen 1 und 0 (siehe [http://www.asciitable.com/ www.asciitable.com]) verglichen.

Für den [[AVR-Tutorial:_Vergleiche|Vergleich]] eines Registers mit einer Konstanten gibt es den Befehl '''cpi register, konstante'''. Das Ergebnis dieses Vergleichs kann man mit den Befehlen '''breq label''' (springe zu label, wenn gleich) und '''brne label''' (springe zu label, wenn ungleich) auswerten.

<avrasm>
.include "m8def.inc"

.def temp = R16

.equ F_CPU = 4000000 ; Systemtakt in Hz
.equ BAUD = 9600 ; Baudrate

; Berechnungen
.equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden
.equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate
.equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille

.if ((BAUD_ERROR>10) || (BAUD_ERROR<-10)) ; max. +/-10 Promille Fehler
.error "Systematischer Fehler der Baudrate grösser 1 Prozent und damit zu hoch!"
.endif

.org 0x00
rjmp main

.org URXCaddr
rjmp int_rxc

; Hauptprogramm
main:

; Stackpointer initialisieren

ldi temp, LOW(RAMEND)
out SPL, temp
ldi temp, HIGH(RAMEND)
out SPH, temp

; Port B = Ausgang

ldi temp, 0xFF
out DDRB, temp

; Baudrate einstellen

ldi temp, HIGH(UBRR_VAL)
out UBRRH, temp
ldi temp, LOW(UBRR_VAL)
out UBRRL, temp

; Frame-Format: 8 Bit

ldi temp, (1<<URSEL)|(3<<UCSZ0)
out UCSRC, temp

sbi UCSRB, RXCIE ; Interrupt bei Empfang
sbi UCSRB, RXEN ; RX (Empfang) aktivieren

sei ; Interrupts global aktivieren

loop:
rjmp loop ; Endlosschleife

; Interruptroutine: wird ausgeführt sobald ein Byte über das UART empfangen wurde

int_rxc:
push temp ; temp auf dem Stack sichern
in temp, sreg ; SREG sichern
push temp

in temp, UDR ; UART Daten lesen
cpi temp, '1' ; empfangenes Byte mit '1' vergleichen
brne int_rxc_1 ; wenn nicht gleich, dann zu int_rxc_1
cbi PORTB, 0 ; LED einschalten, low aktiv
rjmp int_rxc_2 ; Zu int_rxc_2 springen
int_rxc_1:
cpi temp, '0' ; empfangenes Byte mit '0' vergleichen
brne int_rxc_2 ; wenn nicht gleich, dann zu int_rxc_2
sbi PORTB, 0 ; LED ausschalten, low aktiv
int_rxc_2:

pop temp
out sreg, temp ; SREG wiederherstellen
pop temp ; temp wiederherstellen
reti
</avrasm>

== Weblinks ==
* [http://www.wormfood.net/avrbaudcalc.php WormFood's AVR Baud Rate Calculator] online.

{{Navigation_zurückhochvor|
zurücktext=Mehrfachverzweigung|
zurücklink=AVR-Tutorial: Mehrfachverzweigung|
hochtext=Inhaltsverzeichnis|
hochlink=AVR-Tutorial|
vortext=Speicher|
vorlink=AVR-Tutorial: Speicher}}

[[Category:AVR]][[Category:AVR-Tutorial]]

Wellenwiderstand

2009-04-18T11:01:10Z

Philipp burch: Typo

== Einleitung ==

Schnelle Digitalschaltkreise bzw. hochfrequente Analogschaltungen stellen erhöhte Anforderungen an die Verbindungsleitungen zwischen ICs und Baugruppen. Wo ein langsamer CMOS-Baustein der 4000 Serie mit ein paar Megahertz noch problemlos auf dem Steckbrett mit wilder Klingeldrahtverkabelung funktioniert, dort versagt ein moderner, schneller IC seinen Dienst. Ähnliches passiert auf geätzten Leiterplatten. Nicht nur die Packungsdichte der Gehäuse, auch die immer kürzer werdenden Schaltzeiten der Signale verlangen mehr und mehr einen durchdachten, hochfrequenzgerechten Aufbau mit zwei, vier oder mehr Lagen. Die Verbindungsleitungen, welche bei niedrigen Frequenzen praktisch nicht auffallen, sind plötzlich sichtbare Bauelemente, welche die zwei wichtigen Parameter Wellenwiderstand und Laufzeit aufweisen.

== Wellenwiderstand ==

Eine elektrische Leitung muß man bei hohen Frequenzen als ein Netzwerk aus

* Serienwiderstand Rs
* Parallelwiderstand Rp
* Serieninduktivität Ls
* Parallelkapazität Cp

betrachten.

[[bild:wellenwiderstand_ersatzschaltbild.png]]

Praktisch kann man sich das so vorstellen. Jeder elektrische Leiter hat einen [[Widerstand|ohmschen Widerstand]] Rs. Vorsicht! Das ist nicht der Wellenwiderstand! Ebenso hat jede elektrische Leitung einen Widerstand zwischen den Leitern, denn der Isolator ist nie ideal. Praktisch kann man den allerdings meist vernachlässigen, da er im Bereich von Gigaohm liegt. Die unvermeidlichen und ausschlaggebenden Parameter sind jedoch Ls und Cp. Jeder elektrische Leiter, welcher von einem Strom durchflossen wird, erzeugt ein Magnetfeld. Das ist gleichbedeutend mit der Induktivität Lp. Ebenso besteht zwischen zwei isolierten Leitern immer ein elektrisches Feld, wodurch der Kondensator Cp gebildet wird. Ls und Cp sind die entscheidenden Grössen zur Bestimmung des Wellenwiderstandes. Je nach geometrischer Anordnung der Leiter kann man sie in gewissen Grenzen variieren (Koaxialkabel, Twisted Pair, Flachbandkabel etc.).

Der Wellenwiderstand berechnet sich aus

<math>Z_0= \sqrt{\frac{Ls}{Cp}}</math>

Er ist eine charkteristische Grösse einer Leitung.

Beispiele:

* Koaxialkabel RG58 und RG174, 50Ω
* Koaxialkabel RG59, 75Ω
* Twisted Pair CAT3/5/7 für Ethernet, 100Ω
* Flachbandkabel, 150Ω typ.
* Leiterbahnen auf Platinen mit 30...150Ω

== Laufzeit ==

Elektrische Signale haben eine sehr hohe, aber dennoch begrenzte Ausbreitungsgeschwindigkeit. In Luft bzw. im Vakuum breiten sich Funksignale mit Lichtgeschwindigkeit aus, das sind 300.000 km/s, oder 30cm/ns. Auf Leitungen breiten sich Signale langsamer aus, da das elektromagnetische Feld mit der Umgebung interagiert. Je nach Leitungstyp etwa mit 50..70% der Lichtgeschwindigkeit, sprich mit ca. 15..21 cm/ns.

== Terminierung ==

Wenn eine elektrische Leitung als lang betrachtet werden muß, dann treten Reflexionen auf. Diese sind unerwünscht und können von sporadischen Fehlern bis zum völligen Versagen einer Schaltung alles verursachen. Deshalb müssen solche Leitungen terminiert werden. Die Terminierung absorbiert die einlaufenden Signale und verhindert damit ungewollte Reflexionen. Eine Leitung wird mit einem ohmschen Widerstand terminiert, welcher den gleichen Wert wie der Wellenwiderstand aufweist. Die Terminierungswiderstände müssen möglichst am Ende der Leitung plaziert werden.

'''Eine Leitung ist dann als elektrisch lang zu betrachten, wenn die einfache Laufzeit der Leitung grösser als ca. 1/6 der minimalen Anstiegszeit der Signale ist.'''

Ein Beispiel.

Ein [[AVR]] ist ein recht typischer digitaler IC. Die minimale Anstiegszeit beträgt ca. 5ns! Nach obiger Formel darf die Laufzeit nur 1/6 ~ 0,83ns betragen. Bei einer Ausbreitungsgeschwindigkeit von 21cm/ns ergibt das eine maximal zulässige Leitungslänge von 21cm/ns * 0,83ns ~ 17,5cm. Das heißt, bei einer Leitungslänge von bis zu 17,5cm '''und''' halbwegs sauberer Leitungsführung treten keine nennenswerten Reflexionen auf, eine Terminierung ist nicht notwendig. Darüber muss man aufpassen, spätestens bei dem doppelten bis dreifachen Wert ist eine Terminierung meist unverzichtbar.

=== Serienterminierung ===

Serienterminierung arbeitet bewußt mit Reflexionen. Von der Quelle wird ein Signal mit einem Innenwiderstand gleich dem Wellenwiderstand eingespeist. Dadurch ergibt sich ein Spannungsteiler von 1:2, d.h. Das Signal hat kurzzeitig nur die halbe Amplitude. Damit läuft es bis zum Ende der Leitung, welches offen ist. Es wird zu 100% reflektiert. Dadurch entsteht der volle Spannungspegel. Wenn die rücklaufende Reflexion die Quelle wieder erreicht wird sie vom Innenwiderstand der Quelle, welcher gleich dem Wellenwiderstand ist, absorbiert, es entsteht keine weitere Reflexion. Idealerweise sollte der externe Serienwiderstand Rs plus der Innenwiderstand des Ausgangs Ri gleich dem Wellenwiderstand sein. CMOS-ICs haben Ausgangswiderstände zwischen 15..50 Ohm.

[[bild:wellenwiderstand_serienterminierung.png]]

Datensignale können meist problemlos mit Serienterminierung betrieben werden. Taktsignale dürfen nur bei Punkt zu Punkt Verbindungen mit Serienterminierung betrieben werden (ein Sender und nur ein Empfänger). Anderenfalls kann es zu Fehlfunktionen kommen, da ein Takteingang, welcher in der Mitte der Leitung sitzt für ein paar Nanosekunden eine Spannung am Eingang anliegen hat die etwas VCC/2 entspricht. Das ist aber genau die Schaltschwelle von CMOS-ICs. Kleinste eingekoppelte Störungen können nun dafür sorgen, daß der Takteingang mehrere Flanken "sieht", wo eigentlich nur eine sein sollte.

=== Parallelterminierung ===

Parallelterminierung absorbiert die ankommende Welle am Ende einer Leitung. Damit treten zu keinem Zeitpunkt Reflexionen auf.

[[bild:wellenwiderstand_parallelterminierung.png]]

Nachteilig ist der Stromverbrauch bei HIGH Pegel. Den kann man halbieren, indem man mit einem speziellen Spannungsregler eine sog. Terminierungsspannung generiert (z.B. bei SCSI). Dieser Spannungsregler muss sowohl Strom liefern können (source) als auch Strom aufnehmen können (sink). Allerdings ist auch hier der Stromverbrauch noch recht beachtlich. Diese Terminierung ist nicht für 5 oder 3.3V CMOS geeignet. Parallelterminierung wird typisch bei Ethernet sowie beim RS485 Bus verwendet, dort sogar an beiden Enden. Es gibt diverse IO-Standards wie HSTL, SSTL etc., welche für schnelle ICs entwickelt wurden (DDR-RAM, DDR2-RAM), diese arbeiten mit Parallel- sowie Serienterminierung.

[[bild:wellenwiderstand_vt-terminierung.png]]

Ohne Terminierungsspannung kommt man mit der sog. Thevenin-Terminierung aus. Dabei wird der Terminierungswiderstand durch zwei doppelt so große Widerstände ersetzt. Aus Sicht des Kabels sind diese beiden Widerstände '''parallel''' geschaltet! Daher auch der Name, Thevenin Equivalent ist im Englischen die Bezeichung für eine Ersatzschaltung mit anderem Aufbau aber im Endeffekt gleichen Eigenschaften. Hier spart man auch die Hälfte des Stroms ein, allerdings fliesst jetzt auch bei LOW ein Strom durch die Terminierung.

[[bild:wellenwiderstand_theveninterminierung.png]]

=== AC-Terminierung ===

Um den Stromverbrauch allgemein zu senken kann AC-Terminierung eingesetzt werden. Dazu wird ein Kondensator in Reihe zum Terminierungswiderstand geschaltet. Damit fliesst nur für eine kurze Zeit ein Strom, wenn der Pegel wechselt. Nachteilig ist die bisweilen kritische Dimensionierung des Kondensators. Er darf nicht zu klein sein, damit die Spannung nicht zu schnell steigt und somit der Terminierungswiderstand nicht voll wirksam ist. Andererseits darf er nicht zu groß sein, damit der Umladevorgang vor dem nächsten Flankenwechsel abgeschlossen ist (Taktfrequenz). Hier muß man ggf. experimentieren und '''richtig''' messen. Typische Werte liegen zwischen 100pF und 10nF.

Für Takte und Signale mit konstantem Mittelwert ([[Manchester]]kodierung, 8B10B Kodierung) kann man den Kondensator sehr groß wählen (100nF Keramik + großen Elko). Dann lädt sich der Kondensator über mehrere hundert Takte auf den Mittelwert der Spannung auf und hält diese. Damit wirkt er wie eine Spannungsquelle für die Terminierungsspannung. Der Vorteil ist der eingesparte Spannungsregler, der Stromverbrauch ist identisch mit der Parallelterminierung. Als grobe Orientierung sollte die Zeitkonstante aus Terminierungswiderstand mal Kondensator ca. 1000 mal größer sein als die Periodendauer des Taktes bzw. die Bitdauer das Datenstroms sein.

<math>R_T \cdot C_T >= 1000 \cdot T_{CLK}</math>

[[bild:wellenwiderstand_ac-terminierung.png]]

== Takt- und Datensignale ==

Bei Datensignalen ist es meist durchaus akzeptabel, wenn ein erhöhtes Maß an Überschwingern und Reflexionen auftreten. Auf synchronen [[Bus]]systemem werden die Daten mittels eines Taktes abgetastet. Nur zu diesem Zeitpunkt müssen die Daten sauber anliegen, ein wenig davor (Setup Time) und ein wenig danach (Hold time). Ganz anders bei Takten, asynchronen Resets und Interruptsignalen. Auf diese reagiert ein digitaler IC '''sofort''' und sehr schnell. Durch Reflexionen kann es zu "Zacken" auf Taktflanken kommen, welche ein langsamer IC ignoriert aber ein schneller darauf reagiert und zwei Taktflanken "sieht", wo eigentlich nur eine ist. Hier muss man aufpassen. Diese Signale sollten

* sehr solide layoutet werden
* etwas Abstand zu allen anderen Signalen bekommen
* ggf. sauber terminiert werden

Dann gibt es auch keine Probleme mit instabilen Datenübertragungen etc.

== Leitungsführung und Layout ==

Der Zusatz "und halbwegs saubere Leitungsführung" ist eine entscheidende Komponente bei der Verteilung schneller Signale! Irgendwelche wilde Klingeldrahtorgien oder lieblos auf die Platine geschmissene Leitungen zählen nicht dazu. Im Idealfall sind die Leitungen mit einer Impedanz von 50 oder 75 Ohm layoutet, bei differentiellen Signalen auch 100 Ohm (Ethernet, LVDS etc.). Dazu muß eine bestimmte Geometrie der Leiterbahn eingehalten werden, im wesentlichen bestimmt durch Breite und Abstand zur Referenzfläche (GND oder VCC). Die Stichworte für eine Suche im Internet lauten Microstrip und Stripline. Bei zwei- oder vierlagigen Platinen werden die Leitungen mit 50/75Ω ziemlich breit, deshalb kann man sich dort dem Ideal nur sehr grob nähern. Dennoch sollte man vor allem für Takte es versuchen, und möglichst die Leitung über einer Referenzfläche führen. Das grundlegende Prinzip lautet:

'''Die Fläche der Leiterschleife zwischen Signal und Massefläche muß minimiert werden.'''

Man muß immer daran denken. Strom fließt immer im Kreis, deshalb heißt es ja auch Stromkreis. Der Stromkreis beginnt am Versorgungspin des ICs, welcher das Signal generiert, läuft über den Ausgang und die Signalleitung zum Eingang des Empfängers bzw. der dort platzierten Terminierung, dort nach Masse und über die Masse zurück zum Sender-IC. Die Rückleitung über Masse ist genauso wichtig wie die Hinleitung des Signals! Eine wild geschlungene Masseleitung macht das beste Layout zunichte. Optimal sind komplette Masseflächen, doch die sind nur meist nur bei Platinen mit vier oder mehr Lagen machbar. Bei hochfrequenten Analogschaltungen gönnt man sich den "Luxus" auch bei zweilagigen, weil man sonst in Teufels Küche kommt. Bei schnellen Digitalschaltungen auf zweilagigen Platinen muß man Kompromisse eingehen. Aber auch hier gilt die alte Weisheit, daß die Masse möglichst sternförmig verteilt werden sollte.

Wenn Kabel als Verbindung zwischen ICs verwendet werden, sollte man auch hier Sorgfalt walten lassen.

* Idealerweise sollte man bei Flachbandkabeln jede 2. Ader auf Masse legen und auf BEIDEN Seiten der Verbindundung am Stecker mit der Masse der Platine verbunden werden.
* Meist reicht es, jede 4. bis 10. Ader auf Masse zu legen, wobei man Takte direkt neben die Masse legen sollte.
* Bei Steuerkabeln (verdrillt oder auch nicht) gilt ähnliches.

== Zusammenfassung ==

* Entscheidend für das Entstehen von Reflexionen ist '''NICHT''' die Taktfrequenz sondern die Anstiegszeit der Signale. Eine Schaltung mit schnellen ICs wird auch bei niedrigen Taktfrequenzen sehr schnell schalten, auch wenn das nicht unbedingt notwendig wäre.
* Mit Reflexionen muß man rechnen, wenn die einfache Laufzeit der Leitung grösser als ca. 1/6 der minimalen Anstiegszeit der Signale ist.
* Serienterminierung ist für Takte nur bei Punkt zu Punkt Verbindungen sicher nutzbar.
* Parallelterminierung ist für 5/3,3V CMOS ungeeignet (Stromverbrauch).
* Auch ohne Terminierung ist bei schnellen Signalen eine halbwegs saubere Leitungsführung notwendig.
* Man sollte nach Möglichkeit immer die langsamsten Logikbausteine verwenden, um Probleme mit Reflexionen zu minimieren (Wozu braucht man 1ns Anstiegszeit bei 5 MHz Takt?).
* Ausgänge sollten möglichst identische Ausgangswiderstände für LOW und HIGH haben (wie z.B. die HC Familie), sonst wird eine Serienterminierung schwierig bis unmöglich (wie. z.B. die ABT Familie); siehe [http://www.ti.com/litv/pdf/szza008 "Input and Output Characteristics of Digital Integrated Circuits"]

== Links ==

* [http://de.wikipedia.org/wiki/Wellenimpedanz Wellenwiderstand bei Wikipedia]
* [http://www.signalintegrity.com Die Bibel der hochfrequenten Digitalsignale]
* [http://www.ti.com/litv/pdf/szza008 "Input and Output Characteristics of Digital Integrated Circuits"]
* http://www.forelec.ch/www/fichiers/HS-PCB-1.PDF (Sehr gutes Dokument zum Thema)
* [http://wiki.fed.de/fed-wiki/images/3/3f/Impedanzarten_-_Lagenaufbauten.pdf Striplines/Microstrip schnell berechnet] (PDF)
* [http://www1.sphere.ne.jp/i-lab/ilab/tool/cpw_e.htm Online Calculator]
* [http://supachris.homeip.net/cits25setup.exe Offline Calculator]
* [http://www.hp.woodshot.com/appcad/version302/setup.exe Noch ein Offline Calculator]
* Linksammlung [http://www.circuitsage.com/tline.html Transmission Line Design and Analysis]