Mikrocontroller.net - Benutzerbeiträge [de]

FIFO

2015-12-28T22:53:58Z

87.178.118.194: hierarchie

Ein FIFO (First-In-First-Out) ist ein Pufferspeicher nach dem "Warteschlangen-Prinzip". Pufferspeicher dienen dazu, Daten aufzufangen, die noch nicht sofort verarbeitet werden können. Ein FIFO funktioniert definitionsgemäß so, dass das erste Element (First In), welches "hinten" in die Warteschlange eingefügt wird, später auch als erstes "vorne" herausgeholt wird (First Out). Das Gegenstück zum FIFO ist [[LIFO]].

== Funktion ==
Ein bekanntes Beispiel für einen FIFO-Speicher ist der des [[UART]]s im PC. Dieser sammelt ankommende Daten solange, bis er fast voll ist (meist 14 Bytes). Dann wird ein [[Interrupt]] ausgelöst und der Prozessor kann "auf einen Rutsch" alle Daten auf einmal schnell auslesen. Ganz am Anfang hatten UARTs keinen FIFO und erzeugten für jedes empfangene Byte einen Interrupt, so wie es heute noch die meisten Mikrocontroller machen. Damit ist aber die CPU-Belastung wesentlich höher, was bei höheren Datenraten zu Problemen führen kann. In Senderichtung ist das Problem auch vorhanden, wenn gleich unkritischer. Mit einem FIFO kann die CPU sehr viele Dutzende bis Hunderte Bytes in sehr kurzer Zeit (wenige Dutzend Mikrosekunden) hineinschreiben, welche dann relativ langsam mittels [[Interrupt]] Byte für Byte mit dem UART gesendet werden. Die CPU muss nicht warten, bis jedes einzelne Zeichen versendet wurde. Zum Vergleich. Ein AVR mit 16 MHz Takt macht während der Übertragung von 1 Byte bei 115200 Baud (86,8us) 1389 CPU-Takte. Damit kann man sehr viel anstellen! Bei schnelleren CPUs bzw. niedrigeren Baudraten ist das Mißverhältnis noch deutlich größer. Im Idealfall werden die Daten aus dem FIFO mittels [[DMA]] an den UART übertragen, dann hat der Prozessor gar nichts mehr damit zu tun.

Die Umsetzung eines FIFOs in Software heißt Ringpuffer und weist auch eine feste Puffergröße auf. Wesentlicher Vorteil gegenüber der verketteten Liste ist die schnellere Ausführungszeit und der geringere Aufwand.

== Standard-Ringpuffer ==

Vorteile:
* Simpel
* Leicht verständlich
* Daten können auch vom Typ struct sein

Nachteile:
* Schnell aber nicht optimal

=== Beschreibung ===
{|
|-
|
[[Bild:Ringpuffer.png|300px]]
|
[[Bild:Circular buffer.png|200px]]
|}

Die Inhalte des Puffers werden in einem schlichten Array gespeichert und der Zugriff erfolgt über einen Integer-Index. Erreicht ein Index die Obergrenze springt dieser auf Null zurück. Topologisch ist dies äquivalent zu einem Ringschluss, bei dem man ja auch nach dem letzten Element wieder beim ersten angelangt ist. Man denke zb an das Zifferblatt einer Uhr, bei der nach der 59 wieder die 0 kommt. Ein größer-gleich statt nur eines ist-gleich Vergleichs ist sicherer gegenüber Programmfehlern, bei denen der Index verstellt wurde.
<syntaxhighlight lang="c">
write = write + 1;
if (write >= BUFFER_SIZE)
write = 0;
</syntaxhighlight>
Haben Lese- und Schreib-Index den gleichen Wert wird der Puffer als leer angesehen und es kann kein Element aus dem Puffer entnommen werden. Wenn write+1 und read identisch sind wird der Puffer als voll angesehen und es kann kein weiteres Element mehr im Puffer gespeichert werden. Nun fehlt noch der Sonderfall bei dem read gleich Null ist, hier funktioniert der write+1-Vergleich nicht mehr (wegen dem 'Überlauf' am Ende des Arrays, der den Ringschluss bewirkt) und die Abfrage einer zusätzlichen Bedingung ist zur Voll-Abfrage erforderlich.
<syntaxhighlight lang="c">
read == write => leer
write + 1 == read || read == 0 && write+1 == BUFFER_SIZE => voll
</syntaxhighlight>
Bei gleichzeitigem Zugriff zwischen dem Befüller (zb. einer [[Interrupt#UART_mit_Interrupts | UART-ISR]]) und dem Entnahmecode (zb. der Code in der Hauptschleife) muss ausgeschlossen werden, dass der Entnahmecode beim Lesen aus dem Puffer nicht durch den Interrupt unterbrochen werden kann. Denn während diese Funktion läuft, ist zwischenzeitlich der read-Index in einem inkonsistenten Zustand. Erst nach Beendigung der Funktion spiegelt der read-Index wieder die Realität des Füllgrades wieder. Als Abhilfe dienen [[Interrupt#Atomarer_Datenzugriff|Atomare Abschnitte]], solche können durch keinen Interrupt unterbrochen werden. Die Radialkur deaktiviert alle Interrupts, besser ist die Deaktivierung eines einzelnen Interrupts. Es geht aber meistens auch so, da die FIFO-Funktionen sehr kurz sind und daher auch die Interrupts nur kurz abgeschaltet werden. Im Allgemeinen werden versäumte Interrupts nach erneuter Aktivierung nachgeholt und gehen nicht verloren, so dass bereits anstehende Interrupts nur kurz verzögert werden. Solange die Interruptperiodendauer größer als die Ausführungsgeschwindigkeit der FIFO Funktionen ist, stellt das Abschalten der Interrupts daher auch in der Praxis meist kein allzugroßes Problem dar.

<syntaxhighlight lang="c">
cli()
ret = BufferOut(&var);
sei()
</syntaxhighlight>

Hilfreich ist die Initialisierung der Indizes (read, write) mit -1, denn damit kann man einen leere Ringpuffer von einem vollen unterscheiden. Initialisiert man nur mit 0, kann man einen leeren nicht von einem vollen mit read=write=0 unterscheiden.

Eine weitere Möglichkeit der Vereinfachung entsteht durch die Einführung einer "Counter" Variable, die den Füllstand des Buffers wiedergibt. Bei Einschreiben wird diese um +1 erhöht, beim Auslesen um 1 erniedrigt. Ist sie 0 ist der Buffer leer. Damit lässt sich die Codeeffizienz steigern, da die obigen Vergleiche kürzer ausfallen und sich auf nur diese eine Variable beschränken. Nachteilig ist allerdings, dass man eine weitere Variable im System hat und natürlich benötigen die entsprechenden Operationen zum Erhöhen bzw. Erniedrigen dieser Variable ja auch Ausführungszeit. Benötigt man im restlichen Code den Füllgrad der FIFO nicht als explizite Zahl, dann lohnt daher eine derartige Counter-Variable meistens nicht.

=== Code-Beispiel ===
<syntaxhighlight lang="c">

#define BUFFER_FAIL 0
#define BUFFER_SUCCESS 1

#define BUFFER_SIZE 23

struct Buffer {
uint8_t data[BUFFER_SIZE];
uint8_t read; // zeigt auf das Feld mit dem ältesten Inhalt
uint8_t write; // zeigt immer auf leeres Feld
} buffer = {{}, 0, 0};

//
// Stellt 1 Byte in den Ringbuffer
//
// Returns:
// BUFFER_FAIL der Ringbuffer ist voll. Es kann kein weiteres Byte gespeichert werden
// BUFFER_SUCCESS das Byte wurde gespeichert
//
uint8_t BufferIn(uint8_t byte)
{
//if (buffer.write >= BUFFER_SIZE)
// buffer.write = 0; // erhöht sicherheit

if ( ( buffer.write + 1 == buffer.read ) ||
( buffer.read == 0 && buffer.write + 1 == BUFFER_SIZE ) )
return BUFFER_FAIL; // voll

buffer.data[buffer.write] = byte;

buffer.write++;
if (buffer.write >= BUFFER_SIZE)
buffer.write = 0;

return BUFFER_SUCCESS;
}

//
// Holt 1 Byte aus dem Ringbuffer, sofern mindestens eines abholbereit ist
//
// Returns:
// BUFFER_FAIL der Ringbuffer ist leer. Es kann kein Byte geliefert werden.
// BUFFER_SUCCESS 1 Byte wurde geliefert
//
uint8_t BufferOut(uint8_t *pByte)
{
if (buffer.read == buffer.write)
return BUFFER_FAIL;

*pByte = buffer.data[buffer.read];

buffer.read++;
if (buffer.read >= BUFFER_SIZE)
buffer.read = 0;

return BUFFER_SUCCESS;
}
</syntaxhighlight>

=== FIFO als Bibliothek ===

Hier sollen FIFO-Funktionen bereitgestellt werden, welche folgende Eigenschaften besitzen.

* Mehrfache FIFOs einfach anlegen und benutzen
* Leistungsfähiger Zugriff auf FIFO-Daten (Blockzugriff)
* Interruptfester FIFO-Zugriff

Diese FIFOs sind auf so ziemlich allen Plattformen nutzbar, entwickelt wurde sie jedoch auf einem AVR. Daher ist im FIFO im Moment auch noch eine Begrenzung der FIFO-Größe auf 64kiB vorhanden, welche aber leicht per typedef in fifo.h abgeändert werden kann. Ebenso kann die Größe der FIFO-Elemente eingestellt werden (8, 16, 32 Bit, ebenfalls structs). Alle FIFO-Funktionen sind interruptsicher aufgebaut, d.h. die kritschen Zugiffe auf die FIFO-Kontrolldaten erfolgen [[Interrupt#Atomarer_Datenzugriff | atomar]]. Damit ist der Einsatz im Hauptprogramm und in [[Interrupt]]s sicher möglich. Bei anderen Plattformen muss ggf. der atomare Zugriff angepasst werden. Der Datenzugriff erfolgt direkt über Pointer, das erhöht die Geschwindigkeit gegenüber Indexoperationen. Die folgenden Funktionen sind im wesentlichen verfügbar:

* fifo_init(): FIFO initialisieren
* fifo_write_busy(): wartet bis mindesten 1 Element im FIFO frei ist und schreibt es in den FIFO
* fifo_write(): schreibt ein Element in den FIFO, ohne Prüfung ob genügend Platz vorhanden ist
* fifo_read_busy(): wartet bis mindesten 1 Element im FIFO vorhanden ist und liest es aus dem FIFO
* fifo_read(): liest ein Element es aus dem FIFO, ohne Prüfung ob Daten vorhanden sind
* fifo_get_level(): liefert die Anzahl der Elemente im FIFO zurück
* fifo_get_free(): liefert die Anzahl der noch frei verfügbaren Elemente im FIFO zurück

Die Funktionen fifo_write_busy() und fifo_read_busy() warten solange vor dem FIFO-Zugriff, bis Speicher bzw. Daten im FIFO verfügbar sind. Das kann bisweilen lange dauern (blockierende Funktionen).
Die Funktionen fifo_write() und fifo_read() greifen ohne weitere Prüfung auf den FIFO zu. Die Prüfung muss vorher erfolgen. Damit ist eine nicht blockierende Arbeitsweise möglich ([[Multitasking]]).

==== Leistungsverbesserung ====

Die Funktionen zum Lesen und Schreiben einzelner Elemente sind einfach und klar. Aber was ist, wenn man mehrere Elemente aus dem FIFO lesen will? Oder noch viel schlimmer, wenn Bibliotheksfunktionen mehrere Elemente über einen Zeiger lesen wollen? Hier kommen die restlichen Funktionen ins Spiel.

* fifo_write_bursted(): korrigiert den Schreibzeiger des FIFOs nach einem Blockzugriff
* fifo_read_bursted(): korrigiert den Lesezeiger des FIFOs nach einem Blockzugriff

D.h. eine Funktion wie z.B. memcpy() liest eine Anzahl X Bytes aus dem FIFO und kopiert sie woanders hin. Danach wird der Lesezeiger um die Anzahl X korrigiert. Damit muss nicht X mal die Funktion fifo_read() aufgerufen werden, was deutlich an CPU-Leistung spart. Ein derartiger Blockzugriff spart auch Zwischenspeicher, wenn z.B. eine Funktion zum Schreiben von Daten auf SD-Karte direkt auf diese zugreifen kann, ohne dass sie weiß, dass diese in einem FIFO stecken!

Doch Vorsicht, so einfach ist es nicht! Denn unser FIFO ist ein Ringpuffer! Am Ende des Datenbereichs muss der Schreib- bzw. Lesezeiger immer wieder auf den Anfang des Datenbereichs zurück springen. Allerdings wissen Funktionen wie memcpy() und andere nichts von einem Ringpuffer! Sie erwarten die Daten immer in linearer Anordnung im Speicher. D.h. man muss vor einem Blocktransfer immer erst prüfen, ob die gewünschte Menge Daten linear an einem Stück im FIFO liegt oder ob zwischendrin ein Überlauf des Schreib- oder Lesezeiger statt findet. In diesem Fall muss man den Blockzugriff auf zwei Zugriffe aufteilen. Dazu dienen die beiden Funktionen

*fifo_get_read_wrap(): liefert die Anzahl Elemente bis zu Überlauf des Lesezeigers
*fifo_get_write_wrap(): liefert die Anzahl Elemente bis zu Überlauf des Schreibzeigers

Die Anwendung aller Funktionen ist in einem kurzen Beispielprogramm demonstriert und mit Doxygen dokumentiert (/doxygen/html/index.html). Dabei ist vor allem zu beachten, dass die Funktionen des FIFOs immer mit der Anzahl von Elementen arbeiten, wogegen viele andere Funktionen mit der Anzahl von Bytes arbeiten. Die kleine Bibliothek ist als [[media: fifo.zip | Archiv]] verfügbar. Für die Simulation muss man die Optimierung des Compilers ausschalten, um alle Variablen anzeigen zu können.

== 2n-Ringpuffer - die schnellste Lösung ==

Vorteile:
* Durch Bitmaske auf den Feld-Index ''write'' kann der nicht "Amoklaufen" und beliebige Inhalte im Speicher überschreiben
* Sehr einfach, sehr schnell
Nachteile:
* Nur Größenfaktoren von 2n möglich
* Nur in speziellen Fällen Pointerreferenz möglich

=== Beschreibung ===

Wenn der Index am oberen Ende angekommen ist springt er an den Anfang zurück. Die Definition der Obergrenze wird nicht durch einen Vergleich realisiert, sondern durch Modulo-Arithmetik. Dies kann sehr einfach und schnell durch Maskieren des Index-Werts umgesetzt werden.

Beispiel:
<syntaxhighlight lang="c">
( write + 1 ) & MASK

15 = 0b00001111
15 + 1 = 16 = 0b000010000
16 & MASK = 0b000010000 & 0b000001111 = 0b000000000
</syntaxhighlight>

Daraus folgt das ''write'' nur einen Wert zwischen 0 und 15 einnehmen kann. Das ganze funktioniert nur mit Zahlen der Reihe 2n.

Da der Puffer nur eine endliche Größe aufweist, muss eine voll/leer Indikation verfügbar sein. read == write bedeutet Puffer leer, entsprechend bedeutet write + 1 == read, dass keine weiteren Elemente mehr hinzugefügt werden können, denn sonst würde das Hinzufügen weiterer Daten einen Pufferüberlauf hervorrufen. Für die Behandlung des Pufferüberlaufs gibt es zwei Methoden, nichts tun und Fehler zurück geben oder ältesten Puffer-Inhalt verwerfen (read+1).

<syntaxhighlight lang="c">
read == ((write + 1) & MASK)
</syntaxhighlight>

Auch hier verhindert die Bitmaske einen möglichen Überlauf. Weiter zu beachten ist, dass ein Byte durch die voll/leer Indikation verloren geht, der Puffer hat hier nur eine größe von 15 statt 16 Byte

Und noch ein kleiner Trick. Bei einer Zahl der Reihe 2^n lässt sich auf einfache Weise immer eine passende Bitmaske erzeugen und man sieht gleichzeitig klar die Anzahl der genutzten Bytes.

<syntaxhighlight lang="c">
# define SIZE 16
# define MASK (SIZE-1)

16 = 0b010000
16 - 1 = 0b001111
</syntaxhighlight>

Im Normalbetrieb sollte der Puffer nie voll ausgereizt sein und wenn der Puffer bereits überläuft ist es für die Systemstabilität und Fehleranlyse oft schon zu spät, denn von einem nicht mehr funktionierenden Gerät lässt sich nur wenig Information herauskitzeln. Da kann ein Frühwarnsystem mehr bieten, wobei zwei Ausprägungen typisch sind, Höchstwert merken und eine Meldeschwelle einführen.

<syntaxhighlight lang="c">
freeMemory = (read - write - 1 ) & MASK);
if (freeMemory < floodmark)
floodmark = freeMemory;
</syntaxhighlight>

<syntaxhighlight lang="c">
if ( (read - write - 1 ) & MASK) <= FLOODMARK;
FloodmarkExcess();
</syntaxhighlight>

Eine entsprechende Auswertung kann z.B. bei einer UART zur Steuerung des Handshakes benutzt werden, bei dem die Gegenstelle aufgefordert wird, das Senden kurzfristig einzustellen, damit man nicht Gefahr läuft, übertragene Zeichen zu verlieren, weil die FIFO voll wird. Dabei ist allerdings auch zu berücksichtigen, dass die Gegenstelle das Senden nicht sofort einstellen kann, da sich beispielsweise bereits Zeichen in der Sendehardware befinden können, die der Sender nicht mehr stoppen kann. Hier heißt es also rechtzeitig zu reagieren und nicht erst, wenn der FIFO propevoll ist. Fällt der Füllgrad einer darartigen UART-FIFO wieder unter eine gewisse Schwelle, dann wird der Gegenstelle signalisiert, dass sie mit dem Senden fortfahren kann.

=== Code-Beispiel ===

<syntaxhighlight lang="c">

#define BUFFER_FAIL 0
#define BUFFER_SUCCESS 1

#define BUFFER_SIZE 16 // muss 2^n betragen (8, 16, 32, 64 ...)
#define BUFFER_MASK (BUFFER_SIZE-1) // Klammern auf keinen Fall vergessen

struct Buffer {
uint8_t data[BUFFER_SIZE];
uint8_t read; // zeigt auf das Feld mit dem ältesten Inhalt
uint8_t write; // zeigt immer auf leeres Feld
} buffer = {{}, 0, 0};

//
// Stellt 1 Byte in den Ringbuffer
//
// Returns:
// BUFFER_FAIL der Ringbuffer ist voll. Es kann kein weiteres Byte gespeichert werden
// BUFFER_SUCCESS das Byte wurde gespeichert
//
uint8_t BufferIn(uint8_t byte)
{
uint8_t next = ((buffer.write + 1) & BUFFER_MASK);

if (buffer.read == next)
return BUFFER_FAIL; // voll

buffer.data[buffer.write] = byte;
// buffer.data[buffer.write & BUFFER_MASK] = byte; // absolut Sicher
buffer.write = next;

return BUFFER_SUCCESS;
}

//
// Holt 1 Byte aus dem Ringbuffer, sofern mindestens eines abholbereit ist
//
// Returns:
// BUFFER_FAIL der Ringbuffer ist leer. Es kann kein Byte geliefert werden.
// BUFFER_SUCCESS 1 Byte wurde geliefert
//
uint8_t BufferOut(uint8_t *pByte)
{
if (buffer.read == buffer.write)
return BUFFER_FAIL;

*pByte = buffer.data[buffer.read];

buffer.read = (buffer.read+1) & BUFFER_MASK;

return BUFFER_SUCCESS;
}
</syntaxhighlight>

=== FIFO mit C-Präprozessor ===

<syntaxhighlight lang="c">
#ifndef FIFO_H_
#define FIFO_H_

#include <stdint.h>

typedef struct {
uint8_t _read;
uint8_t _write;
uint8_t _buffer[64];
} FIFO64_t;

typedef struct {
uint8_t _read;
uint8_t _write;
uint8_t _buffer[128];
} FIFO128_t;

#define FIFO_init(fifo) { fifo._read = 0; fifo._write = 0; }

#define FIFO_available(fifo) ( fifo._read != fifo._write )

#define FIFO_read(fifo, size) ( \
(FIFO_available(fifo)) ? \
fifo._buffer[fifo._read = (fifo._read + 1) & (size-1)] : 0 \
)

#define FIFO_write(fifo, data, size) { \
uint8_t tmphead = ( fifo._write + 1 ) & (size-1); /* calculate buffer index */ \
if(tmphead != fifo._read) { /* if buffer is not full */ \
fifo._buffer[tmphead] = data; /* store data in buffer */ \
fifo._write = tmphead; /* store new index */ \
} \
}

#define FIFO64_read(fifo) FIFO_read(fifo, 64)
#define FIFO64_write(fifo, data) FIFO_write(fifo, data, 64)

#define FIFO128_read(fifo) FIFO_read(fifo, 128)
#define FIFO128_write(fifo, data) FIFO_write(fifo, data, 128)

#endif /*FIFO_H_*/
</syntaxhighlight>

Hinweis: viele C-Compiler übersetzen automatisch eine Modulo-Division mit einem Divisor einer 2-er Potenz in Form einer entsprechenden Bitmaskierung. Zum einen erspart man sich dadurch das Bestimmen der entsprechenden Maske, zum anderen hat man dann den 'Bonus', dass der Code immer noch korrekt funktioniert (wenn auch langsamer), wenn der Anwender einen Fehler macht und die Array-Länge nicht als 2-er Potenz definiert. Die Operation

<syntaxhighlight lang="c">
fifo._buffer[fifo._read = (fifo._read + 1) & (size-1)] : 0 \
</syntaxhighlight>
kann dann durch die in diesem Sinne gleichwertige Operation
<syntaxhighlight lang="c">
fifo._buffer[fifo._read = (fifo._read + 1) % size] : 0 \
</syntaxhighlight>
ausgedrückt werden, bzw.
<syntaxhighlight lang="c">
uint8_t tmphead = ( fifo._write + 1 ) & (size-1); /* calculate buffer index */ \
</syntaxhighlight>
durch
<syntaxhighlight lang="c">
uint8_t tmphead = ( fifo._write + 1 ) % size; /* calculate buffer index */ \
</syntaxhighlight>

== Weblinks ==
* [http://en.wikipedia.org/wiki/Circular_buffer Circular buffer], englische Wikipedia

[[Kategorie:Grundlagen]]
[[Kategorie:Datenübertragung]]
[[Kategorie:Algorithmen und Arithmetik]]
[[Kategorie:Speicher und Dateisysteme]]

Mini-Jakobsleiter

2015-12-28T22:47:56Z

87.178.118.194: kleines

----
{|
|-
|[[Bild:High voltage warning.svg|100px]]
|
<center><big>'''Achtung, hier wird mit lebensgefährlicher Netzspannung gearbeitet. Dieses Projekt ist nur für Personen geeignet, die mit den notwendigen Sicherheitsvorkehrungen vertraut sind.'''
|[[Bild:High voltage warning.svg|100px]]
|}
</big></center>
----
[[Bild:Jakobsleiter in Aktion.jpg|thumb|Jakobsleiter in Aktion (Aufbau entspricht nicht exakt den Angaben)]]

Schlagen irgendwo Funken über, so erregt man die Aufmerksamkeit aller Anwesenden und Jeder versteht: Hier fließt Strom! Besonders faszinierend sind die kletternden Lichtbögen der sogenannten '''Jakobsleiter''', doch selbst Hochspannung zu erzeugen trauen sich die Wenigsten zu. Dabei macht es gar nicht so viel Aufwand, sobald der richtige Weg bekannt ist. Grundstein dieses Projekts bildete das Datenblatt für den Zündtrafo ZS 1052 auf Conrad.de. Das Ergebnis ist ein Mini-Jakobsleiter im Lochrasteraufbau.

== Funktionsprinzip ==

=== Hochspannung erzeugen ===

Der Brückengleichrichter mit dem Elko erzeugt eine Gleichspannung in Höhe von 315 Volt. Der Widerstand (≈560 kΩ) parallel zum Elko entlädt diesen nach dem Ausschalten des Hochspannungsgenerators zügig. Bei offenem Schalter lädt sich der Schwingkreiskondensator über den Widerstand auf und bei geschlossenem Schalter bildet der Kondensator mit der Induktivität des Trafos einen Parallelschwingkreis und transformiert die Netzspannung zu etwa 11 kV Hochspannung. Der Ladewiderstand hängt an 315 Volt und hat keinen Einfluss auf den Schwingkreis.

[[Bild:Hochspannungsschwingkreis.svg]]

Dass der Ladewiderstand mit dem Kondensator direkt gegen Masse geschaltet wird, vereinfacht den Aufbau erheblich, so ist kein Wechselschalter von Nöten. Dafür darf der Schalter nur kurz geschlossen werden. Da Elektronik zum Einsatz kommt, ist das aber kein nennenswertes Problem.

Die Resonanz spielt für die Funktion keine Rolle und stellt nur einen Nebeneffekt dar. Der Kondensator bietet zwei wesentliche Vorteile: er wird mit einer definierten Energiemenge aufgeladen und liefert eine definierte Spannung. Dadurch haben Kurzschlüsse, dazu zählen auch Lichtbögen, keine gravierenden Auswirkungen auf den Trafo. Der Trafo übersetzt die Kondensatorspannung gemäß seines Übersetzungsverhältnisses auf die Sekundärseite.

Eine genauen Berechnung der Bauteile im voraus ist nicht möglich, denn für Jakobsleitern gibt es keine spezielle Theorie. Die Ausgangsbasis bildet der Zündtrafo, dessen Datenblatt legt einen Kondensator mit Kapazität 47 nF fest. Ein Oszillogramm zeigt, dass bis zum Abklingen der Resonanz etwa 100 µs vergehen. Solange sollte also der Schalter mindestens geschlossen bleiben, aber auch nicht länger um den Ladewiderstand zu schonen. Die Ladespannung für den Kondensator wird dort mit 300 Volt angegeben, also im Bereich des Gleichrichtwerts der Netzspannung. Somit war klar, woraus die Spannungsversorgung erzeugt wird.

Nun kommt der wesentliche Praxiswert: eine Kondensatorladung enthält eine definierte Energiemenge. Daher kommt es bei der Leistungsbemessung nur noch auf die Schaltfrequenz an. Die minimale Ladezeit, Schalter offen, für den Kondensator beträgt 3* τ, sprich 3 *Ladewiderstand*Schwingkreiskondensator. Anfangs war dies ein 22 kΩ/1 W Widerstand. Ein kleiner Funke sprang über, es reichte aber nicht für eine Jakobsleiter und so kamen 22 kΩ Parallel dazu, womit die Ladezeit sank. Jetzt zeigte der Aufbau seine volle Pracht.

Der Geruch verriet allerdings, die Widerstände wurden zu heiß, denn beim Materialeinkauf wurde großzügig mit einem Tastverhältnis von 1:100 gerechnet und erst bei der Praxiserprobung auf 1:10 reduziert, wodurch wesentlich mehr Ladezyklen pro Zeit erfolgten mit wesentlich höhere Verlusten am Widerstand. Daher sei hier das Parallelschalten von drei bis vier 33 kΩ/1 W Widerständen empfohlen (genaue Berechnungen stehen noch aus). Insgesamt ergibt sich damit eine Ladezeit von 1 ms und eine Schwingzeit von 100 µs.

Statt eines richtigen Schalters befindet sich in der Schaltung ein MOSFET (z. B. BUZ91A) der für 300 Volt ausgelegt ist. Eine Zeitgeberelektronik steuert die Gatespannung, siehe nächster Abschnitt.

Die Experimentierfreude soll jedem selbst überlassen bleiben in Form weiterer Tuningmaßnahmen durch mehr Widerstände und in Folge geringer Ladezeit nach dem Prinzip mehr Leistung = mehr Spaß. Eine Halbierung sollte noch drin sein, die Verlustleistung steigt aber mit der Schaltfrequenz weiter und der Wert der einzelnen Widerstände sollte auf 39 kΩ oder 39 kΩ erhöht werden.

Statt eines Trafos können sekundärseitig auch zwei in Serie geschaltet werden und die Spannung verdoppelt sich. Mehrere geht nicht, da ansonsten die Potentialdifferenz zur Primärseite zu hoch wird und der Trafo durchschlägt.

=== Zeitgeber NE555 ===

Als Zeitgeber kommt der allseits-bekannte NE555 als astabiler Multivibrator zum Einsatz. Der obere Teil bildet die Spannungsversorgung mit 78xx in Standardschaltung.

[[Bild:Hochspannung ne555.svg]]

Zur Spannungsversorgung muss nichts weiter erklärt werden.

Die Schaltung an Output dient als Inverter da die Multivibratorschaltung lange Pulse mit kurzen Pausen erzeugt, der MOSFET genau umgekehrt lange aus und kurz ein sein soll. Der Arbeitswiderstand beträgt 470 Ω der Basisvorwiderstand 10 kΩ. Der Kondensator parallel beträgt 500 pF und soll die Basis-Emitter-Kapazität füllen, damit der Transistor schneller durchschaltet. Keine Ahnung, ob das überhaupt notwendig ist, aber wer will schon sein Oszi mit Hochspannungsmessungen zerstören? Der Bipolar-Transistor ist ein BC557B also pnp. Signal-Masse ist mit der Source vom MOSFET verbunden der Inverter-Ausgang mit Gate.

Der Kern des Multivibrators besteht aus zwei Widerständen und einem Kondensator. Die Puls und Pausenzeit ergibt sich grob nach folgender Formel:
:<math>t = 0{,}7 \cdot R \cdot C</math>
:<math>R = \frac {t}{0{,}7 \cdot C} </math>

Die Kapazität beträgt 100 nF. Bei 1 ms Pausenzeit beträgt der Widerstand an Versorgungsspannung 14 kΩ und der zum Disch-Eingang 1,4 kΩ. Letztenlich zum Einsatz kam die Paarung 10 kΩ/1 kΩ.

=== Jakobsleiter ===

Aufgrund der geringen Leistung wird die Jakobsleiter nicht überdimensional groß. Als Leiter genügt der für den Lochrasteraufbau übliche Silberdraht. Das untere Ende muss einen sanften Übergang zu den Versorgungsleitungen bilden, ein scharfer Knick führt zu Verzerrungen im elektrischen Feld und der Lichtbogen kommt nicht vom Fleck. Damit der Lichtbogen genug beschleunigt, so dass er auch am oberen Ende abreißt, muss er genug Anlauf bekommen. Die Jakobsleiter darf dabei nicht zu weit auseinander gehen, da sonst kein Speed zustande kommt. Ein leichtes Öffnen ist trotzdem wichtig, denn es hat sich gezeigt, dass ansonsten der Lichtbogen gerne zu weit oben zündet. Die Abriss sollte nicht zu lange sein, sonst tritt wieder der Effekt des einschlafenden Lichtbogens auf, aber auch nicht zu schroff, denn ein Knick bewirkt Zündungen an der falschen Stelle. Nicht nur aus ästhetischen Gründen ist daher das obere Ende bei manchen Aufbauten gekringelt. Einfache gebogene Konstruktionen funktionieren auch.

Insgesamt ist die Konstruktion der Jakobsleiter der fieseligste Teil des Aufbau. Bevor die Funken dauerhaft steigen und nicht ständig einschlafen braucht es eine gewisse Probier- und Lernphase.

[[Bild:Jakobsleiter.svg]]

=== Inbetriebnahme ===

Für das Lochraster-Layout sei hier kein Plan vorgegeben und kann sich jeder selbst zusammenreimen.

Hochspannungsteil aufbauen und Gate, Drain und Source mit Lötbrücke kurzschließen. Wenn alles in Ordnung ist leuchtet die LED permanent. Lötbrücke zwischen Drain und Gate auftrennen dann darf die LED nicht mehr leuchten. Ansonsten ist der MOSFET defekt.

Nun den Schaltungsteil für den Zeitgeber aufbauen, aber noch nicht mit dem MOSFET verbinden. Leuchtet die LED der Versorgungsspannung ist alles in Ordnung. Jetzt Zeitgeber und MOSFET verbinden und Lötbrücke auftrennen. Der Luftspalt zwischen der Jakobsleiter sollte anfangs eher klein sein. Nach dem einstecken leuchten beide LEDs und Funken schlagen über, die Schaltung ist Einsatzbereit.

Bei der Fehlersuche helfen zusätzliche LEDs etwa mit Vorwiderstand Parallel zum Arbeitswiderstand des Inverters oder am Output vom NE555.

Die gesamte Schaltung ist mit der Netzspannung verbunden vor dem Berühren der Schaltung immer Netzstecker ziehen, da Kabelschalter meist nur ein-polig Trennen.

==Material==
* Schraubklemme RM 5,0 zum Netzkabel anschließen
* Sicherung
* Lochrasterplatine ca. 10cm x 10cm
* Netzkabel (Vorsicht: Kabelschalter trennen meist nur einpolig)
* 4x M3 Schraube 25mm und Mutter als Füßchen

=== Hochspannungsteil ===

* 5x 33 kOhm 1W Metallschichtwiderstände zum Kondensatoraufladen
* LED mit 10mA Nennstrom in Reihe zu einem der Ladewiderstände als Funktionsanzeige
* [[FET]] (BUZ90, BUZ91, IRF730 o.ä)
* Zündspule (ZS 1052, Conrad/Voelkner) und passenden Kondensator mit 47 nF/X2 für Schwingkreis
* Brückengleichrichter (B250C800 o.ä.)
* Siebkondensator ≈ 4,7µF/350V
* Entladewiderstand mit ≈ 560 kΩ für den Siebkondensator

=== Taktgenerator ===
* NE555
* Brückengleichrichter (B250C800 o.ä.)
* Siebkondensator ≈ 100 µF
* LED mit passendem Vorwiderstand als Betriebsanzeige
* Stabi LM7812
* Kondensator 0.1µF für Stabi-Ausgang
* Trafo 12V/30 mA o.ä.
* Zeitgeber-Kondensator 0.1 µF
* Zeitgeber-Widerstände 1kΩ + 10kΩ
* BC557B als Inverter für NE555 Ausgang
* Boostkondensator für BC557B 500 pF
* 10 kΩ Basisvorwiderstand für BC557B
* 560 Ω Arbeitswiderstand für BC557B

== Sicherheitshinweise ==

* Trotz Trafo hängt die gesamte Schaltung an Netzpotential.
* Nach dem Ausstecken noch 10 Sekunden warten bis die Kondensatoren sicher entladen sind.
* Kabelschalter trennen nicht immer allpolig, also lieber den Stecker ziehen.
* Um den Hochspannungsanschluss herum die überflüssigen Lötaugen entfernen, sonst verkürzt sich die Funkenstrecke zur Primärseite.
* Vor der Erstinbetriebnahme den Hochspannungsbereich mit Spiritus gründlich von Lötfett befreien
* Beim Lochrasteraufbau ist darauf zu achten, das genügen Abstand zwischen Primär und Hochspannungsseite eingehalten wird.
* Für Schäden durch Hochspannung ist jeder selbst verantwortlich

== Alternativen ==
* Zeilentrafo aus dem Fernseher
* Kfz-Zündspule vom Schrottplatz
* Hochspannungskaskade
* Zwei Mikrowellentrafos (MOT) für ca. 4 kV, vom Schrott
* Neon Sign Transformer (NST), bei Ebay
* Messwandler für Hochspannungsmessung (Potential-Transformer), wenn man sowas hat
* Elektor-Projekt Jakobsleiter (03/2006), für Leute mit Geld
* (Netzteil einer Kaltkathodenröhre (CCFL), meist aber zu schwach)
* Labornetzgerät für Hochspannung, für Leute mit ganz viel Geld

Zündkabel, Anodenkabel, und Laborleitungen haben eine hohe Isolationsspannung, so kann Spannung sicher transportiert werden.

== Weblinks ==
* [http://www.hcrs.at/TVLINE.HTM Hochspannung erzeugen mit Zeilentrafo]
* [http://geocities.com/CapeCanaveral/Lab/5322/hv2.html Snock's High Voltage Page]
;Videos
* '''[http://de.youtube.com/watch?v=DhWgCMReGKk&feature=channel_page Dieses Projekt in Aktion]'''
* [http://de.youtube.com/watch?v=GNbvg9jfDr8&feature=related Jakobsleiter mit NST]
* [http://de.youtube.com/watch?v=CUxbIuxqQl8&feature=related CD mit Hochspannungsbehandlung]
* [http://de.youtube.com/watch?v=CRLCW6alEwc&feature=related Hochspannungslabor]
* [http://de.youtube.com/watch?v=aAYGNcA34UI&feature=related Zeilentrafo im Einsatz]
* [http://www.andreas-kilchenmann.ag.vu/jakobsleiter.html Mikrowellentrafo]

[[Kategorie:Projekte]]
[[Kategorie:Spannungsversorgung und Energiequellen]]