Mikrocontroller.net - Benutzerbeiträge [de]

AVR-GCC-Codeoptimierung

2011-07-01T09:37:22Z

194.94.93.93: /* Compileroption -mint8 für 8-Bit Arithmetik als Default */

Entstanden aus diesem [http://www.mikrocontroller.net/topic/66690 Thread] sollen hier ein paar Hinweise/Erfahrungen gegeben werden, um den Quellcode in Punkto Größe und Geschwindigkeit zu optimieren. ''En detail'' ist das Thema komplex, da es stark von der Codeoptimierung des Compilers abhängt. Es ist im Einzelfall ratsam zu prüfen, ob die eigenen Maßnahmen auch erfolgreich waren. Die Diskussionen [http://www.mikrocontroller.net/topic/132624] bzw. [http://www.mikrocontroller.net/topic/180800#new] können als Anhaltspunkte dienen, wie eine solche Prüfung ablaufen kann.

== Prinzipien der Optimierung ==

Wie so oft sollte man nicht einfach wild drauf los optimieren und sich zunächst ein paar Dinge klar machen.

* Warum will ich optimieren?
* Was kann man sinnvoll optimieren?
* Wieviel Rechenzeit oder Speicher soll dabei gespart werden?
* Wie kann optimiert werden?
* "Verfrühte Optimierung ist die Wurzel allen Übels"

Viele Optimierungen sind "Angst-Optimierungen", die nicht wirklich nötig sind. Die Gefahr mit Optimierungen ist, den Code tot zu optimieren, sprich Lesbarkeit, Portierbarkeit und ggf. Fehlerfreiheit sinken massgeblich. Kurz und knapp in diesem [http://blogs.msdn.com/b/audiofool/archive/2007/06/14/the-rules-of-code-optimization.aspx BLOG] formuliert.

=== Warum ===

Optimieren sollte man nur, wenn
* der Speicher nicht mehr ausreicht (RAM, Flash)
* Die Laufzeit für bestimmte Programmteile zu groß wird und somit bestimmte (Echtzeit-)Ausgaben nicht im erforderlichen Zeitrahmen erledigt werden

Weiter sollte man folgende Punkte gegeneinander abwägen:

* Codeverbrauch
* Datenverbrauch. Statisch/Stack/Heap
* Mittlere Laufzeit/maximale Laufzeit
* Entwicklungszeit
* Portabilität (Compiler, Hardware, ...)
* Verständlichkeit der Quelle, siehe [[Strukturierte Programmierung auf Mikrocontrollern]]
* ABI-Konformität

=== Was ===

Die goldene Regle lautet: 90% der Rechenleistung werden in 10% des Codes verbraucht. Diese 10% muss man finden und zum richtigen Zeitpunkt optimieren. Der Rest muss nur sauber und lesbar geschrieben sein. Was jedoch nichts bringt, ist eine Funktion, die von 1 Minute Programmlaufzeit lediglich 1 Sekunde verbraucht, um den Faktor 10 schneller zu machen. Die Programmlaufzeit sinkt dann von 60 Sekunden auf 59.1 Sekunden. Der Aufwand, die Funktion um einen Faktor 10 schneller zu machen ist aber meistens beträchtlich! Kann ich aber den Code, der für die 59 Sekunden verantwortlich ist um einen Faktor 10 schneller machen, dann sinkt die Gesamtlaufzeit von 60 Sekunden auf 6.9 Sekunden. Dort bringt Optimieren augenscheinlich viel mehr!

Um die optimierungswürdigen Stellen zu finden, muss man sein Programm analysieren. Dazu gibt es verschiedene Möglichkeiten.

====Speicherverbrauch nach Funktionen aufschlüsseln====

;map-File:
:dort sind alle globalen und statischen Variablen enthalten. Eine Map-Datei kann mit den GNU-Tools während des Linkens angelegt werden:
::<pre>> avr-gcc ... -Wl,-Map,foo.map</pre>
: Die Option -Wl bewirkt, daß avr-gcc die angehängen Optionen unverändert an den Linker weiterreicht. Dieser erzeugt dann das Mapfile "foo.map", eine Textdatei.
;avr-size: Mit Tools wie avr-size kann die Platzbelegung einzelner Module ermittelt werden:
::<pre>> avr-size -x foo1.o foo2.o ...</pre>
:bzw. die Platzbelegung der elf-Datei:
::<pre>> avr-size -C --mcu=atmega8 foo.elf</pre>
;avr-nm:
::<pre>> avr-nm --size-sort -S foo.elf</pre>
:ergibt eine Liste mit der Größe aller Objekte: der erste Spalte enthälte die Adresse, die zweite Spalte die Größe, die dritte den Typ und die vierte Spalte den zugehörigen Symbolnamen. Der Typ ergibt sich aus der folgenden Zuordnung, wobei Großbuchstaben globale Symbole kennzeichnen und Kleinbuchstaben Symbole, die Modul-lokal sind:
:;T/t: Objekte in der text-Section: Funktionen, Daten im Flash
:;D/d: Objekte im data-Segment (initialisierte Daten)
:;B/b: Objekte im bss-Segment (Null-initialisierte Daten)

;avr-gcc: Der Compiler hat bereits Informationen über die übersetzten Funktionen, die man direkt zur Analyse verwenden kann. Dazu lässt man avr-gcc die Assembler-Ausgabe, die ohne weiteres Zutun nur als temporäre Datei angelegt wird, abspeichern. Etwa für die Quelldatei foo.c:
::<pre>> avr-gcc -save-temps foo.c -c ...</pre>
:Die Assembler-Datei wird damit als foo.s angelegt und nicht gelöscht. (Das ebenfalls angelegte Präcompilat foo.i wird nicht benötigt). Für jede Funktion gibt avr-gcc 3.4.x im Prolog einen Kommentar der Form<ref>Für avr-gcc 4.x sehen die Kommentare anders aus oder fehlen je nach Compilerversion ganz</ref>
::<pre>/* prologue: frame size=0 */</pre>
:aus, was die Größe des aktuellen Frames angibt. Dies ist der Platz auf dem Stack, der für lokale Variablen benötigt wird. Am besten ist es, wenn die Frame-Size wie im Beispiel gleich 0 ist. Ansonsten sollte man versuchen, diese Größe auf Null zu bringen. Für Variablen, die nicht in Registern gehalten werden können, müssen Speicherzugriffe in den Stack erzeugt werden. Diese machen das Programm sowohl größer aus auch langsamer. Zudem reserviert avr-gcc bei solche Funktionen das Y-Register als Frame-Pointer; das Y-Register steht damit nicht mehr für lokale Variablen zur Verfügung was sich ebenfalls ungünstig auf die Codegüte auswirkt. Ein Grund für das Anlegen eines Frames können zu viele lokale Variablen sein (zB lokale Puffer/Arrays) oder lokale Variablen/Strukturen/Parameter mit ungünstigen Größen, etwa eine 3-Byte große Struktur.

: Neben dieser Information gibt avr-gcc Kommentare der Gestalt
::<pre>/* prologue end (size=2) */</pre>
:aus die darüber informieren, wie viele Register auf dem Stack gesichert wurden.

: Zusammen mit Werkzeugen wie grep, die in jedem Linux und jeder WinAVR-Distribution enthalten sind, findet man schnell Übeltäter wie Funktionen mit Frame.

;Assembler-Code sichten: Ein kurzer Blick auf den erzeugten Assembler-Code zeigt oft, wie gut der Compiler den Code umgesetzt hat. Den erzeugten Assembler-Code zu überfliegen ist wesentlich zeitsparender als selbst in Assembler zu programmieren. Je nach Gusto verwendet man zur Einsicht den Assembler-Code, den avr-gcc ausgibt (s.o.), Assembler-Dumps des Assemblers, List-Files oder HEX-Dumps. Siehe auch<ref>[http://rn-wissen.de/index.php/Assembler-Dump_erstellen_mit_avr-gcc roboternetz.de: Assembler-Dump erstellen mit avr-gcc]</ref>

;Hilfsmittel: einkaufen oder selber bauen. Es gilt herauszufinden, welche Funktion massig Stack durch lokale Variablen verbraucht. Stacktracer können das. Wenn man keinen hat, dann muss man sich eben selber einen bauen, indem man den Stackpointer mitloggt. Zur Not einen Code-Review machen: Alle Funktionen optisch durchgehen und die identifizieren, die viele Variablen anlegen. Dann die Aufrufhierarchie der Funktion feststellen: Wirken sich die vielen Variablen überhaupt aus oder entsteht mein Problem durch eine tiefe Funktionsaufrufhierarchie, bei der zwar wenige Variablen pro Funktion im Spiel sind, aber die Menge der ineinandergeschachtelten Aufrufe 'das Kraut fett macht'
;Profitools: können das alles fast auf Knopfdruck, kosten aber viel Geld

====Laufzeit messen====

*Simulator
*In Echtzeit mittels Testpin, welche an Anfang einer Funktion/Blocks gesetzt wird und am Ende wieder gelöscht wird. Mit einem [[Oszilloskop]] kann man so sehr einfach die Laufzeit messen.

; Anmerkung: Solche Messverfahren liefern immer nur eine ''untere'' Schranke für die Laufzeit, niemals eine obere Schranke. Eine obere Schranke, wie man sie etwa in sicherheitsktitischen Systemen benötigt, liefert eine statische Codeanalyse.

=== Wieviel ===

Der Aufwand von Optimierungen wächst exponentiell. Die letzten paar Prozent brauchen überproportional viel Aufwand.

=== Wie ===

Meist muss man die Wahl treffen ob man Speicher oder Rechenzeit sparen will, beides gleichzeitg geht meist nicht. Das Konzept heißt 'Space for Time' und kann in beide Richtungen verwendet werden. Als Beispiel soll eine komplizierte Berechnung dienen. Diese kann man relativ kompakt in eine Funktion packen, welche dann aber eher langsam ist. Oder man benutzt eine sehr große Tabelle, in welcher die Ergebnisse schon für jeden Eingangswert vorausberechnet wurden. Diese Lösung ist sehr schnell, verbraucht aber sehr viel Speicher.

* Inlining von Funktionen erhöht den Speicherverbrauch, senkt aber die Laufzeit. Beispiel: Funktion A ist 50 Byte groß und wird 10 mal im Programm aufgerufen. Ein Aufruf kostet 10 Byte:
** Ohne Inline: 10 * 10Byte + 50 Byte = 150 Byte Platzverbrauch
** Mit Inline: 10 * 50 Byte = 500 Byte
* Optimierer einschalten
* möglichst keine Floating Point Operationen, besser ist meist [[Festkommaarithmetik]]
* Formeln umstellen und zusammenfassen
* Variablen so klein wie möglich, uint8_t wo's nur geht.
* Wirklich zeitkritische Funktionen und Interrupts als Assemblercode in separater Datei

==Optimierung der Größe==

===GCC-interne Optimierung===

avr-gcc kennt mehrere Optimierungsstufen:
;-O0: Keine Optimierung. Alle lokalen Variablen werden auf dem Stack angelegt und nicht in Registern gehalten. Es werden keine komplexen Optimierungsalgorithmen angewandt; lediglich Konstanten wie 1+2 werden zu 3 gefaltet. Diese Optimierungsstufe erzeugt zusammen mit Debug-Information Code, der sehr gut in einem Debugger nachvollzogen werden kann.
;-O1: Je höher die Optimierungsstufe, desto schwieriger ist der erzeugte Code nachvollziehbar — auch mit Debugger. Diese O-Stufe ist ein Kompromiss zwischen agressiver Optimierung und Nachvollziehbarkeit des erzeugten Codes. Ein ehernes Gesetz in GCC ist, dass er den gleichen Code erzeugen muss unabhängig davon, ob Debug-Information erzeugt wird oder nicht. Im Umkehrschluss erlaubt volle Debug-Unterstützung nicht alle Optimierungen, wozu diese Optimierungsstufe dient.

;-O2: Optimierung auf Geschwindigkeit. Für AVR nur mässig sinnvoll, da sich der Codezuwachs nicht in einem entsprechenden Geschwindigkeitszuwachs transformiert. Dies liegt vor allem daran, daß Sprünge und Funktionsaufrufe auf AVR im Vergleich zu anderen Architekturen sehr billig sind. Es bringt also kaum einen Geschwindigkeitszuwachs, einen Block zu kopieren um einen Sprung zu sparen. Hingegen vergrößert dies den Code deutlich.

;-O3: Ditto. Auf Teufel-komm-raus Funktionen zu inlinen, Schleifen aufzurollen oder gar Funktionen mehrfach für unterschiedliche Aufruf-Szenarien zu implementieren, ist auf einem kleinen µC wie AVR der Overkill.

;-Os: Optimierung auf Codegröße. Die bevorzugte Optimierungsstufe für AVR und viele andere µC.

Jede O-Option ist ein Sammlung von verschiedenen Schaltern, welche bestimmte Optimierungsstrategien aktivieren. Um zu sehen, welche Schalter dies genau sind, erzeugt man wie oben beschrieben mit den Schalten
-fsave-temps -fverbose-asm
die Assembler-Ausgabe von gcc und schaut die Optionen im s-File nach. Einzelne Optionen lassen sich gezielt aktivieren bzw. deaktivieren und damit zum Beispiel zum -Os-Paket hinzufügen.

Eine Ausnahme bildet -O0: Hier ist Code-Optimierung generell deaktiviert, und Optimierungsschalter bleiben ohne Wirkung. -O0 optimiert auf Resourcenverbrauch des /Compilers/ und auf Nachvollziehbarkeit per Debug-Info (so diese erzeugt wird).

Kandidaten dafür für Optimierungsoptionen sind folgende Schalter. -m kennzeichnet maschinenspezifische Schalter, die nur für AVR gültig sind. -f bzw. -fno- sind maschinenunabhängige Schalter, die auch für andere Architekturen verfügbar sind.

;-fno-split-wide-types: Je nach Quelle kann die Deaktivierung von -fsplit-wide-types besseren Code ergeben.

;-fno-inline-small-functions: Relativ kleine Funktionen /immer/ zu inlinen kann den Code unnötig vergrößern, dieser Schalter unterbindet das automatische Inlinen kleiner Funktionen.

;-finline-limit=<n>: Maximale Wert für automatisch geinlinte Funktionen. In einschlägigen Foren werden kleine Werte für den Parameter vorgeschlagem, z.B. 1...3

;-mcall-prologues: Die für aufwändige Funktionen mitunter recht langen push/pop-Sequenzen werden durch Hilfsfunktionen ersetzt. Das kann vor allem bei grossen Programmen Platz sparen. Die Ausführungszeit steigt an.

;-fno-jump-tables: Switch-Statements werden hierdurch mitunter deutlich kürzer.

;-fno-move-loop-invariants -fno-tree-loop-optimize: einige Schleifenoptimierungen, welche die Registerlast erhöhen und für AVR kaum zu einem Geschwindigkeitszuwachs führen, unterbleiben

Generall gilt für all diese Optionen, daß sie abhängig vom Projekt zu einer Codeverbesserung oder -verschlechterung führen können — dies ist i.d.R. vom Projektcode abhängig.

===Statische (globale) Variablen in einer Struktur sammeln===

Das erleichtert dem Compiler die Adressierung, da er den Basiszeiger wiederverwenden kann. Die Codegröße kann dann noch von der Reihenfolge der struct-Member abhängen. Die häufigst benutzte Variable sollte am Anfang stehen, dann kann sie ohne Offset direkt mit dem Basiszeiger adressiert werden. Ansonsten in Gruppen, wie die Variablen auch gebraucht werden. Hier kann man viel rumprobieren.

Beispiel:
<c>
typedef struct
{
uint16_t sec; // Meistbenutze Variable an den Anfang
uint16_t minute;
uint16_t hour;
} time_t;

time_t global; // Globale Struktur definieren
uint8_t min; // Als Vergleich: einzelne globale Variable

int main(void)
{
time_t *time = &global; // Zeiger auf die globale Struktur
// LDI R30,LOW(global) ; Init Z pointer
// LDI R31,(global >> 8) ; Init Z high byte
if (++time->sec == 60)
{
// LDD R16,Z+2 ; Load with displacement
// INC R16 ; Increment
// STD Z+2,R16 ; Store with displacement
// CPI R16,LOW(60) ; Compare
// BRNE ?0005 ; Branch if not equal
}
if ( ++min == 60)
{
// LDS R16,LWRD(min) ; Load direct from SRAM
// INC R16 ; Increment
// STS LWRD(min),R16 ; Store direct to SRAM
// CPI R16,LOW(60) ; Compare
// BRNE ?0005 ; Branch if not equal
}
return 0;
}
</c>

Dadurch, dass die Strukturvariable über LDD/STD (LDD/STD 2 Bytes; LDS/STS 4 Bytes) angesprochen werden kann, werden an dieser Stelle 4 Bytes eingespart.
Hinzu kommen jedoch noch einmal die 4 Bytes für die Initialisierung des Z-pointers, sodass die Einsparung erst bei mehreren Globalvariablen zum Tragen kommt.

; Anmerkung: Dieses Beispiel zeigt sehr schön, daß solcherlei "Optimierung" ohne Wissen um die Arbeitsweise des eingesetzten Compilers nach hinten losgehen können oder ins Leere laufen. Der erzeugte Code (avr-gcc 4.3.3 -Os) ist:
::{|
|<pre>
main:
/* prologue: function */
lds r24,global
lds r25,(global)+1
adiw r24,1
sts (global)+1,r25
sts global,r24
lds r24,min
subi r24,lo8(-(1))
sts min,r24
ldi r24,lo8(0)
ldi r25,hi8(0)
/* epilogue start */
ret
</pre>
|}
: D.h. es wird ''nicht'' indirekt auf die Daten zugegriffen. Grund ist, daß gcc die Adresse zur Compilzeit ermitteln kann und dieses Wissen ausnutzt. Angemerkt sei noch, daß der Code im Beispiel von oben entweder gefaket ist und nicht von einem Compiler stammt (die wahrscheinlichere Variante), oder der Compiler inkorrekten Code erzeugte: Das INC erhöht nur die unteren 8 Bit der Komponenten, welche jedoch 16-Bit Werte sind.

: Dennoch ist die angedeutete Zusammenfassung von ''inhaltlich zusammengehörenden'' Variablen sinnvoll und besser als ein Schwarm frei-flottierender int-Variablen.

===Multiplikationen mit Konstanten===

Der Compiler instanziiert sofort eine teure allgemeine Bibliotheksfunktion, auch wenn es anders ginge. Ich hatte eine einzige 32-bit Multiplikation mit 10 drin, die mir ein mulsi3 beschert hat. Mit a = (b<<3) + (b<<1) geht es in dem Fall kürzer. Wie gesagt, map-File beobachten.
Anmerkung: Variablen als unsigned definieren, dann sollte der Compiler das selbst machen.

;Anmerkung: Auch Schieben ist teuer auf AVR. Schauen wir uns also mal an, was aus folgendem Code wird:

<c>
uint32_t foo (uint32_t i)
{
return i*10;
}

uint32_t bar (uint32_t i)
{
return (i << 1) + (i << 3);
}
</c>

{{Scrollbox|18ex;|
<pre>
00000032 <foo>:
32: 2a e0 ldi r18, 0x0A ; 10
34: 30 e0 ldi r19, 0x00 ; 0
36: 40 e0 ldi r20, 0x00 ; 0
38: 50 e0 ldi r21, 0x00 ; 0
3a: 19 d0 rcall .+50 ; 0x6e <__mulsi3>
3c: 08 95 ret

0000003e <bar>:
3e: 26 2f mov r18, r22
40: 37 2f mov r19, r23
42: 48 2f mov r20, r24
44: 59 2f mov r21, r25
46: 22 0f add r18, r18
48: 33 1f adc r19, r19
4a: 44 1f adc r20, r20
4c: 55 1f adc r21, r21
4e: e3 e0 ldi r30, 0x03 ; 3
50: 66 0f add r22, r22
52: 77 1f adc r23, r23
54: 88 1f adc r24, r24
56: 99 1f adc r25, r25
58: ea 95 dec r30
5a: d1 f7 brne .-12 ; 0x50 <__SREG__+0x11>
5c: 26 0f add r18, r22
5e: 37 1f adc r19, r23
60: 48 1f adc r20, r24
62: 59 1f adc r21, r25
64: 95 2f mov r25, r21
66: 84 2f mov r24, r20
68: 73 2f mov r23, r19
6a: 62 2f mov r22, r18
6c: 08 95 ret

0000006e <__mulsi3>:
6e: ff 27 eor r31, r31
70: ee 27 eor r30, r30
72: bb 27 eor r27, r27
74: aa 27 eor r26, r26

00000076 <__mulsi3_loop>:
76: 60 ff sbrs r22, 0
78: 04 c0 rjmp .+8 ; 0x82 <__mulsi3_skip1>
7a: a2 0f add r26, r18
7c: b3 1f adc r27, r19
7e: e4 1f adc r30, r20
80: f5 1f adc r31, r21

00000082 <__mulsi3_skip1>:
82: 22 0f add r18, r18
84: 33 1f adc r19, r19
86: 44 1f adc r20, r20
88: 55 1f adc r21, r21
8a: 96 95 lsr r25
8c: 87 95 ror r24
8e: 77 95 ror r23
90: 67 95 ror r22
92: 89 f7 brne .-30 ; 0x76 <__mulsi3_loop>
94: 00 97 sbiw r24, 0x00 ; 0
96: 76 07 cpc r23, r22
98: 71 f7 brne .-36 ; 0x76 <__mulsi3_loop>

0000009a <__mulsi3_exit>:
9a: 9f 2f mov r25, r31
9c: 8e 2f mov r24, r30
9e: 7b 2f mov r23, r27
a0: 6a 2f mov r22, r26
a2: 08 95 ret

</pre>
}}

: Der Funktionsaufruf samt Lib-Funktion ist garnicht sooo teuer. Bereits mit zwei Multiplikationen im Programm — auch einer Multiplikation mit einer anderen Konstanten oder einer Variablen — gewinnt die lib-Version, da der Code wiederverwendet wird. Übrigens sind diese Multiplikationsroutinen und auch die in die libgcc enthaltenen Divisionen keine "normalen" Funktionen wie sie von C erzeugt werden. avr-gcc weiß genau, welche Register diese Routinen belegen und welche nicht. Damit ist der Aufruf einer solchen Funktion billiger als ein herkömmlicher Funktionsaufruf, bei dem die Funktion als Blackbox behandelt werden muss, die alle call-clobbered Register zerstört.

===Alle Variablen nur so breit wie nötig===

Hatte ich eigentlich schon, nur an einigen wenigen Stellen war ich da etwas nachlässig. Mitunter reicht ein kleinerer Typ doch, wenn man z. B. vorher geeignet skaliert. Am besten nur die skalaren Typen aus <stdint.h> verwenden, das erleichtert auch das Folgende. Bei RAM Knappheit: kann ich Strings sinnvollerweise aus dem RAM ins Flash verbannen? Kann ich es mir leisten mehrere Flag-Variablen in ein Byte zusammenzufassen, auch wenn dann die Zugriffe möglicherweise etwas langsamer werden.

===Logische Operatoren werden auf int-Größe erweitert===

Obwohl der AVR ein 8-Bit Controller ist, weitet der AVR-GCC an manchen Stellen Vergleiche von zwei 8-Bit Variablen auf 16-Bit auf.
Als Beispiel sei dabei folgendes gezeigt:

<c>
void foo(uint8_t a, uint8_t b)
{
if (a == b)
{
// tue dies
}
if (a == ~b)
{
// tue das
// clr r19 ; clear register
// mov r24,r22 ; copy register
// clr r25 ; clear register
// com r24 ; one's complement
// com r25 ; one's complement
// cp r18,r24 ; compare registers
// cpc r19,r25 ; compare registers with carry
// brne .L1 ; branch if not equal
}
}
</c>
Den zweiten Vergleich mit der Negation weitet der Compiler auf 16 Bit auf.
Ein Cast verhindert dieses:
<c>
void foo(uint8_t a, uint8_t b)
{
if (a == b)
{
// tue dies
}
if (a == (uint8_t) ~b)
{
// tue das
// com r22 ; one's complement
// cp r25,r22 ; compare registers
// brne .L1 ; branch if not equal
}
}
</c>
Die Einsparung an Speicher zwischen den beiden Versionen beträgt 12 Bytes. Außerdem ist die zweite Version um 6 Takte schneller.

;Achtung: Tatsächlich handelt es sich dabei nicht um ein Optimierungsproblem, sondern einen typischen Programmierfehler. Die beiden Varianten sind keineswegs identisch. Bei Variablen vom Typ uint8_t wird der Ausdruck (a == ~b) immer falsch sein (a=0x0000:0x00FF, ~b=0xFF00:0xFFFF).

===Compileroption -mint8 für 8-Bit Arithmetik als Default===

Mit obigen casts überall sähe der Code ziemlich schlimm aus. Blöd auch, wenn man mal einen Type ändert, dann muß man sorgsam nach den zugehörigen casts
suchen. Mit dem Compilerschalter -mint8 wird das zum Standard. Bei mir
hat das etwa 200 Byte gespart! Man sollte dafür aber keine ints mehr im
Code haben, nur noch Typen definierter Größe aus <stdint.h>.
Literal-Werte muß man ggf. anpassen (z. B. mit postfix L long machen)
damit sie nicht überlaufen, Compiler-Warnings beachten. Ist anscheinend
noch etwas experimentell(?), mit dem aktuellen gcc 4.1.1 gibt es eine
Unverträglichkeit in <stdint.h>, der kriegt ein Problem mit den 64-bit Typen. Ist aber wohl in Arbeit, ich habe einen Patch gesehen.

{{Warnung|
;Warnung:Diese Option verändert das Binärinterface! Funktionen, die nicht mit dieser Option übersetzt wurden, sind nicht unbedingt kompatiablen mit solchen, die mit dem Schalter erzeugt wurden. Da die Bibliotheken — auch die Compiler-interne libgcc — ohne diesen Schalter generiert werden, ist mit Problemen zu rechnen. Weiterhin sind bestimmte Typen nicht mehr verfügbar bzw. werden mit anderer Semantik belegt, etwa int und long. Für die Option gibt es in avr-gcc 4.x kein Support mehr.}}

===Stack auf 256 Bytes begrenzen===

Mit dem Compileflag -mtiny-stack wird für den Stack eine einfachere Adressierung möglich, die aber "nur" 256 Byte Stacktiefe erlaubt. Wenn man nicht exzessiv automatische Variablen benutzt (Arrays!) oder eine hohe
Verschachtelungstiefe hat, sollte das ausreichen. Hat mir nochmal knapp 100 Byte (!) kleineren Code erzeugt.

===Speichern von globalen Flags===

Oft werden in den Programmen Flags verwendet um beispielsweise eingetroffene Interrupts in der main-Routine auszuwerten. Hierzu wird üblicherweise eine globale Variable verwendet.

Um den Wert dieser Variable abzufragen, muss sie jedoch erst aus dem SRAM in ein Register geladen werden, und kann dann erst auf ihren Status hin überprüft werden. Eine Möglichkeit ist, der globalen Variablen ein einziges Register fest zuzuordnen:
<c>
register uint8_t counter8_1 asm("r2");
register uint8_t counter8_2 asm("r3");
register uint16_t counter16_1 asm("r4"); // r4:r5
register uint16_t counter16_2 asm("r6"); // r6:r7
</c>
siehe auch: http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_regbind

Als Alternative kann man ein nicht verwendetes Register des I/O-Bereichs verwenden. Dabei würde sich z. B. das Register eines zweiten UARTs, oder das EEPROM-Register anbieten, falls diese nicht benötigt werden.

Neuere AVR-Modelle besitzen für diesen Zweck 3 frei verwendbare Bytes im bitadressierbaren I/O-Bereich: GPIOR0-2.

{{Warnung|
;Warnung: Dieses Vorgehen verändert das ABI! Um dieses Feature fehlerfrei anzuwenden, ist einiges an Wissen über die Interna von GCC notwendig. Auch ein korrekt funktionierendes Programm ist keine Garantie dafür, daß die globalen Register fehlerfrei implementiert wurden. Unter Umständen bringen erst spätere Codeänderungen/-erweiterung den Fehler zum Vorschein, und weil der Fehler vorher nicht akut war, sucht man sich den Wolf an der falschen Stelle im Code anstatt bei der globalen Registern. Siehe auch [[Globale Register]].}}

===Puffern von volatile-Variablen===

Der Compiler behandelt volatile-Variablen bei mehreren Manipulationen wie heiße Kartoffeln. Für jeden einzelnen Vorgang wiederholt sich das Spiel:

* aus dem Speicher holen
* bearbeiten
* zurückspeichern

Unter Umständen ist dieses Verhalten unsinnig. Ein Minimalbeispiel:

<c>
volatile char var;

ISR()
{
var++;

if (var > 100)
var = 0;
}

void main (void)
{
while (1)
printf (var);
}
</c>

Hier wird '''var''' pro [[ISR]]-Ausführung zwei mal aus dem RAM geholt und zurückgeschrieben. Das ist überflüssig, weil die Interruptrountine nicht unterbrochen werden kann. Aus Sicht der ISR bräuchte man eigentlich kein volatile, kann es aber wegen dem Zugriff von main heraus nicht weglassen. Eine Lösung findet sich im folgenden Schnipsel:

<c>
volatile char var;

ISR()
{
char temp = var;

if (++temp > 100)
temp=0;

var = temp;
}

void main (void)
{
while (1)
printf (var);
}
</c>

Hier wird die globale Variable '''var''' in der lokalen Variable '''temp''' gepuffert. Ein Nachteil durch das Anlegen von '''temp''' ergibt sich nicht, da das dafür verwendete Register für die Manipulation sowieso benötigt wird.

Wie alle Optimierungen kann dieses Vorgehen auch nach hinten losgehen: Wenn Laden und Zurückspeichern von '''var''' weit auseinanderliegen (extrem lange ISR), müllt man sich die Register zu. Im schlimmsten Fall wird '''temp''' sogar zwischenzeitlich auf dem Stack ausgelagert.

===Schleifen===

Bei Schleifen, die eine bestimmte Anzahl an Durchläufen ausgeführt werden sollen, ist es besser den Schleifenzähler vorher auf einen Wert zu setzen, und am Ende einer Do-While Schleife diesen zu dekrementieren.
So beschränkt sich die Sprungbedingung auf ein brne (branch if not equal).

Beispiel:
<c>
uint8_t counter;
counter = 100;
do
{
// mach irgendetwas
} while (--counter);
</c>

===Unbenutzte Funktionen und/oder Variablen entfernen===

F: Mir ist aufgefallen, dass der Linker nicht benutzte Funktionen trotzdem mit linkt und Speicherplatz belegt. Gibt es eine Möglichkeit diese Funktionen automatisch weg zu lassen?

A: Dem GNU Linker sagt man mit ''--gc-sections'', dass er unbenutzte Sektionen rauswirft. Mit ''--print-gc-sections'' listet er die rausgeworfenen auch auf. Dem GCC kann man mit ''-ffunction-sections'' sagen, dass er jede Funktion in eine eigene Sektion legt, damit funktioniert das auch unterhalb der Ebene einer Quellcodedatei (also eine Funktion rausschmeissen obwohl fünf andere in derselben Datei gebraucht werden). Mit der Option ''-fdata-sections'' geht das auch für statische Variablen ([http://www.mikrocontroller.net/topic/210453#2084822 Forumsbeitrag von Andreas B.]).

Vorsicht: Je nach Implementierung der Interruptsprung- bzw. Vektorleiste kann es dazu führen, dass alle eigenen Interrupt-Handler ebenfalls wegoptimiert werden. Dies passiert dann, wenn es im Code keinen Verweis (typisch: Ermittlung der Adresse zum Eintrag in eine Interrupt-Vektortabelle oder in Hardwareregister eines Interrupt-Controllers) auf die Handler-Funktion gibt oder die Funktion, in der der Verweis auf eine ISR enthalten ist, nie aufgerufen wird. In solchen Fällen kann es notwendig sein, die Handler mit __attribute__((used)) zu versehen. Bei Verwendung der Makros aus der avr-libc (in WinAVR enthalten, z.B. ISR()) ist dies nicht erforderlich, da das Attribut bereits in den Makro-Definitionen enthalten ist (avr-libc/interrupt.h/ __INTR_ATTRS). In manch anderer Umgebung, wie bei einigen Quellcodes für ARM-basierte Controller, ist das Attribut jedoch zu ergänzen.

==Optimierung der Ausführungsgeschwindigkeit==

Hierzu gibt es schon eine Application-Note von Atmel. Diese AppNote bezieht sich auf den IAR-Compiler. Die darin genannten "Optimierungen" sind für avr-gcc größtenteils obsolet oder bleiben bestenfalls ohne Effekt.

* [http://www.atmel.com/dyn/resources/prod_documents/doc1497.pdf AVR035]: Efficient C Coding for AVR
*[http://en.wikipedia.org/wiki/Program_optimization Program optimization] auf Wikipedia, engl.

== Fußnoten ==
<references/>

[[Category:avr-gcc]]

Absolute Beginner

2010-10-06T12:48:43Z

194.94.93.93: /* Probleme beim Mikrocontroller */

[[Category:Grundlagen]]

==Einleitung==
<div align="center">
Gestern tat es einen Schlag, 
wovon ich hier berichten mag. 

Drosselspulen, Widerstände, 
alles fällt mir in die Hände. 
Da bau ich eine Schaltung auf. 
Ein Kühlblech kommt da auch noch drauf. 
An Einstellreglern rumgedreht, 
bis dann plötzlich nichts mehr geht. 
Elkos hab ich nicht gebraucht, 
Widerstände abgeraucht. 
Jetzt ist die Bude voller Qualm, 
zum Himmel schick ich einen Psalm. 
Transistoren an den Ohren. 
Dioden an den Hoden. 
Kabel am Nabel. 
Phase an der Nase! 
Herzkammer flimmert; kann nur noch fluchen. 
Muß mir ein neues Hobby suchen! 
MfG Paul </div>

 
Dass dieses von Paul so plastisch dargestellte Anfängerszenario gar nicht erst eintritt, werden auf dieser Artikelseite von http://www.mikrocontroller.net einige Dinge aufgeführt, die unbedingt notwendig sind, wenn man sich mit Elektronikbasteleien auseinandersetzt. Die Seite richtet sich bewusst an den absoluten Anfänger um so interessierten Leuten den Einstieg in die Welt der Elektronik und damit auch zum Programmieren von Mikrocontrollern möglichst einfach zu gestalten.

Natürlich ist das Programmieren von Mikrocontrollern auch ohne Elektronikkenntnisse machbar, aber die Aussenanbindung eines Mikrocontrollers zu verstehen ist häufig sinnvoll, so z. B. wenn man ein Signal auswerten möchte.

Die Grundlage für diesen Artikel bildet dieser [http://www.mikrocontroller.net/forum/read-1-344257.html#new Thread] aus dem Forum.

==Sicherheit==

Bleibt gesund! Denkt daran, dass nicht nur Strom und Spannung bei dem neuen interessanten Hobby gefährlich sein können, sondern auch Hitze, Licht (Laser), Schall, Chemikalien (Entwickler, Ätzbäder, Lötrauch) usw. Lieber einmal mehr fragen, als einmal zu wenig. Und vielleicht bewahrt eure Frage euch und den Nächsten vor Schaden!

===Versuchsaufbauten >60V (DC)===
Tipp aus dem Forum [http://www.mikrocontroller.net/topic/181266#1750311]:
<pre>
Diplomand schrieb:
> Oder wie geht es auf'er Arbeit zu in Puncto
> Versuchsaufbauten?

Alles was über 60V (DC) ist muß bei anliegender Spannung
mindestens unter 1 cm dickes Plexiglas.

Gruß Anja
</pre>

==Literatur==
Ohne Lektüre (egal ob in Papierform oder im Internet) wird das mit der Elektronik in Eigenregie nix.
Möchte man sich ernsthaft mit der Materie beschäftigen, so kommt man nicht umhin, sich mit den Grundlagen der Elektronik zu beschäftigen. Während man im Internet viele Schaltungen findet, die einfach nachzubauen sind, bietet sich für das Grundlagenstudium eher ein Buch an. Da gute Elektronikbücher häufig teuer sind, will ich Dir folgenden Tipp geben: Schau einfach mal in die nächste größere Bibliothek. Wenn Dir ein Buch dort gefällt, kannst Du es jederzeit noch kaufen. Wer sich nicht irgendwann mit den Grundlagen beschäftigt, wird nie über das Stadium herauskommen, in dem er Schaltungen aus dem Internet kopiert. Aber unser aller Ziel ist es doch, auch zu verstehen, weshalb hier jetzt genau der rot-rot-schwarze Widerstand rein muss und was er tut...
*'''Fachzeitschriften''' am Kiosk
*'''Internet'''
**'''[http://www.elektronik-kompendium.de/ Das Elektronik Kompendium]''' Ziel von das ELKO ist es die Themen Elektronik, Computertechnik, Kommunikationstechnik und Netzwerktechnik allgemeinverständlich zu erklären und der Allgemeinheit zu präsentieren. Die Zielgruppe sind vor allem Schüler und Auszubildende, die sich mit Elektronik näher beschäftigen müssen oder wollen. Weiterhin sollen alle privat und beruflich an Elektronik interessierte angesprochen werden.
**'''http://www.dse-faq.elektronik-kompendium.de/''' Es gibt zwar von der Startseite des ELKO einen Link zum FAQ, aber es schadet sicher nicht, es hier explizit aufzuführen.
**'''http://www.b-kainka.de/'''
**'''http://www.dieelektronikerseite.de/'''
**'''http://www.howstuffworks.com/'''
**'''Datenblatt (Datasheet)''' zu den meisten Bauteilen, wird vom Hersteller ein Datasheet angeboten. Es ist sinnvoll, dies wenigstens einmal durchzulesen, auch wenn man am Anfang wenig mit den ganzen Fachbegriffen anfangen kann.
**Diverse Application Notes der großen Halbleiterhersteller sind auch immer eine gute Informationsquelle und beschäftigen sich teilweise auch mit sehr grundlegenden Problemen
*'''Bücher'''
**'''[http://www.amazon.com/gp/product/0521370957/103-9884703-3518215?v=glance&n=283155 Art Of Electronics]''' Bitte nur die englische Version nutzen, da die Übersetzung nicht gut gelungen ist.
** '''[http://www.amazon.de/exec/obidos/ASIN/3426037920/qid=1146692611/sr=8-1/ref=sr_8_xs_ap_i1_xgl/302-0461878-1759243 Elektronik ohne Geheimnisse]''' Von der Anfängerschaltung bis zum Radio Franzis-Verlag ISBN 3-426-03792-0
**'''Schaltkreisbastelbuch''' von H.Jakubaschk und das
**'''Radiobastelbuch''' von K.H. Schubert. Das sind sehr alte DDR-Bücher. Aber die sind für Einsteiger äußerst nahrhaft.
**'''Tabellenbuch''' ein beliebiges Elektronik Tabellenbuch, hier findest Du die mathematischen Grundlagen als Formelsammlung. Es wird Dich als Nachschlagewerk bis zur Rente begleiten.
** [http://www.generalatomic.com/teil1/index.html Das Telekosmos-Praktikum (Teil 1)]
** '''[http://www.amazon.de/Elektronik-nicht-schwer-Experimente-Gleichstrom/dp/3921608325 Elektronik - gar nicht schwer]''' Es gibt davon verschiedene Bände. Band 1 ist für den absoluten Einstieg gut, allerdings sind die Schaltungen darin für etwas Fortgeschrittene nicht mehr besonders interesssant. Band 2 hingegen ist sowohl für Einsteiger als auch für Fortgeschrittene empfehlenswert!

==Grundausstattung für das Elektroniklabor==
In der folgenden Liste werden die wichtigsten Bauteile aufgeführt, die in keinem Elektroniklabor fehlen dürfen. Da es eine Unmenge an Angeboten der einzelnen Bauteile gibt, wird auf der Seite [[Standardbauelemente]] darauf hingewiesen, welche Bauteile sich im Laufe der Zeit als sinnvoll dargestellt haben.

* [[Steckbrett]] Mit dem Steckbrett (Breadboard) kann man schnell und ohne Lötkolben eine Schaltung zum Testen aufbauen. Zur Auswahl des richtigen Drahts fürs Steckbrett sind in folgendem Thread nützliche Informationen zu finden: [http://www.mikrocontroller.net/forum/read-1-350462.html#new]

*'''Widerstände:''' 330 Ω, 1 kΩ, 3.3 kΩ, 10 kΩ, 100 kΩ, 1 MΩ (lies: "Ohm"/"Kilo-Ohm"/"Mega-Ohm")
*'''Potentiometer:''' 1 kΩ, 10 kΩ, 100 kΩ
*'''Elektrolytkondensatoren''' ("Elkos"): 1 µF, 10 µF, 470µF, 1000µF, 2200 µF (lies: "Mikro-Farad"). Eine Spannungsfestigkeit von 16 oder 64 Volt ist für den Anfang ausreichend.
*'''Keramikkondensatoren:''' 100 nF, 15pF (letztere für Quarze)
*'''Dioden:''' 1N4148, 1N400X, BAT43 (Schottky)
*'''[[LED]]s''' verschiedenfarbig, je nach Geschmack
*'''[[Transistor]]en:''' BC547, BC557. Dies sind die beiden Standard npn- bzw. pnp-Transistortypen. BC327, BC337 (höherer Kollektorstrom, trotzdem Standard)
*'''Operationsverstärker ("OpAmp"):''' LM324 (der LM741 ist weniger gut geeignet)
*'''Universal-Timer-IC:''' NE555. Wenn man mit 3,3V Mikrocontrollern arbeitet, dann eventuell die nur wenige Cent teureren CMOS-Version wie LM'''C'''555, I'''C'''M7555, TS555, TM'''C'''555, usw. Diese lassen sich mit niedrigeren Betriebsspannungen betreiben (Datenblatt checken!), während der bipolare NE555 etwa mindestens 4,5V benötigt.
*'''[[AVR-Tutorial:_Equipment#Stromversorgung|Spannungsregler]]:''' Ein 7805-Festspannungsregler für die Bereitstellung von 5 V ist sinnvoll, wenn man mal eine Schaltung autark betreiben will. Dann benötigt man in den meisten Fällen noch einen geeigneten Trafo mit einem Brückengleichrichter und einem Glättungskondensator oder ein kleines Steckernetzteil als Basisversorgung für den Spannungsregler. Ein regelbares Netzteil mit Anzeige ist ebenfalls einsetzbar, birgt aber eine Gefahr in sich. Einige ICs, darunter Mikrocontroller, haben enge Betriebsgrenzen, in denen sie funktionieren bzw. oberhalb denen sie sterben (siehe unter ''Absolute Maximum Ratings'' im Datenblatt). Irgendwann ist der Stellknopf am Labornetzteil dann doch höhergestellt, als es dem Chip gut tut...

*'''Schalter''' einfache Schiebeschalter (EIN/AUS)
*'''Taster: ''' Prellfreier Digitaster
*'''Lötnägel''' Sind dazu gedacht, auf Platinen eingelötet zu werden. Auf Breadboards haben sie nichts verloren, weil sie mit einem Durchmesser von 1 mm dafür zu dick sind.

* '''Ein Satz Schnellverbinder-Kabel''' mit Krokodilklemmen an beiden Enden

*'''Draht'''
** dünne Litze,
** dünner isolierter Draht (je dünner desto besser), ideal: Wrap-Draht ca. AWG30, leider etwas schwer erhältlich und teuer,
** dünner blanker verzinnter Draht (möglichst < 0,5mm, leider etwas schwer erhältlich), oder lötbarer Silberdraht.

230V-Litze oder Klingeldraht sollte man zum Aufbau von Lochraster-Schaltungen nicht verwenden. Leitungen mit größerem Querschnitt kommen nur zum Einsatz, wenn ernsthaft Strom fließen soll.

Zur Aufbewahrung der Kleinteile ist ein Sortimentkasten sehr zu empfehlen. Man muss sich nicht von vornherein auf spezielle Bauteile festlegen.

Eine weiterreichende Liste von Standard-Bauelementen findet sich [[Standardbauelemente|hier]].

==Werkzeug==
* Eine eigene '''Bastelecke''', in der ein Aufbau auch mal ein, zwei Wochen [http://www.mikrocontroller.net/topic/15027#104245 liegenbleiben] kann, bis man wieder Lust oder Zeit hat, was daran zu machen. Bau Dir den Schreibtisch vorm PC nicht zu – Du brauchst den Zugang hierher ;-)

* Eine '''stabile Unterlage''', z. B. eine Holzplatte. Die nimmt es im Gegensatz zum Wohnzimmertisch nicht übel, wenn der Lötkolben mal umfällt und einen Brandfleck hinterlässt, oder wenn abgeknipste, scharfe Drahtspitzen (Platinenunterseiten!) kratzen.

* Ein '''kleiner Schraubendreher''' als Allzweckwerkzeug zum Drücken, Klopfen, Justieren, ICs-aus-dem-Sockel-hebeln, Kabel beim Löten Fixieren. Ach ja, Schrauben drehen kann man damit auch.

* Eine gute, spitze '''Pinzette''' zum Greifen und Richten kleiner Bauteile, Drähte einstecken usw. Außerdem eine Klemmpinzette mit flacher Spitze zum Fixieren von Bauteilen.

* Ein '''Seitenschneider''', klein, zum Durchtrennen von Drähten. Opas Kneifzange ist ungeeignet, Omas Handarbeitsschere auch.

* Eine '''Spitzzange''', klein, für alles, wofür die Pinzette nicht kräftig genug ist.

* Eine '''Abisolierzange''', Bauform vgl. Wasserrohrzange. Die symmetrischen mit dem Loch vorne sind eher für Starkstromleitungen gedacht.

* Ein '''Skalpell''' als Allzweckwaffe. Wenn man es einmal hat, will man es nicht mehr missen.

* Eine Grundausrüstung zum Löten. Detaillierte Informationen zum Löten findest Du im Artikel [[Löten_(praktisch)]].
** '''Lötkolben''' mindestens 30 Watt
** ''' Lötzinn''' 1 mm
** '''Lötschwamm '''. Ein gut mit Wasser angefeuchteter Baumwoll-Lumpen (gefaltete "Jute-Tasche") tut es auch.
** '''Entlötlitze'''

* Ein '''Netzteil mit Strombegrenzung''' hilft zu verhindern, dass Dir ständig die Bauteile flöten gehen. Oder Du nimmst deine Schaltungen zunächst mit Batterien oder Akkus in Betrieb, dann kostet es "nur" die Schaltung. Denn bei Batterien/Akkus ist auch darauf zu achten, dass bei einem Kurzschluss sehr hohe Ströme fließen können! Als Strombegrenzung für die Schaltung kann bei kleinen Aufbauten eine 6 V/100 mA Glühlampe in Serie benutzt werden ([http://www.mikrocontroller.net/topic/61119#480376 Forenbeitrag]). Bei einem Kurzschluss heizt sich durch den hohen Strom der Faden auf, die Lampe wird hell, der Widerstand des Fadens nimmt zu, und es können nur die 100 mA zur Schaltung kommen.

* Ein '''[http://de.wikipedia.org/wiki/Multimeter Multimeter]''' zum Messen von Spannungen, Strömen und Widerständen. Eine Überlegung wert ist der Kauf zweier Multimeter, weil man dann z. B. gleichzeitig Strom und Spannung messen kann. Prüfspitzen in Klemmausführung haben den Vorteil, dass man die Hände frei hat für wichtigere Dinge. [http://de.wikipedia.org/wiki/Digitalmultimeter Digitale Multimeter] sind in der Regel günstiger als die analogen (Beispiel: 3,95 € bei [http://www.pollin.de pollin]).

* Ein '''[[Oszilloskop]]''' ist zu Beginn noch nicht unbedingt notwendig. Wenn man sich eine Weile mit der Materie beschäftigt, kommt der Wunsch danach von alleine. Ein kleiner Ratgeber zur Auswahl von Oszilloskopen findet man hier im Wiki. ''Tip:''Für I2C und UART reicht bei niedrigen Raten (bis so 16kHz) oft ein PC-Oszilloskop mit einem etwas veränderten Mikrofonkabel.

* Ein '''Simulationstool''' ist nützlich. Mit Simulationsprogrammen kann man sich viel Zeit und Frust ersparen. Man weiß bereits vor dem Aufbau, ob eine Schaltung NICHT funktionieren wird. Der Umkehrschluss ("Das funktioniert dann auch in Echt") ist leider nicht immer möglich.
:Viele kommerzielle, aber auch kostenlos erhältliche Simulationsprogramme sind Abkömmlinge eines Programms namens '''[[SPICE]]'''. Z.B. enthalten die folgenden Programme nicht ganz zufällig je einen SPICE-Kern für die eigentliche Berechnung. Im Gegensatz zum Original-SPICE bieten sie jedoch den Vorteil einer grafischen Benutzeroberfläche.
** Die '''[http://www.electronicsworkbench.com/ Electronic Workbench]''' (aktuelle Versionen heißen '''NI Multisim''', nachdem der Hersteller von National Instruments übernommen wurde) ist in einigen Fachbüchern (s. Franzis Verlag) als abgespeckte Version mit einem geringeren Umfang an simulierbaren Bauteilen beigelegt und als [http://digital.ni.com/worldwide/germany.nsf/web/all/23834AA0D635C68586257124004EF1C9#3 Studentenversion günstiger erhältlich].
** '''[http://www.linear.com/designtools/software/#Spice SwitcherCAD III/LTspice]''' wird vom Hersteller Linear Technology kostenlos abgegeben. Eigentlich zur Unterstützung bei der Entwicklung von Anwendungen mit Linear Technology Produkten gedacht, enthält es doch einen kompletten SPICE-Kern.
** Das früher sehr populäre '''PSpice''' (erste PC SPICE Version, von der es eine kostenlose ''Student Edition'' gab) wurde mittlerweile von Cadence übernommen und in die OrCAD-Produktlinie integriert. Dabei ist die Student Edition weggefallen. Es gibt statt dessen eine '''[http://www.cadence.com/products/orcad/downloads/orcad_demo/index.aspx OrCAD PCB Demo-CD]''', auf der auch eine eingeschränkte PSpice-Version enthalten ist.
** '''[http://ngspice.sourceforge.net/screens.html ngspice]''' ist eine mit diversen Erweiterungen versehene Freie-Software Version von SPICE für diverse Unix Systeme (Solaris, Linux, Mac OS X, etc.) und Windows XP. Es enthält eine graphische Ausgabe, jedoch selber keine graphische, sondern nur eine Texteingabe. Es ist Teil von '''[http://www.geda.seul.org/ gEDA]''', einer Sammlung von freien ''Electronic Design Automation''-Werkzeugen, zu denen auch '''gschem''' als Schaltplan-Editor gehört. Was zur nächsten Kategorie führt:
** '''[http://qucs.sourceforge.net QUCS]''' ist ein gutes Simulationsprogramm, welches sich nicht nur zu Lernzwecken eignet, sondern auch zur Simulation von "echten" Schaltungen (Bauteilkatalog mit Strg-4 abrufen). Nützlich ist die Einbindung der Graphen direkt in den Schaltungseditor, da man so "alles auf einem Blick hat".
** '''[http://ktechlab.org/ KTechLab]''' ist eine Echtzeitsimulation von analogen und digitalen Bauelementen in Kombination mit PIC-Mikrocontrollern.
** '''[http://www.falstad.com/circuit/ P. Falstads Circuit Simulator]''' ist ein Java-Applet, das man direkt aus dem Browser heraus ausführen kann. Die Möglichkeiten sind zwar nicht ganz so umfangreich wie bei den anderen genannten Simulatoren, trotzdem lässt sich mit dem Applet schnell und einfach eine Schaltung simulieren (Vorteil: Programm muss nicht erst installiert werden)
So kann das gesamte Mikrocontrollerprojekt simuliert werden. Aber auch in die Transistor/Operationsverstärker/Logiktechnik kann man sich mit dem Programm gut
einarbeiten.
* Ein '''Schaltplaneditor''' (''schematic capturer'') ist nützlich z. B.
** '''[http://www.abacom-online.de/html/splan.html sEdit ]''' Software für Windows auch als Freewareversion geeignet.
**'''[http://www.cadsoft.de/ Eagle von Cadsoft]''' Der Quasi-Standard für Hobbyanwender. Es ist zwar etwas gewöhnungsbedürftig in der Bedienung, aber wenn man erstmal dahintergekommen ist, was sich Cadsoft dabei gedacht hat, kann man damit leben. Und mit der Freeware-Version, Light- oder auch Non-Profit-Version kann man schon einiges machen. Früher oder später wirst eh nicht darum herumkommen, auch Platinen zu machen, und dann kannst Du schon auf eine Basis von Schaltplänen zurückgreifen, die Du vorher nur z. B. auf Lochraster aufgebaut hast und brav vorher wenigstens einen Schaltplan davon gezeichnet hast.
** Die bereits erwähnte '''[http://www.cadence.com/products/orcad/downloads/orcad_demo/index.aspx OrCAD PCB Demo-CD]''' enthält eine Demo-Version von '''OrCADE Capture'''.
** Das schon erwähnte '''[http://www.geda.seul.org/tools/gschem/index.html gschem]''' aus der gEDA-Sammlung.
** Die freie Software '''[http://www.lis.inpg.fr/realise_au_lis/kicad/ KiCad]''' für Linux und Windows (siehe auch den Artikel [[KiCAD]]).
:Siehe den Artikel [[Schaltplaneditoren]] für weitere Informationen zu Schaltplaneditoren.

* Ein '''Layout-Editor''' ist nützlich, um den Schaltplan dann in eine Vorlage zum Selbstätzen umzusetzen oder die Platine als Datei zum Leiterplattenhersteller zu senden.
** Das bereits erwähnte '''[http://www.cadsoft.de/ Eagle von Cadsoft]''' gilt auch hier als der Standard im Hobbybereich.
**'''[http://www.ibfriedrich.com TARGET 3001! ]''' vom Ing.-Büro Friedrich ist eine komplette Software vom Schaltplan bis zum Layout, inkl. Simulation oder Isolationsfräsen. Die kostenlose [http://www.ibfriedrich.com/download.htm Discover-Version] geht bis 250 Pins. Einen einfachen Einstieg findet man '''[http://ibfriedrich.dyndns.org/wiki/ibfwikide/index.php?title=Kurzeinführung2 hier]'''.
** In der gEDA-Sammlung für Linux findet man '''[http://www.geda.seul.org/tools/pcb/index.html PCB]''', das allerdings noch Ecken und Kanten hat.
** Das bereits erwähnte '''[http://www.lis.inpg.fr/realise_au_lis/kicad/ KiCad]''' ermöglicht ebenfalls die Erstellung von Platinen-Layouts.
** Zum Aufbau auf Platinen mit '''Lochraster''' oder '''Lochstreifen''' gibt es die Tools [http://www.geocities.com/stripboarddesigner/ Stripboard Designer] (Shareware), [http://veecad.com/ VeeCAD] Stripboard Layout Editor und [http://www.abacom-online.de/html/lochmaster.html Lochmaster] (ca. 40€). Beide Tools laufen ab Windows 95. Alternativ kann man mit Papier und Stift entwerfen oder mit einem Zeichenprogramm ([http://www.mikrocontroller.net/topic/112889 Forenbeitrag]).

* Eine kleine '''(LED-) Taschenlampe''', um Bauteile wie Dioden oder schwach bedruckte IC's zu beleuchten, um deren Beschriftung erkennen zu können. Das Tageslicht kann gelegentlich zu "dunkel" sein.

==Baukästen==
Elektronikbaukästen bieten die Möglichkeit, das was man gelernt hat, gleich praktisch anzuwenden. Sie beinhalten die notwendigen Bauteile und sind oft didaktisch sinnvoll aufgebaut.

*'''Kosmos XN'''
** '''XN1000''' Bereits für Kinder geeignet. Prof. Armstrong und der kleine Roboter Robert führen spielend in die Welt der Elektronik ein.
** '''XN2000''' Die Erweiterung.
** '''XN3000''' Nicht mehr auf Kinder, sondern auf Jugendliche ausgerichtet. Relativ anspruchsvoll, aber verständlich.
** ''Nachteil:'' relativ teuer
*'''Busch-Elektronik-Kästen (Conrad)'''
**''Nachteil:'' Weil die Bauteile auf kleinen Platten befestigt sind, kann man mit ihnen keine eigenen Schaltungen aufbauen.
*'''Polytronic A B C ... (ex. DDR)''' aber nicht um jeden Preis im Kaufhaus kaufen - also Vorstufe zum Steckbrett
*'''Lernpaket Elektronik 2006 (amazon)''' Sehr gut geeignet, da echte ungesockelte Bauelemente die überall nachgekauft werden können.
**''Nachteil:'' Steckbrett wird schnell "zu klein"
*'''Lernpaket Elektronik mit ICs (Franzis)''' Ausgezeichnetes Lernpaket für Theorie und Praxis: '''[http://www.franzis.de/elo-das-magazin/literatur-und-software/experimente/lernpaket-elektronik-mit-ics Lernpaket Elektronik mit ICs]'''
**''Besonders schön:'' Es liegt ein großes Breadboard bei
**''Und dazu:'' Es werden nur kommerzielle Bauelemente eingesetzt, alles ist also nachbestellbar, Erweiterungen sind kein Problem.
*'''Lernpaket Sensortechnik (Franzis)''' Hervorragendes Lernpaket für angewandte Sensorelektronik: '''[http://www.elo-web.de/elektronik-lernpakete/mechatronik/elektrotechnik-industrielle-elektronik/lernpaket-sensortechnik Lernpaket Sensortechnik]'''
**''Inhalt:'' Alle gängigen Sensoren, Opto-, Thermo-, Hall-Sensor etc.
**''Weiterhin:'' Interessante ICs: LM386, 555, Bargraph-Treiber, LEDs etc. etc.
*'''NerdKit''' Steckbrett, AVR Microcontroller, LCD Screen, Temperatursensor, Piezo-Summer und weitere Bauteile. Interessante Projekte finden sich auf der '''[http://www.nerdkits.com/ Nerdkits Webseite]'''. ''Die Dokumentation ist englischsprachig.''

== Sinnvolles Wissen ==
*Es schadet nichts, wenn man das [http://de.wikipedia.org/wiki/Ohmsches_Gesetz ohmsche Gesetz] und die [http://de.wikipedia.org/wiki/Kirchhoffsche_Regeln kirchhoffschen Regeln] kennt.
*http://www.tldp.org/HOWTO/html_single/Coffee/ ;)

== Was tun, wenn es brennt? ==

Hier ist eine Liste der üblichen Anfängerfragen. Bitte überprüfe doch all diese Punkte. Falls Du zu einem der Punkte detaillierte Fragen hast, kannst Du Dich auch an die Experten im Forum wenden. Viel Glück bei der Suche!
*'''Anschlüsse vergessen''' Bevor Du die Schaltung das erste Mal an die Spannungsquelle hängst, überprüfe doch folgendes:
**'''VCC''' und '''GND''' Wurden die Bauteile mit der Versorgungsspannung verbunden? In aller Eile vergisst man dies leicht.
**'''Abblockkondensatoren''' Für sichere Funktion die Abblockkondensatoren (oft 100nF) nahe an den Pins anschließen. Sie sollen Störungen abfangen.
*'''Bauteile richtig herum eingesetzt?'''
*'''Wackelkontakt''' am Breadboard. Die Steckbretter haben leider häufig die Eigenschaft, dass die Kontakte nicht perfekt sind.
*'''korrekte Werte''' Gelegentlich liest man von Newbies, die etwas von 100µF am Quarz schreiben und sich ernsthaft wundern, weshalb nichts schwingt...

===Probleme beim Mikrocontroller===
*'''Quarz schwingt nicht'''. Ein Anzeichen hierfür ist, wenn die Spannung zwischen XTAL1 und GND nicht ungefähr 1/2 VCC beträgt.
*'''Steckkontakte''' sind nicht ok - Steckbretter haben manchmal schlechte Kontakte. Aus diesem Grund ist es sinnvoll, Mikrocontroller mit Sockel auf eine Platine zu löten.
*'''falsche Kondensatoren'''
*'''Bauteil beschädigt'''


==Bezugsquellen==
*'''http://www.csd-electronics.de''' Günstiger Anbieter, führt eigentlich alles was man als Einsteiger braucht, dazu sehr günstig und mit niedrigen Versandkosten. Eine Bestellung aber nur über den Shop zu empfehlen.
*'''http://www.reichelt.de''' Mittel-Günstiger Anbieter, führt leider nicht alles, was das Elektronikerherz begehrt. Der Grund hierfür ist, dass er sich hauptsächlich auf Mainstreamprodukte stützt, die einen großen Absatz finden. Nur so ist der günstige Preis möglich. Mindestbestellwert und Versandkosten nach Deutschland sind sehr günstig. Die Versandkosten ins Ausland sind relativ hoch, weil es für Nicht-Deutschland einen hohen Mindestbestellwert gibt.
* '''http://www.pollin.de''' Diverse Restposten, sehr günstige Preise aber keine große Auswahl an Standardbauteilen.
* '''http://www.conrad.de'''
* '''http://www.ELV.de'''
* '''http://www.segor.de''' Hat manchmal Teile, die man bei Reichelt, Conrad nicht bekommt.

Der Artikel [[Elektronikversender]] zählt viele weitere Versender auf. Doch sollte man darauf achten, dass gerade sogenannte Distributoren in Deutschland normalerweise nicht an Privatleute verkaufen wollen (eine merkwürdige deutsche Spezialität) und mit Privatleuten auch mal sehr ruppig umgehen. Eine Ausnahme machen einige Distributoren für Studenten, da man sich so erhofft, frühzeitig Kontakt zu späteren gewerblichen Kunden zu bekommen. Eine andere Ausnahme sind normale Versender, die sich zusätzlich als Distributoren betätigen.

Steckbrett

2010-10-06T12:12:28Z

194.94.93.93: Tippfehler korrigiert

[[Bild:steckbrett.jpg|miniatur|rechts|280px|zwei zusammengeclipste Steckbretter]]
[[Bild:steckbrett_verbindungen.jpg|miniatur|rechts|280px|interne Verbindungen des Steckbretts in orange]]

Das Steckbrett auch Steckplatine genannt ist eine gute Möglichkeit um schnell einen Prototypen einer Schaltung aufzubauen und in einem iterativen Entwicklungsprozess zu verbessern.
Heutzutage wird auch oft der engl. Begriff [[Breadboard]] verwendet

== Do's and Do Not's beim Arbeiten mit Steckbrettern ==
Nutzer von Steckbrettern bemängeln immer wieder die schlechte Qualität (ausgeleierte Kontakte, auffallend hohe Übergangswiderstände usw.). Viele dieser Probleme entstehen durch unsachgemäße Handhabung. Aus diesem Grund folgt hier eine Aufstellung der Do's and Do Not's:

=== Do Not's ===
* Drahtenden sollten nicht allzu dick sein, da es ansonsten zum ausleiern der Kontakte kommen kann. Notfalls Drahtenden mit dünnerem Draht 'verlängern'.
* Gegurtete Bauteile sollten nicht als Ganzes vom Gurt gelöst und in das Breadboard gesteckt werden, da sich Kleberreste, welche an den Drahtenden haften, sich auf den Kontaktzungen festsetzen und so den Übergangswiderstand dauerhaft erhöhen bzw. sogar gegen unendlich treiben. Diese Bauteile sollten also ausserhalb des gegurteten Bereiches abgezwickt werden.

=== Do's ===
* SIL-Buchsen (Single-in-Line = "Halbe IC-Fassung") für Bauelemente mit kurzen Anschlussdrähten verwenden
* An der Unterseite aufgeklebten Schaumstoff entfernen, dann lassen sich die Kontaktfedern zum reparieren und reinigen herausnehmen
* Die oft verwendeten Metallträgerplatten sind ungünstig: zusätzliche Streukapazität - besser Trägerplatten mit geringer Dielektrizitätskonstante verwenden
* Verschmutzung vermeiden: Kriechströme (Feuchtigkeit)
* Litzen mit Drahtenden und Schrumpfschlauch versehen
* Maximal empfohlene Spannung: 30 V
* Maximal empfohlener Strom: 1 A
* Der Kontaktwiderstand zwischen Kontaktfeder und Anschlussdraht eines Bauelementes beträgt typischerweise 5 - 25 mOhm
* Die Kapazität zwischen Kontaktfedern beträgt ca. 1-2 pF

Hier finden sich viele Beispiele für Breadboard-Schaltungen:
* [http://www.franzis.de/elo-das-magazin ELO-Online-Magazin]
* [http://www.dieelektronikerseite.de Die Elektronikerseite]

== Weblinks ==
* Eine Reihe sehr guter Tipps für die Arbeit mit Breadboards findet sich unter [http://www.elo-web.de/elo/aktuelles-und-uebersicht/tipps-und-tricks Breadboardtipps in ELO-web.de]
* [http://www.national.com/rap/Story/0,1562,8,00.html] Bob Pease zum Thema wann man "solderless breadboards" besser nicht benutzen sollte: "...solderless breadboards are unsuitable for any applications other than medium-speed, medium-impedance-level, and medium-precision circuits."
* [http://tinkerlog.com/2009/01/18/attiny-breadboard-headers/ ATtiny breadboard headers] von Alex
* [http://www.instructables.com/id/My_Top_Ten_Most_Useful_Breadboard_Tips_and_Tricks/?ALLSTEPS My Top Ten Most Useful Breadboard Tips and Tricks] auf www.instructables.com
* [http://diy4fun.blogspot.com/2010/02/atmega-1632-pinout-sticker.html DIY Pinout Sticker] - Pfiffiges, selbstgemachtes Hilfsmittel
* [http://oomlout.co.uk/?p=189 How-to Breadboard Arduino Compatible] (ATmega168)

* Online-Programme:
** [http://rev-ed.co.uk/picaxe/pebble/ Pebble] - Online Layoutprogramm für einfache, kleine Breadboard-Aufbauten
** [http://www.dieelektronikerseite.de/Tools/V-Breadboard/index.html DES-Steckboard]
** [http://www.musicfromouterspace.com/ElectronicTools/virtualbreadboard/index.html VirtualBreadboard]

== Siehe auch ==
* [http://de.wikipedia.org/wiki/Steckplatine de.wikipedia.org/wiki/Steckplatine]
* [http://www.mikrocontroller.net/topic/58204 Diskussion im Forum mit Bezugsquellen]
* [[Breadboard]] Übersicht über verschiedene Prototyp Methoden
* [[SMD 2 Steckbrett Adapter]]
* [[Schaltplaneditoren#Fritzing]]
* [[Lochrasterplatine]]

[[Category:Platinen]]
[[Kategorie:Boards]]