RN-Wissen.de - Benutzerbeiträge [de]

Inline-Assembler in avr-gcc

2014-10-25T11:38:34Z

SprinterSB: /* Quellen */ linkfix

In C versteht man unter '''Inline Assembler''' die Möglichkeit, direkt Assembler-Befehle in den Code einzufügen bzw. die eingefügten Assembler-Befehle selbst.

Neben den einzufügenden Befehlen muss beschrieben werden, welche Nebeneffekte die Befehle auf die Maschine haben und wo/wie Parameter übergeben werden, bzw. wie die Zuordnung von Variablen zu den Registern ist. Diese Beschreibung ist notwendig weil der [[Compiler]] keine Vorstellung davon hat, welche Effekte und Nebenwirkungen die Assembler-Kommandos auf Register, Variablen und Speicher haben, denn der Assembler-Schnippsel ist für den Compiler lediglich eine "Black Box".

Obgleich das dazu verwendete Schlüsselwort <tt>__asm</tt> zum ANSI-C-Standard gehört, ist dies in jedem C-Compiler anders implementiert. Das gilt insbesondere für die Schnittstellenbeschreibung Variablen/Register. Dieser Artikel bezieht sich auf den Inline Assembler von [[avr-gcc]].
Viele Erklärungen aus diesem Artikel sind auch gültig für Inline-Assembler anderer C-Compiler der [[gcc]]-Familie. Instruktionen und Registerklassen werden sich aber unterscheiden, weil diese natürlich abhängig sind vom verwendeten Controller bzw. der Controller-Familie.

=Assembler oder Inline-Assembler?=
;Assembler: Längere und komplexere Code-Stücke sind komfortabler direkt in Assembler auszudrücken. Dazu schreibt man Assembler-Funktionen und ruft diese von C aus auf. Natürlich können auch C-Funktionen von Assembler aus aufgerufen werden. Zudem kann man im Assembler den C-Präprozessor nutzen, was bei Inline-Assembler nur auf C-Ebene geht. Der Build-Prozess wird allerdings komplizierter, da extra asm-Dateien übersetzt werden müssen. Ein typischer Fall ist es, eine komplette ISR in Assembler zu schreiben.
;Inline-Assembler: Mit Inline-Assembler kann man kleine Assembler-Stückchen direkt in den C-Code einbetten. Es muss dann keine Assembler-Funktion aufgerufen werden. Dies kann von der Registerverwendung her deutlich günstiger sein, da [[gcc]] genau weiß, welche Register gebraucht werden und welche nicht.
:Eine (Assembler-)Funktion ist hingegen eine Black Box, bei der von der Standard-[[avr-gcc/Interna#Registerverwendung|Registerverwendung]] ausgegangen werden muss, auch wenn weniger Register in der Funktion verwendet werden. Ein Funktionsaufruf bedeutet also meistens einen Laufzeit-Overhead im Vergleich zu einem Inline-Code.
:Bei mehrfacher Verwendung einer längeren Codesequenz ist eine Funktion jedoch sparsamer im [[Flash]]-Verbrauch. Legt man eine Funktion als C-Funktion an und ihren Body als Inline-Assembler (eine s.g. Stub-Funktion, von engl. ''Stub'' = Stumpf), dann übernimmt gcc das Verwalten von Funktions-Argumenten, return-Wert, etc. und man brauch sich nicht selber um die Aufruf-Konvention zu kümmern. Auch innerhalb einer Funktion kann C mit Assembler gemischt werden.
:Ein Vorteil von Inline-Assembler ist, daß eine C-Funktion, die Inline-Assembler enthält, vom C-Compiler [[C-Tutorial#Inlining|geinlinet]] werden kann. Dies ist mit einer reinen Assembler-Funktion nicht möglich.

=Begriffe=
;Assembler-Template: Das Template (''Schablone'') ist ein statischer, konstanter String im Sinne von C. Es enthält die Assembler-Befehle sowie Platzhalter, in deren Stelle später die Operanden treten
;Constraint: Die Constraints (''Nebenbedingungen'') beschreiben Einschränkungen an die zu verwendeten Register. Dies ist notwendig, da nicht alle Maschinenbefehle auf alle Register anwendbar sind
;Clobber-List: Das ist eine Liste von Registern, deren Inhalt durch den Inline-Assembler zerstört wird

=Syntax und Semantik=
Das Schlüsselwort, um eine Inline-Assembler Sequenz einzuleiten, ist <tt>__asm</tt> (ANSI). Oft ist auch <tt>asm</tt> oder <tt>__asm__</tt> verwendbar. Um zu kennzeichnen, daß die Sequenz keinesfalls wegoptimiert werden darf – etwa dann, wenn der Assembler keine Wirkung auf C-Variablen hat – wird dem <tt>asm</tt> ein <tt>volatile</tt> bzw. <tt>__volatile</tt> nachgestellt. Danach folgen in runden Klammern die durch <tt>''':'''</tt> getrennten Abschnitte des Inline-Assemblers:
asm volatile ([[#Assembler-Template|asm-template]] : [[#Operanden und Constraints|output-operand-list]] : [[#Operanden und Constraints|input-operand-list]] : [[#Clobbers|clobber-list]]);

Abschnitte, die leer sind, können auch weggelassen werden, wenn dahinter kein weiterer Abschnitt folgt:
asm volatile (asm-template);

Oder, wenn weder Input- noch Output-Operanden gebraucht werden, aber Register oder Speicher verändert werden:
asm volatile (asm-template ::: clobber-list);

{{FarbigerRahmen |
Aus Compiler-Sicht werden die Assembler-Befehle im Template parallel, also ''gleichzeitig'' ausgeführt! Dies ist zu bedenken, wenn Register sowohl als Input als auch als Output verwendet werden.
}}

Ab Version 4.5 kennt GCC <tt>asm goto</tt>, mit dem ausgedrückt werden kann, dass der Codefluß des Assembler-Teils u.U. zu einem Stück C-Code springt:
asm goto ([[#Assembler-Template|asm-template]] : {{comment|Leer}} : [[#Operanden und Constraints|input-operand-list]] : [[#Clobbers|clobber-list]] : [[#asm goto mit C-Labels|C-labels]]);

== Assembler-Template ==

Im Template stehen die durch Zeilenumbrüche getrennten Assembler-Befehle. Das Template kann zudem <tt>%</tt>-Ausdrücke als Platzhalter enthalten, welche durch die Operanden ersetzt werden. Dabei bezieht sich <tt>%0</tt> auf den ersten Operanden, <tt>%1</tt> auf den zweiten Operanden, etc.
Die Operanden selbst werden im zweiten und dritten Abschnitt des Templates als Komma-getrennte Liste angegeben.
Diese Ersetzung findet jedoch nur dann statt, wenn das asm nicht nur aus einem String besteht:
asm ("10% mehr"); {{comment|"10% mehr"}}
asm ("10%% mehr" :); {{comment|"10% mehr"}}

Ein Platzhalter kann zusätzlich einen einbuchstabigen Modifier enthalten, um den Operanden in printf-ähnlicher Manier in einem speziellen Format darzustellen. Wird z.B. ein Wert ab Register <tt>r28</tt> (dem Y-Register) gehalten, dann wären folgende Ersetzungen denkbar (als erstes Argument):

:<tt>%0     →  r28</tt>

:<tt>%A0    →  r28</tt><br/>
:<tt>%B0    →  r29</tt><br/>
:<tt>%C0    →  r30</tt><br/>
:<tt>%D0    →  r31</tt>

:<tt>%a0    →  y  </tt>

Im einfachsten Falle enthält das Templater nur einen Befehl:
"nop"
oder sogar garkeinen Befehl oder lediglich einen Kommentar:
"; ein Kommentar"

:{| {{Blauetabelle}}
|+ '''Tabelle: asm-Platzhalter und ihre Modifier, Sonderzeichen'''
|- {{Hintergrund1}}
! Platzhalter || wird ersetzt durch || AVR-spezifisch
|- valign="top"
|<tt>%''n''</tt> || Wird ersezt durch Argument <tt>''n''</tt> mit <tt>''n''</tt> = 0...9
|
|- valign="top"
|<tt>%A''n''</tt> || das erste (untere) Register des Arguments <tt>''n''</tt> (Bits 0...7)
|align="center" rowspan="4"| '''X'''
|- valign="top"
|<tt>%B''n''</tt> || das zweite Register des Arguments <tt>''n''</tt> (Bits 8...15)
|- valign="top"
|<tt>%C''n''</tt> || das dritte Register des Arguments <tt>''n''</tt> (Bits 16...23)
|- valign="top"
|<tt>%D''n''</tt> || das vierte Register des Arguments <tt>''n''</tt> (Bits 24...31)
|- valign="top"
|<tt>%a''n''</tt> || Ausgabe des Arguments als Adress-Register,<br/>also als <tt>x</tt>, <tt>y</tt> bzw. <tt>z</tt>. Erlaubt zusammen mit Constraint <tt>b</tt>, <tt>e</tt>, <tt>x</tt>, <tt>y</tt>, <tt>z</tt>
|align="center"| '''X'''
|- valign="top"
|<tt>%i''n''</tt> || Ab 4.7. Ausgabe einer RAM-Adresse als I/0-Adresse. Beispiel: <tt>0x30</tt> wird auf Xmega-Controllern als <tt>0x30</tt> ausgegeben und auf nicht-Xmega als <tt>0x10</tt>.
|align="center"| '''X'''
|- valign="top"
|<tt>%r''n''</tt> || Ab 4.8. Ausgabe eines Registers ohne die Register-Präfix "r". Damit kann per Inline-Assembler auf 64-Bit Variablen zugegriffen werden, z.B. kann mit <tt>"clr %r0+7"</tt> das High-Byte gelöscht werden.
|align="center"| '''X'''
|- valign="top"
|<tt>%T''n''%T''m''</tt> || Ab 4.7. Gibt einen Doppel-Operanden aus wie er zum Beispiel in BLD oder BST benötigt wird, d.h. durch ein Komma getrennte Register- und Bitnummer. Das erste <tt>%T</tt> erhält ein Register und speichert es zwischen bis zum nächsten <tt>%T</tt>, das die konstante Bitnummer ''m'' enthält. Die Ausgabe erfolgt erst mit dem zweiten <tt>%T</tt>: Beispielsweite kann durch folgende Zeile das High-Bit von ''var'' gelöscht werden:
asm ("clt $ bld %T[v]%T[b]" : [v] "+r" (var) : [b] "n" (8*(sizeof var)-1));
|align="center"| '''X'''
|- valign="top"
|<tt>%T''n''%t''m''</tt> || Ab 4.7. Funktioniert wie <tt>%T''n''%T''m''</tt>, es wird aber nur das zum Bit ''m'' gehörende Register ausgegeben, d.h. weder Komma noch Bitnummer.
|align="center"| '''X'''
|- valign="top"
|<tt>%x''n''</tt> || Ab 4.5. Gibt ein Label ohne Operand-Modifier <tt>gs()</tt> aus.
|align="center"| '''X'''
|- valign="top"
|<tt>%~</tt> || wird auf AVR mit Flash bis max. 8kiByte durch ein <tt>r</tt> ersetzt, ansonsten bleibt es leer.<br/>Zum Aufbau von Sprungbefehlen, etwa "<tt>%~call foo</tt>"
|align="center"| '''X'''
|- valign="top"
|<tt>%!</tt> || Ab 4.4. Wird auf AVR mit Flash ab 128kiByte durch ein <tt>e</tt> ersetzt, ansonsten bleibt es leer.<br/>Zum Aufbau von indirekten Sprungbefehlen, etwa "<tt>%!icall</tt>"
|align="center"| '''X'''
|- valign="top"
|<tt>%=</tt> || eine für dieses asm-Template und die Übersetzungseinheit eindeutige Zahl.<br/>Zum Aufbau lokaler Sprungmarken.
|
|- {{Hintergrund1}}
! Sequenz || wird ersetzt durch Sonderzeichen || AVR-spezifisch
|- valign="top"
|<tt>%%</tt> || das <tt>%</tt>-Zeichen selbst
|
|- valign="top"
|<tt>\n</tt> || ein Zeilenumbruch zum Trennen mehrerer asm-Befehle/Zeilen
|
|- valign="top"
|<tt>$</tt> || trennt mehrere Befehle in der gleichen Zeile
|align="center"| '''X'''
|- valign="top"
|<tt>\t</tt> || ein TAB, zur Übersichtlichkeit im erzeugten asm ||
|- valign="top"
|<tt>\"</tt> || ein <tt>"</tt> wird eingefügt ||
|- valign="top"
|<tt>\\</tt> || das <tt>\</tt>-Zeichen selbst ||
|- {{Hintergrund1}}
! Kommentar || Beschreibung || AVR-spezifisch
|- valign="top"
|<tt>; ''Text''</tt> || einzeiliger Kommentar bis zum Ende des Templates bzw. nächsten Zeilenumbruch
|align="center"| '''X'''
|- valign="top"
|<tt>/* ''Text'' */</tt> || mehrzeiliger Kommentar wie in C ||
|}

== Operanden und Constraints ==

Ein Operand besteht aus der Angabe des Constraint-Strings (also der Registerklasse und Kennzeichnung, ob es sich um einen Output-Operanden handelt) und dahinter in runden Klammern der C-Ausdruck, der in Register der angegebenen Klasse geladen werden soll. Die Operanden werden mit 0 beginnend von links nach rechts durchnumeriert und über diese Nummer angesprochen, um sie ins Assembler-Schnippsel einzufügen.

Mehrere Input- bzw. Output-Operanden werden durch Komma getrennt.

:{| {{Blauetabelle}}
|+ '''Tabelle: Constraints und ihre Bedeutung'''
|- {{Hintergrund1}}
! Constraint || Register || Wertebereich
|rowspan="14"| 
! Constraint || Konstante || Wertebereich
|-
|<tt>a</tt>||einfache obere Register||<tt>r16</tt>...<tt>r23</tt>
|<tt>G</tt>||Floatingpoint-Konstante ||<tt>0.0</tt>
|-
|<tt>b</tt>||Pointer-Register ||<tt>y</tt>, <tt>z</tt>
|<tt>i</tt>||Konstante, entspricht <tt>"sn"</tt> || 
|-
|<tt>d</tt>||obere Register ||<tt>r16</tt>...<tt>r31</tt>
|<tt>s</tt>||symbolischer Wert ||  
|-
|<tt>e</tt>||Pointer-Register ||<tt>x</tt>, <tt>y</tt>, <tt>z</tt>
|<tt>n</tt>||Wert bekannt zur Compilezeit || 
|-
|<tt>l</tt>||untere Register ||<tt>r0</tt>...<tt>r15</tt>
|<tt>I</tt>||positive 6-Bit-Konstante ||0...63
|-
|<tt>q</tt>||Stack-Pointer ||<tt>SPH:SPL</tt>
|<tt>J</tt>||negative 6-Bit Konstante ||<tt>-</tt>63...0
|-
|<tt>r</tt>||ein Register ||<tt>r0</tt>...<tt>r31</tt>
|<tt>M</tt>||8-Bit Konstante ||0...255
|-
|<tt>t</tt>||Scratch-Register ||<tt>r0</tt>
|colspan="3" | 
|-
|<tt>w</tt>||obere Register-Paare ||<tt>r24</tt>, <tt>r26</tt>, <tt>r28</tt>, <tt>r30</tt>
!{{Hintergrund1}}| Constraint ||{{Hintergrund1}}| Memory ||{{Hintergrund1}}| Wertebereich
|-
|<tt>x</tt>||Pointer-Register X ||<tt>x</tt> (<tt>r27:r26</tt>)
|<tt>m</tt>|| Memory ||  
|-
|<tt>y</tt>||Pointer-Register Y ||<tt>y</tt> (<tt>r29:r28</tt>)
|colspan="3" rowspan="3"| 
|-
|<tt>z</tt>||Pointer-Register Z ||<tt>z</tt> (<tt>r31:r30</tt>)
|-
|<tt>0</tt>...<tt>9</tt>||colspan="2"|Identisch mit dem angegebenen Operanden<br/>Wird verwendet, wenn ein Operand sowohl als Input<br/>als auch als Output dient, um sich auf diesen<br/>Operanden zu beziehen
|}

:{| {{Blauetabelle}}
|+ '''Tabelle: Constraint Modifier'''
|- {{Hintergrund1}}
!Modifier || Bedeutung
|-
|<tt>=</tt> || der Operand ist Output-Operand
|-
|<tt>&</tt> || diesen Operanden ''nicht'' als Input-Operanden verwenden,<br/>sondern nur als Output-Operand
|-
|<tt>+</tt> || dieser Operanden ist Input- und Output-Operand
|}

Ein Input-Operand könnte also so aussehen, wobei <tt>foo</tt> eine C-Variable ist. Als Register dient ein (je nach Typ von <tt>foo</tt> auch mehrere) obere Register, irgendwo von <tt>r16</tt> bis <tt>r31</tt> (Constraint <tt>"d"</tt>):
"d" (foo)

In den Klammern kann ein beliebiger, gültiger C-Ausdruck stehen, der beim folgenden Beispiel in irgendeinem Register landet (Constraint <tt>"r"</tt>), ohne weitere Einschränkung an das Register:
"r" ((foo >= 0) ? foo : -foo)

Um einen Operanden als Output-Operanden zu kennzeichnen, wird dem Constraint ein <tt>"="</tt> vorangestellt.
Soll <tt>foo</tt> ein Output-Operand sein, der in den Registern <tt>r0</tt>...<tt>r15</tt> landen soll (Constraint <tt>"l"</tt>, sieht es so aus. Dabei muss <tt>foo</tt> ein sogenannter Lvalue sein, also ein Wert, dem etwas zugewiesen werden kann:
"=l" (foo)

Ist <tt>foo</tt> sowohl Input als auch Output, schreibt man <tt>foo</tt> als Output- und als Input-Operand hin. In der Input-Constraint bezieht man sich dann auf die Operanden-Nummer von <tt>foo</tt>. Hier ein komplettes Beispiel, das die Nibbles von <tt>foo</tt> tauscht. Weil <tt>swap</tt> auf alle Register anwendbar ist, kann als Registerklasse <tt>"r"</tt> genommen werden:
<pre>
unsigned char foo;
...
asm ("swap %0" : "=r" (foo) : "0" (foo));
</pre>
<tt>foo</tt> als Input-Operand soll im gleichen Register liegen wie <tt>foo</tt> als Output-Operand. Daher wird als Constraint <tt>"0"</tt> angegeben, d.h. es wird ins gleiche Register geladen wie der Operand Numero 0 <tt>"r" (foo)</tt>.

=== Benannte Constraints ===

Um das Assembler-Schnippsel besser lesbar zu halten, kann man Constraints einen Namen geben:
asm ("swap %[bar]" : [bar] "+r" (foo));
Damit ist der Assembler auch unabhängig von der Reihenfolge der Operanden. Das macht die Anpassung, wenn ein neuer Operand hinzukommt, wesentlich einfacher und den Schnippsel zudem besser lesbar.

Hier wird <tt>bar</tt> als Alias für die C-Variable <tt>foo</tt> benutzt; es könnte aber auch jeder andere gültige C-Bezeichner sein, also insbesondere auch <tt>foo</tt>.

=== Instruktionen und Constraints ===

Die folgende Tabelle enhält eine Auflistung von AVR-Instruktionen und dazu passende Argumente bzw. Constraints. Nicht alle Shorthands sind in der Tabelle enthalten, so ist "<tt>clr Rn</tt>" nur eine Abkürzung für "<tt>eor Rn, Rn</tt>", ähnliches gilt für den Zoo von Instruktionen rund um das SREG wie branch, bit set, bit clear, etc., die im Endeffekt auf nur vier Instruktionen abbilden. Instruktionen wie <tt>nop</tt>, die keine Argumente brauchen, sind ebenfalls nicht in der Tabelle enthalten. Gleiches gilt für den Krypto-Befehl <tt>des</tt>, für die keine Constraint verfügbar ist.

<tt>"load"</tt> ist ein <tt>"load from SRAM"</tt><br/>
<tt>"store"</tt> ist <tt>"store to SRAM"</tt><br/>

:{| {{Blauetabelle}}
|+'''Tabelle: Übersicht AVR-Instruktionen und passende Constraints'''
|- {{Hintergrund1}}
!Mnemonic || Constraint ||Bedeutung ||rowspan="35"| 
!Mnemonic || Constraint ||Bedeutung
|-
| <tt>adc</tt>||<tt>r,r</tt> || add with carry
| <tt>add</tt>||<tt>r,r</tt> || add
|-
| <tt>adiw</tt>||<tt>w,I</tt> || add immediate to word
| <tt>and</tt>||<tt>r,r</tt> || and
|-
| <tt>andi</tt>||<tt>d,M</tt> || and with immediate
| <tt>asr</tt>||<tt>r</tt> || arithmetic shift right
|-
| <tt>bclr</tt>||<tt>I</tt> || bit clear in SREG
| <tt>bld</tt>||<tt>r,I</tt> || bit load from T
|-
| <tt>brbc</tt>||<tt>I,label</tt> || branch if bit in SREG clear
| <tt>brbs</tt>||<tt>I,label</tt> || branch if bit in SREG set
|-
| <tt>bset</tt>||<tt>I</tt> || bit set in SREG
| <tt>bst</tt>||<tt>r,I</tt> || bit store from T
|-
| <tt>cbi</tt>||<tt>I,I</tt> || clear bit in I/O
| <tt>com</tt>||<tt>r</tt> || complement
|-
| <tt>cp</tt>||<tt>r,r</tt> || compare
| <tt>cpc</tt>||<tt>r,r</tt> || compare with carry
|-
| <tt>cpi</tt>||<tt>d,M</tt> || compare against immediate
| <tt>cpse</tt>||<tt>r,r</tt>|| compare, skip if equal
|-
| <tt>dec</tt>||<tt>r</tt> || decrement
| <tt>[e]lpm</tt>||<tt>r,z</tt>|| load from program memory<sup>1</sup>
|-
| <tt>eor</tt>||<tt>r,r</tt> || exclusive-or
| <tt>fmul*</tt>||<tt>a,a</tt> || fractional multiply
|-
| <tt>in</tt>||<tt>r,I</tt> || input from I/O
| <tt>inc</tt>||<tt>r</tt> || increment
|-
| <tt>lac</tt>||<tt>z,r</tt> || load and clear
| <tt>lat</tt>||<tt>z,r</tt> || load and toggle
|-
| <tt>las</tt>||<tt>z,r</tt> || load and set
|colspan="3"|  
|-
| <tt>ld</tt>||<tt>r,e</tt> || load indirect
| <tt>ld</tt>||<tt>r,e+</tt> || load indirect, post-increment
|-
| <tt>ld</tt>||<tt>r,-e</tt> || load indirect, pre-decrement
| <tt>ldd</tt>||<tt>r,b+I</tt> || load indirect with displacement
|-
| <tt>ldi</tt>||<tt>d,M</tt> || load immediate
| <tt>lds</tt>||<tt>r,label</tt> || load direct from SRAM
|-
| <tt>lpm</tt>||<tt>t,z</tt> || load from program memory<sup>1</sup>
| <tt>lsr</tt>||<tt>r</tt> || logical shift right
|-
| <tt>mov</tt>||<tt>r,r</tt> || move
| <tt>movw</tt>||<tt>r,r</tt> || move word
|-
| <tt>mul</tt>||<tt>r,r</tt> || multiply unsigned
| <tt>muls</tt>||<tt>d,d</tt> || multiply signed
|-
| <tt>mulsu</tt>||<tt>a,a</tt> || multiply signed/unsigned
|colspan="3"|  
|-
| <tt>neg</tt>||<tt>r</tt> || negate
| <tt>or</tt>||<tt>r,r</tt> || or
|-
| <tt>ori</tt>||<tt>d,M</tt> || or with immediate
| <tt>out</tt>||<tt>I,r</tt> || output to I/O
|-
| <tt>pop</tt>||<tt>r</tt> || pop from Stack
| <tt>push</tt>||<tt>r</tt> || push to Stack
|-
| <tt>ror</tt>||<tt>r</tt> || rotate right
|colspan="3"|  
|-
| <tt>sbc</tt>||<tt>r,r</tt> || subtract with carry
| <tt>sbci</tt>||<tt>d,M</tt> || subtract with carry immediate
|-
| <tt>sbic</tt>||<tt>I,I</tt> || skip if bit in I/O clear
| <tt>sbis</tt>||<tt>I,I</tt> || skip if bit in I/O set
|-
| <tt>sbi</tt>||<tt>I,I</tt> || set Bit in I/O
| <tt>sbiw</tt>||<tt>w,I</tt> || subtract immediate from word
|-
| <tt>sbrc</tt>||<tt>r,I</tt> || skip if bit in register clear
| <tt>sbrs</tt>||<tt>r,I</tt> || skip if bit in register set
|-
| <tt>st</tt>||<tt>e,r</tt> || store indirect
| <tt>st</tt>||<tt>e+,r</tt> || store indirect, post-increment
|-
| <tt>st</tt>||<tt>-e,r</tt> || store indirect, pre-decrement
| <tt>std</tt>||<tt>b,r</tt> || store indirect with displacement
|-
| <tt>sts</tt>||<tt>label,r</tt> || store direct
| <tt>sub</tt>||<tt>r,r</tt> || subtract
|-
| <tt>subi</tt>||<tt>d,M</tt> || subtract immediate
| <tt>swap</tt>||<tt>r</tt> || swap nibbles
|-
| <tt>xch</tt>||<tt>z,r</tt> || exchange
|colspan="3"| 
|}

<sup>1</sup> Je nach Derivat werden die folgenden <tt>lpm</tt>-Ausprägungen unterstützt oder nicht:
* <tt>lpm</tt>
* <tt>lpm r,z</tt> bzw. <tt>lpm r,z+</tt>
* <tt>elpm</tt>
* <tt>elpm r,z</tt> bzw. <tt>elpm r,z+</tt>

Hier noch ein paar der gebräuchlichsten Shorthands und deren Abbildung auf "Basis"-Instruktionen:

:{| {{Blauetabelle}}
|+'''Tabelle: Shorthands'''
|- {{Hintergrund1}}
!Shorthand || gleichbedeutend mit || Bedeutung ||rowspan="5"| 
!Shorthand || gleichbedeutend mit || Bedeutung
|-
| <tt>rol r</tt> || <tt>adc r,r</tt> || rotate left
| <tt>cbr r,M</tt> || <tt>andi r, ~M</tt> || clear bits in reg
|-
| <tt>clr r</tt> || <tt>eor r,r</tt> || clear reg to zero
| <tt>lsl r</tt> || <tt>add r,r</tt> || logical shift left
|-
| <tt>sbr d,M</tt> || <tt>ori d, M</tt> || set bits in reg
| <tt>ser d</tt> || <tt>ldi d, 0xff</tt> || set all bits in reg
|-
| <tt>tst r</tt> || <tt>and r,r</tt> || test against zero
|colspan="3"| 
|}

==Clobbers==

In der Komma-getrennten Clobber-Liste kann man angeben, welche Register durch den Inline-Assembler ihren Wert ändern. Ändern z.B. <tt>r2</tt> und <tt>r3</tt> ihre Werte, dann ist die Clobber-Liste
"r2", "r3"

Wird schreibend auf das RAM zugegriffen, dann muss man das auch mitteilen, damit RAM-Inhalte, die sich evtl. in Registern befinden, nach dem Inline-Assembler neu gelesen werden. Der Clobber dafür ist:
"memory"

'''Beispiel:'''

Es soll ein Inline-Assembler geschrieben werden, das den Inhalt zweier aufeinanderfolgender Speicherstellen austauscht. Die Adresse soll in <tt>addr</tt> stehen. Sie ist Input-Operand und muss in Register X, Y oder Z stehen, um den <tt>ld</tt> bzw. <tt>st</tt>-Befehl anwenden zu können. Die passende Constraint ist also <tt>"e"</tt>. Nach der Sequenz liegt <tt>addr</tt> unverändert vor.
<pre>
asm volatile (
"ld r2, %a0+" "\n\t"
"ld r3, %a0" "\n\t"
"st %a0, r2" "\n\t"
"st -%a0, r3"
: /* keine Output-Operanden */
: "e" (addr)
: "r2", "r3", "memory"
);
</pre>
avr-gcc entscheidet sich dazu, das Z-Register für <tt>addr</tt> zu verwenden:
<pre>
ld r2, Z+
ld r3, Z
st Z, r2
st -Z, r3
</pre>

Günstiger ist es jedoch, dem Compiler auch die Entscheidung zu überlassen, welche(s) Register als Hilfsregister verwendet werden sollen. Ein Register kann <tt>__tmp_reg__</tt> sein, für das zweite legen wir eine lokale 8-Bit-Variable <tt>hilf</tt> an:
<pre>
{
char hilf;

asm volatile (
"ld __tmp_reg__, %a1+" "\n\t"
"ld %0, %a1" "\n\t"
"st %a1, __tmp_reg__" "\n\t"
"st -%a1, %0"
: "=&r" (hilf)
: "e" (addr)
: "memory"
);
}
</pre>
<tt>__tmp_reg__</tt> (also <tt>r0</tt>) brauch nicht in die Clobber-Liste aufgenommen zu werden. Um das zweite benötigte Register (hier <tt>r24</tt>, in dem <tt>hilf</tt> lebt) kümmert sich avr-gcc und sichert es, falls nötig
<pre>
ld r0, Z+
ld r24, Z
st Z, r0
st -Z, r24
</pre>

{{FarbigerRahmen |
Falls das Register <tt>r1</tt> verändert wird – was z.B. geschieht, wenn man Multiplikationsbefehle verwendet – dann muss am Ende des Templates das Register wieder auf 0 gesetzt werden, denn bei avr-gcc enthält dieses Register immer den Wert 0.
Das Register in die Clobber-Liste aufzunehen bleibt wirkungslos. Hat man es zerstört,
dann schreibt man ans Ende des Templates ein
clr __zero_reg__
und stellt es dadurch wieder her.
}}

== asm goto mit C-Labels ==

Ab Version 4.5 kennt GCC <tt>asm goto</tt>, mit dem ausgedrückt werden kann, dass der Codefluß des Assembler-Teils u.U. zu einem Stück C-Code springt:

asm goto ([[#Assembler-Template|asm-template]] : {{comment|Leer}} : [[#Operanden und Constraints|input-operand-list]] : [[#Clobbers|clobber-list]] : [[#asm goto mit C-Labels|C-labels]]);

Die Codefluß-Analyse des Compilers muss wissen, daß die angegebenen C-Code Sequenzen verwendet werden, damit sie nicht wegoptimiert werden. Solch ein Inline-Assembler mit <tt>goto</tt> darf keine Output-Operanden haben, denn der Compiler hat keine Möglichkeit, Code für die entsprechenden Output-Reloads zu erzeugen.

;Beispiel:

extern void __attribute__((noreturn))
panic (void);

char panic_if_x (char x)
{
asm goto ("cpse %0, __zero_reg__" "\n\t"
"%~jmp %x1" "\n\t"
"%~jmp %x2"
:: "r" (x) :: proceed, do_panic);
__builtin_unreachable();

if (0)
{
do_panic:
panic();
}

if (0)
{
proceed:
x++;
}

return x;
}

Im Beispiel wird der Inline-Assembler nur über die Marken <tt>do_panic</tt> oder <tt>proceed</tt> verlassen, weshalb der Code direkt danach unerreichbar ist. Dies wird der Codefluß-Analyse per <tt>__builtin_unreachable()</tt> mitgeteilt. Es wird folgender Code erzeugt:

panic_if_x:
{{comment|#APP}}
cpse r24,__zero_reg__
rjmp .L2
rjmp .L3
{{comment|#NOAPP}}
.L3:
rcall panic
.L2:
subi r24,lo8(-(1))
ret

=Vordefinierte Bezeichner und Makros=
Je nach Assembler, für den avr-gcc Code erzeugt, gibt es unterschiedliche vordefinierte Funktionen/Makros, die von Inline-Assembler aus verwendbar sind.

== GNU-Assembler ==

:{| {{Blauetabelle}}
|+ '''Vordefinierte Makros und<br/>Relocatable Expression Modifiers'''<br/> 
|- {{Hintergrund1}}
! Bezeichner || Bedeutung
|-
|<tt>__SP_L__</tt> || unteres Byte des Stack-Pointers, für <tt>in</tt> bzw. <tt>out</tt>
|-
|<tt>__SP_H__</tt> || oberes Byte des Stack-Pointers, für <tt>in</tt> bzw. <tt>out</tt>
|-
|<tt>__SREG__</tt> || Status-Register, für <tt>in</tt> bzw. <tt>out</tt>
|-
|<tt>__tmp_reg__</tt> || ein Register zur temporären Verwendung (<tt>r0</tt>)
|-
|<tt>__zero_reg__</tt> || ein Register, das 0 enthält (<tt>r1</tt>)
|-
|<tt>lo8(''const'')</tt> || Bits 0...7 der Konstanten <tt>''const''</tt>
|-
|<tt>hi8(''const'')</tt> || Bits 8...15 der Konstanten <tt>''const''</tt>
|- valign="top"
|<tt>hlo8(''const'')</tt><br/><tt>hh8(''const'')</tt> || Bits 16...23 der Konstanten <tt>''const''</tt>
|-
|<tt>hhi8(''const'')</tt> || Bits 24...31 der Konstanten <tt>''const''</tt>
|- valign="top"
|<tt>pm(''const'')</tt> || Konstante <tt>''const''</tt> durch 2 geteilt,<br/>zur Berechnung von Word-Adressen für <tt>icall</tt> und <tt>ijmp</tt>.
|- valign="top"
|<tt>pm_lo8(''const'')</tt><br/><tt>pm_hi8(''const'')</tt><br/><tt>pm_hh8(''const'')</tt>
| Abkürzung für <tt>lo8(pm(''const''))</tt><br/>Abkürzung für <tt>hi8(pm(''const''))</tt><br/>Abkürzung für <tt>hh8(pm(''const''))</tt>
|- valign="top"
|<tt>gs(''label'')</tt> || Word-Adresse von <tt>''label''</tt>. Für Devices mit mehr als 128k Flash wird die Adresse eines Jump-Pads eingetragen. Der Linker erzeugt ein Jump-Pad, das einen direkten Sprung zu <tt>label</tt> erhält. <tt>gs(label)</tt> wird durch diese Adresse ersetzt.
|}

=Beispiele=

==nop==
Mit den bisherigen Vorkenntnissen ist zu <tt>nop</tt> nicht viel zu sagen:
asm volatile ("nop");
Oder als C-Makro:
#define nop() \
asm volatile ("nop")

<tt>nop</tt> hat weder Input- noch Output-Operanden, und Register/RAM ändern sich natürlich nicht. Bei der Makro-Definition ist lediglich darauf zu achten, daß das Makro nicht mit einem <tt>;</tt> endet, damit man den C-Code wie gewohnt mit <tt>;</tt> schreiben kann:
<pre>
if (x)
nop();
else
...
</pre>

==swap Nibbles==
Ein einfaches Beispiel für <tt>swap</tt> haben wir bereits oben kennen gelernt. Der Inline-Assembler dreht die Nibbles von <tt>foo</tt> um:
<pre>
unsigned char foo;
...
asm ("swap %0" : "+r" (foo));
</pre>

Wünschenswert wäre eher, <tt>swap</tt> wie eine normale C-Funktion verwenden zu können und hinzuschreiben:
a = swap(b);
ohne daß <tt>b</tt> seinen Wert ändert. Soll <tt>b</tt> geswappt werden, dann via
b = swap(b);
zudem soll das Argument ein Ausdruck sein können:
if (b == swap (b+1))
...

Dazu verwenden wir eine lokale Variable <tt>_x_</tt>, in die der ursprüngliche Wert <tt>x</tt> gesichert wird:
<pre>
#define swap(x) \
({ \
unsigned char _x_ = (unsigned char) x; \
asm ("swap %0" : "+r" (_x_)); \
_x_; \
})
</pre>
alternativ könnten wir eine inline-Funktion definieren:
<pre>
static inline unsigned char swap (unsigned char x)
{
asm ("swap %0" : "+r" (x));
return x;
}
</pre>

==swap Bytes==
Werden Zahlen zwischen verschiedenen Plattformen übertragen, kann es sein, daß diese unterschiedlich dargestellt werden: Das low-Byte kann in sich im unteren Byte befinden (AVR), es kann aber auch im oberen Byte sein. Ist das so, dann müssen die Werte beim Senden/Empfang umgewandelt werden, indem die Bytes getauscht werden. Liegt der 16-Bit-Wert in <tt>x_in</tt> und soll der konvertierte Wert nach <tt>x_out</tt> gespeichert werden, dann könnte man auf die Idee kommen, so etwas zu schreiben:
<pre>
asm (
"mov %A0, %B1" "\n\t"
"mov %B0, %A1"
: "=r" (x_out)
: "r" (x_in)
);
</pre>
Daraus könnte folgender Code entstehen:
<pre>
mov r24, r25
mov r25, r24
</pre>
Das ist offenbar Käse! Was ist passiert?

avr-gcc hat sich dazu entschieden, <tt>x_in</tt> in <tt>r25:r24</tt> anzulegen. Auch <tt>x_out</tt> wird in diesen Registern angelegt. Das ist erst mal in Ordnung, wenn <tt>x_in</tt> nach dem Inline nicht mehr gebraucht wird.

Allerdings wird das Inline nicht en bloc — also nicht zeitparallel — ausgeführt, sondern sequenziell. Bei ''gleichzeitiger'' Ausführung der beiden <tt>mov</tt>-Instruktionen wäre auch nichts dagegen zu sagen! Ein <tt>swap</tt>-Kommando z.B. tauscht die Nibbles ''gleichzeitig'', und der Input-Operand kann im gleichen Register leben wie der Output-Operand, wenn der Input nicht weiter verwendet wird.

Mit den beiden Bytes geht es aber nicht. Wir müssen daher kennzeichnen, daß sich <tt>x_out</tt> in einem Register befindet, das ''nur'' als Output dient, was durch das <tt>&</tt> in der Output-Constraint erreicht wird:
<pre>
asm (
"mov %A0, %B1" "\n\t"
"mov %B0, %A1"
: "=&r" (x_out)
: "r" (x_in)
);
</pre>
Damit erfolgt eine korrekte Registerzuordnung. <tt>x_out</tt> steht jetzt in <tt>r19:r18</tt> und überschneidet nich nicht mehr mit <tt>x_in</tt>:
<pre>
mov r18, r25
mov r19, r24
</pre>

Alternativ können wir wie bei [[#swap Nibbles|swap Nibbles]] eine lokale Variable verwenden, und alles als (inline-)Funktion machen.

== Zugriff auf SFRs ==
Um auf SFRs zuzugreifen, können im asm-Template keine Defines aus <tt>avr/io.h</tt> verwendet werden, weil der Präprozessor nicht mehr über den erzeugten Assembler-Code läuft (er läuft vor dem Compilieren). Um nicht die hex-Codes des SFRs angeben zu müssen, kann man dem Inline die Adressen als Konstanten übergeben. Weil die Adressen RAM-Adressen sind, müssen sie in das <tt>_SFR_IO_ADDR</tt> Makro verpackt werden, um den Offset für den I/O-Bereich abzuziehen. <tt>tcnt1</tt> wird auf den Inhalt von <tt>TCNT1</tt> gesetzt:
<pre>
#include <avr/io.h>
...
uint16_t tcnt1;

asm volatile (
"in %A0, %1" "\n\t"
"in %B0, %1+1"
: "=r" (tcnt1)
: "M" (_SFR_IO_ADDR (TCNT1))
);
</pre>
wird umgesetzt zu
<pre>
in r24, 44
in r25, 44+1
</pre>

Ab avr-gcc 4.7 kann auch der Operand-Modofier <tt>%i</tt> verwendet werden, um eine RAM-Adresse, wie sie von <tt>avr/io.h</tt> definiert werden, als I/O-Adresse auszugeben:
<pre>
uint16_t tcnt1;

asm volatile (
"in %A0, %i1" "\n\t"
"in %B0, %i1+1"
: "=r" (tcnt1)
: "n" (& TCNT1)
);
</pre>

Das nur als Beispiel. Von C aus geht das natürlich auch mit
uint16_t tcnt1 = TCNT1;

== Zugriff aufs SRAM ==
Auf bekannte globale Symbole kann man direkt von Assembler aus zugreifen:
<pre>
extern int einInt;

asm volatile (
"lds %A0, einInt" "\n\t"
"lds %B0, einInt+1"
: "=r" (...)
);
</pre>
ergibt
<pre>
lds r24, einInt
lds r25, einInt+1
</pre>
alternativ ginge
<pre>
asm volatile (
"lds %A0, %A1" "\n\t"
"lds %B0, %B1"
: "=r" (...)
: "m" (einInt)
);
</pre>

Falls die Adresse eines Objekts zur Compilezeit bekannt ist, kann man auch die Adresse von C aus übergeben:
<pre>
struct foo_t {
int a[2], b[2];
} foo;

...
{
asm volatile (
"lds %A0, %1" "\n\t"
"lds %B0, %1+1"
: "=r" (...)
: "i" (& foo.b[1])
);
}
</pre>
ergibt
<pre>
lds r24, einStruct+6
lds r25, einStruct+6+1
</pre>

Falls die Adresse zur Compilezeit nicht bekannt ist, muss sie natürlich in einem Adress- oder Basisregister übergeben werden:
<pre>
void blah (struct foo_t * pfoo)
{
asm volatile (
"ld %A0, %a1" "\n\t"
"ldd %B0, %a1+1"
: "=&r" (...)
: "b" (& pfoo->b[1])
);
}
</pre>
ergibt
<pre>
ld r24, Z
ldd r25, Z+1
</pre>
Auch hier muss der Output-Operand mit einem <tt>&</tt> gekennzeichnet werden, damit er nicht ins gleiche Register geladen wird wie die Adresse.

= Labels und Schleifen =
Für Labels in Sprüngen und Schleifen können keine festen Bezeichner verwendet werden, weil ein Label, der via Makro oder inline-Funktion in den Code eingefügt wird, nicht mehrfach vorkommen darf. Dazu kann man sich durch Einfügen von <tt>"%="</tt> Labels zusammenbauen, etwa <tt>L_a%=</tt>, <tt>L_b%=</tt>, etc. Das <tt>"%="</tt> wird durch eine für die Übersetzungseinheit und den Code-Schnippsel eindeutige Zahl ersetzt. Die obigen Sequenzen könnten also z.B. umgesetzt werden als <tt>L_a14</tt> und <tt>L_b14</tt>, wenn sie im gleichen Schnippsel stehen.

Etwas bequemer ist die Verwendung einer Ziffer als Label. Beim Sprung gibt man direkt hinter der Ziffer an, in welche Richtung das Label gesucht wird. Ist das Label <tt>''n''</tt>, dann sucht und springt
*<tt>''n''b</tt> zurück (backward)
*<tt>''n''f</tt> nach vorne (forward)

Es wird zum nächsten auffindbaren Label in der angegebenen Richtung gesprungen.

==Bits zählen==

Dieses Assembler-Schnippsel zählt die Anzahl der gesetzten Bits in einem Byte <tt>eingabe</tt>. Die Eingabe wird nach rechts ins Carry geschoben, und das Carry zum Ergebnis dazu addiert.
<pre>
static inline unsigned char count_bits (unsigned char eingabe)
{
unsigned char count;

asm (
"clr %0" "\n"
"0:" "\n\t"
"lsr %1" "\n\t"
"adc %0, __zero_reg__" "\n\t"
"tst %1" "\n\t"
"brne 0b"
: "=&r" (count), "+r" (eingabe)
);

return count;
}
</pre>
Damit kann man sich ein Parity bauen:
#define parity(x) (count_bits(x) & 1)
und hätte eine schlankere (aber etwas langsamere) Parity-Implementierung als in <tt>avr/parity.h</tt>. Ein
if (parity(foo))
...
wird in Assembler dann zu (<tt>r24 = eingabe</tt>, <tt>r25 = count</tt>):
<pre>
lds r24,foo
/* #APP */
clr r25
0:
lsr r24
adc r25, __zero_reg__
tst r24
brne 0b
/* #NOAPP */
sbrs r25,0
rjmp .L1
...
</pre>

=Fallstricke=
* Um die Sonderzeichen <tt>"%~"</tt> und <tt>"%="</tt> benutzen zu können, muss bei parameterlosen Inline Assembler dem Template ein Doppelpunkt folgen:
:<pre>asm volatile ("%~call some_function" :);</pre>
* Steht das <tt>asm</tt> an oberster Ebene — also außerhalb einer Funktion — ist weiter zu beachten:
** Jedes <tt>%</tt> wird als solches ausgegeben, und es sind keine Operanden erlaubt.
** Falls die Reihenfolge von <tt>asm</tt> und Funktionen beibehalten werden soll, muß mit <tt>-fno-toplevel-reorder</tt> compiliert werden.

=Quellen=

; Dokumentation

* AVR-LibC: [http://nongnu.org/avr-libc/user-manual/inline_asm.html ''Inline Assembler Cookbook'']
* GCC Wiki: [http://gcc.gnu.org/wiki/avr-gcc ''avr-gcc'']
* GCC: [http://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html ''Assembler Instructions with C Expression Operands'']
* GCC: [http://gcc.gnu.org/onlinedocs/gcc/Constraints.html ''Constraints for <tt>asm</tt> Operands'']
* GCC: [http://gcc.gnu.org/onlinedocs/gcc/Explicit-Reg-Vars.html ''Variables in Specified Registers'']
* GCC Internals: [http://gcc.gnu.org/onlinedocs/gccint/Constraints.html ''Operand Constraints'']

;GCC-Quellen:

* [http://gcc.gnu.org/viewcvs/gcc/trunk/gcc/config/avr/avr.md?content-type=text%2Fplain&view=co ./gcc/config/avr/avr.md]
* [http://gcc.gnu.org/viewcvs/gcc/trunk/gcc/config/avr/constraints.md?content-type=text%2Fplain&view=co ./gcc/config/avr/constraints.md]

=Siehe auch=
* [[AVR Assembler Einführung]]
* [[:Kategorie:Quellcode Assembler_AVR|Quellcode Assembler]]
* [[Sourcevergleich#GCC (Assembler einfügen)]]
* [[avr-gcc]]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode_Assembler_AVR]]
[[Kategorie:Quellcode C]]

Speicherverbrauch bestimmen mit avr-gcc

2014-09-14T20:18:30Z

SprinterSB: /* Dynamischer RAM-Verbrauch */ static

Der Speicherverbrauch eines C-Programmes lässt sich unter verschiedenen Gesichtspunkten betrachten.
;Ort der Datenablage:
* SRAM
* Flash
* EEPROM

;Art der Daten:
* Programmcode
* Daten
** veränderlich/unveränderlich
** persistent oder flüchtig

;Speicherklasse der Daten
* Statischer Speicherverbrauch
* Dynamischer Speicherverbrauch

Der Ort der Datenablage wird bestimmt von der Art der Daten. Daten, die nicht verändert werden dürfen oder nicht verändert werden müssen, wie der Programm-Code oder konstante Strings, wie sie oft zur Ausgabe verwendet werden, können im Flash gespeichert werden. Konstanten/Tabellen kann man auch im EEPROM speichern, wenn der Platz im Flash knapp ist. Der Programmcode selbst muss bei [[AVR]] im Flash liegen. Man kann den Code zwar auch ins RAM oder ins EEPROM legen, aber von dort nicht ausführen.

Daten, die zur Laufzeit verändert werden müssen, wird man im SRAM speichern, wenn sie einen Reset bzw. ein Ausschalten des Controllers nicht überleben müssen. Sollen die Daten auch ohne Strom erhalten bleiben, muss man den EEPROM oder den Flash als Ablageort wählen. Dabei ist das Speichern von Daten im Flash zur Laufzeit sehr aufwändig, weil man einen [[Bootloader]] für ihre Änderung anstrengen muss. Andererseits kann wesentlich schneller auf das Flash zugegriffen werden als auf den EEPROM-Speicher.

Die Art der Daten ergibt sich aus dem Programm und den zu lösenden Aufgaben,
gleiches gilt für die Speicherklassen.

Die Ablageorte der statische Daten sind bereits zur Compilezeit
bekannt. Hierzu gehören globale und statische Variablen. Dementsprechend ist auch schon zur Compile- bzw. Linkzeit bekannt, wieviel Speicher diese Daten belegen.

Speicherorte und Platzverbrauch dynamischer Variablen sind dem Compiler nicht bekannt. Sie ergeben sich erst zur Laufzeit durch das Allokieren von Speicher mit <tt>malloc</tt>, oder durch den Aufbau eines Stapels, auf dem lokale Variablen gesichert werden, während eine Funktion aufgerufen wird. Je nach Verschachtelungstiefe der Funktionsaufrufe — dazu gehören auch [[Interrupt]] Service Routinen, die prinzipiell jederzeit aufgerufen werden können — wird dafür auch unterschiedlich viel Speicher benötigt.

=Nutzung des SRAM durch avr-gcc=
[[Bild:Avr-ram.png|right|thumb|RAM-Layout für ein AVR mit 1kByte SRAM]]
[[avr-gcc]] legt die Daten in [[avr-gcc/Interna#Sections|Sections]] an.
Nach aufsteigenden Speicheradressen sortiert sind diese:
;<tt>.data</tt>: Statische und (modul-)globale, initialisierte Daten, denen man per Initializer einen Wert ungleich 0 zuweist. Beginnt an der unteren SRAM-Adresse <tt>0x60</tt> nach dem SFR-Bereich, je nach AVR-Derivat auch an anderer Adresse.
;<tt>.bss</tt>: Statische und (modul-)globale, initialisierte Daten, die zu 0 initialisiert sind bzw. keinen Initializer haben (und also auch zu 0 initialisiert werden).
;<tt>.noinit</tt>: Statische und (modul-)globale Daten, die nicht vom Startup-Code initialisiert werden und zum Beispiel einen [[Watchdog]]-Reset überdauern.

Auf diese Sections folgen noch zwei Speicherbereiche für dynamische Daten:

;<tt>Heap</tt>: Danach folgt der Heap. Das ist ein Speicherbereich, aus dem Speicherplatz via <tt>malloc</tt> etc. allokiert wird.
;<tt>Stack</tt>: Auf dem Stapel werden lokale Variablen/Register während Funktionsaufrufen gesichert. Der Stack wird teilweise auch zur Parameterübergabe verwendet und die return-Adresse von Funktionen und [[ISR]]s wird dort abgelegt. Der Stack beginnt an der oberen SRAM-Adresse und wächst nicht wie die andern Bereiche nach oben, sondern nach unten.

Die Größe der ersten drei Speicherbereiche kann man für jedes Modul bereits zur Compile-Zeit bestimmen, da sie unabhängig sind von der Programmausführung. Wie viel Platz die letzten beiden Bereiche brauchen, ergibt sich erst zur Laufzeit des Programms. Diese Größen ändern sich in aller Regel mit der Zeit.

Heap und Stack müssen sich den Speicher, der nicht von <tt>.data</tt>, <tt>.bss</tt> und <tt>.noinit</tt> belegt ist, teilen

Wird der Stackbereich zu groß, weil dort zu viele Daten abgelegt werden (zu viele lokale Variablen (lokale Arrays!), zu tief verschaltelte (rekursive) Funktionen, kaskadierende [[Interrupt]] Service Routinen, ...), dann überschreibt man damit womöglich andere Daten und es kommt zur Fehlfunktion des Programmes. Gleiches gilt, wenn die Obergrenze des Heap über der Untergrenze des Stabels hinauswächst.

=Flash- und statischer RAM-Verbrauch =
Zur Bestimmung des Speicherplatzes, den statische Daten belegen, verwendet man <tt>avr-size</tt>, das zu den Binutils gehört und z.B. bei [[WinAVR]] dabei ist.

Abhängig von der [[avr-gcc#Sections|Section]] schlägt ihr Platzverbrauch in Flash/SRAM/[[EEPROM]] zu Buche:
<center>
{| {{Blauetabelle}}
|+ '''Tabelle: Zuordung des Platzberbrauchs zur Section-Größe'''
|- {{Hintergrund1}}
! |belegter Speicher || Sections (Einzelgrößen addieren) ||Beschreibung
|-
|Flash || <tt>.text</tt> + <tt>.bootloader</tt> + <tt>.data</tt> || Programmcode und Tabelle für initialisierte Daten
|-
|SRAM || <tt>.data</tt> + <tt>.bss</tt> + <tt>.noinit</tt>|| Daten (initialisiert + zu 0 initialisiert + nicht initialisiert)
|-
|EEPROM ||<tt>.eeprom</tt> ||Daten, die man ins EEPROM gelegt hat
|}
</center>

'''Beispiele:'''

Das <tt>'>'</tt> nicht mittippen, es ist der Kommandozeilen-Prompt.

Verbrauch der einzelnen Module auflisten:
> avr-size -x foo1.o foo2.o ...

Verbrauch des gesamten Programms auflisten:
> avr-size -x -A foo.elf
In neueren Versionen von avr-size geht auch
> avr-size --mcu=atmega8 -C foo.elf
was den Verbrauch als Absolutwerte und in Prozentangabe auflistet. Ohne die Angabe der Controllers mit <tt>--mcu</tt> können natürlich keine Prozentwerte berechnet werden, es werden dann nur die absoluten Verbrauche ausgedruckt.

Platzverbrauch von Funktionen, Objekten, Variablen, etc. nach Größe sortiert:
> avr-nm --size-sort --print-size foo.elf
Hilfe zu avr-nm siehe: /WinAVR/doc/binutils/binutils.html/nm.html

Zusammenfassung aus www.mikrocontroller.net:

Großbuchstaben => globale Symbole / kleine Buchstaben => local symbols

T/t : The symbol is in the text (code) section.

D/d : The symbol is in the initialized data section.

B/b : The symbol is in the uninitialized data section (known as BSS).

Alle Symbole mit einem "T" (globale Funktionen), "t" (statische Funktionen) und letztlich auch mit einem "D" oder "d" (globale bzw. statische Daten, die haben ihre Initialisierungswerte im ROM) betreffen das FLASH-ROM. "B" und "b" brauchen ausschließlich RAM (werden beim Start mit 0 initialisiert). Die erste Spalte ist die Adresse des Symbols, die zweite ist die Größe (beides hexadezimal)

=Dynamischer RAM-Verbrauch=

Um den momentan freien Speicher zu bestimmen, zieht man einfach den Anfang des Heaps vom Stackpointer ab:
#include <avr/io.h>

{{ccomment|__heap_start is declared in the linker script}}
extern unsigned char __heap_start;
...
uint16_t momentan_frei = SP - (uint16_t) &__heap_start;

Interessanter ist es jedoch, den Maximalverbrauch an Speicher bzw. das Minimum an ungenutztem Speicher seit Programmstart zu bestimmen.

Mit der folgenden kleinen Routine kann der noch freie SRAM-Bereich bestimmt werden. Es wird nicht der momentan freie Speicher bestimmt, sondern das Minimum an Speicher, das bis dato ungenutzt geblieben ist. Dazu wird im Startup-Code das Muster <tt>0xaa</tt> in den SRAM geschrieben. Durch Aufruf der Funktion <tt>get_mem_unused</tt> wird bestimmt, wieviel von diesem Muster zum Zeitpunkt des Aufrufs noch intakt ist.

Dieses Vorgehen ist deshalb notwendig, weil unter Umständen auch [[ISR]]-Routinen dynamisch Speicherplatz belegen, man jedoch <tt>get_mem_unused</tt> nicht ''in'' der ISR aufrufen will.

Mit optimierendem Compiler brauchen die beiden Routinen zusammen 42 Bytes an Flash.

Damit der Code den richtigen Wert liefert, darf keine dynamische Speicherallokierung mit <tt>malloc()</tt> etc. geschehen sein; ein <tt>[[Avr-gcc/Interna#Dynamische Speicherallokierung|__builtin_alloca]]</tt> ist hingegen kein Problem, da letzteres den Platz vom Stapel nimmt.

Die Funktion <tt>init_mem</tt> wird in der Init-Phase [[Avr-gcc/Interna#Frühe Codeausführung vor main()|vor <tt>main</tt> aufgerufen]].

;<tt>mem-check.h</tt>
#ifndef MEM_CHECK_H
#define MEM_CHECK_H

extern unsigned short get_mem_unused (void);

#endif {{comment|MEM_CHECK_H}}

;<tt>mem-check.c</tt>
#include <avr/io.h> {{ccomment|RAMEND}}
#include "mem-check.h"

{{ccomment|Mask to init SRAM and check against}}
#define MASK 0xaa

{{ccomment|From linker script}}
extern unsigned char __heap_start;

{{ccomment|!!! This doesn't work together with malloc et.al. (whose use is}}
{{ccomment|!!! discouraged on AVR, anyway). alloca, however, is no problem}}
{{ccomment|!!! because it allocates on stack.}}

{{ccomment|Get minimum of free memory (in bytes) up to now.}}
unsigned short
get_mem_unused (void)
{
unsigned short unused = 0;
unsigned char *p = &__heap_start;

do
{
if (*p++ != MASK)
break;

unused++;
} while (p <= (unsigned char*) RAMEND);

return unused;
}

{{ccomment|!!! Never call this function, it is part of .init-Code}}
static void [[Avr-gcc/Interna#Attribute|__attribute__]] ((naked, used, section(".init3")))
init_mem (void)
{
{{ccomment|Use inline assembler so it works even with optimization turned off.}}
{{ccomment|Apart from that, according to GCC docs, the only code that's safe}}
{{ccomment|in a naked function is inline assembly.}}
__asm volatile (
"ldi r30, lo8 (__heap_start)" "\n\t"
"ldi r31, hi8 (__heap_start)" "\n\t"
"ldi r24, %0" "\n\t"
"ldi r25, hi8 (%1)" "\n"
"0:" "\n\t"
"st Z+, r24" "\n\t"
"cpi r30, lo8 (%1)" "\n\t"
"cpc r31, r25" "\n\t"
"brne 0b"
:
: "i" (MASK), "i" (RAMEND)
);
}

Der Grund, hier auf [[Inline-Assembler in avr-gcc|Inline Assembler]] zurückzugreifen, ist folgender: Durch normalem C/C++-Code kann man nicht garantieren, daß alle Variablen in Registern leben. In diesem Falle würden Variablen, die auf dem Stack angelegt werden, durch die init-Routine überschrieben.

=Siehe auch=
* [[AVR]]
* [[avr-gcc]]
* [[Inline-Assembler in avr-gcc|Inline-Assembler]]

[[Kategorie:Quellcode C]]
[[Kategorie:Quellcode Assembler AVR]]
[[Kategorie:Software]]

Avr-gcc

2014-09-14T07:48:47Z

SprinterSB: /* ISR mit eigenem Prolog/Epilog */ Framepointer, used

'''avr-gcc''' ist ein freier C-[[Compiler]], mit dem C-Programme zu ausführbaren Programmen übersetzen werden können, die auf [[Microcontroller]]n der [[AVR]]-Familie lauffähig sind.
An Sprachen versteht avr-gcc sowohl C als auch [[#C%2b%2b|C++]].
Neben Standard-C bzw. ANSI-C versteht avr-gcc auch GNU-C, das etwas mehr Möglichkeiten und kleinere Spracherweiterungen bietet.

avr-gcc kann auch dazu verwendet werden, um C/C++ Programme nach Assembler zu übersetzen oder um Bibliotheken zu erstellen, die später in unterschiedlichen Projekten verwendet werden können.

Wie bei allen aus der UNIX-Welt kommenden Programmen ist das Kommando-Interface von avr-gcc die Shell bzw. die Kommandozeile, über die Optionen, Parameter, Einstellungen und die Namen der zu übersetzenden Dateien angegeben werden.

=How to Read=

Dieser Artikel bespricht avr-gcc Version 3.x. Er ist kein C-Tutorial und kein AVR-Handbuch – das würde den Umfang des Artikels bei weitem sprengen.

Der Artikel ist ein Handbuch zu avr-gcc. Er bespricht zum Beispiel, wie avr-gcc angenwendet wird und Besonderheiten von avr-gcc-C, die nicht zum Sprachumfang von C gehören.
Dazu zählen die Definition von [[#Interrupts|Interrupt]] Service Routinen ([[ISR|ISRs]])
oder wie man Daten ins [[EEPROM]] legt.

Es wird also besprochen, ''wie'' eine ISR zu definieren ist, aber nicht,
''warum'' das gegebenenfalls notwendig oder nicht notwendig ist.
''Warum'' etwas gemacht wird, ist abhängig von der gestellten Aufgabe,
etwa ''"Initialisiere den [[UART]] zur Benutzung mit 9600 Baud"''.
Dafür enthält dieser Artikel zusammen mit dem AVR-Handbuch das Rüstzeug,
bietet aber keine Lösungen für konkrete Aufgaben.

Neben diesem Artikel gibt es den Unterartikel [[avr-gcc/Interna|Interna von avr-gcc]] wo Dinge wie die Registerverwendung, Attribute, Builtins und Sections von avr-gcc dargestellt werden. Zudem findet sich dort ein Überblick über die Arbeitsweise von gcc mit den Schritten
* Precompilieren
* Compilieren
* Assemblieren
* Linken
Ein weiterer Unterartikel widmet sich dem Thema [[Inline-Assembler in avr-gcc]].

In den [[:Kategorie:Quellcode C|C-Codebeispielen]]
befindet sich das ausführlichere Beispiel "[[Hallo Welt für AVR (LED blinken)]]",
das nur eine [[Diode#Lumineszenzdiode|LED]] blinkt und zeigt,
wie ein kleines Projekt mit avr-gcc compiliert werden kann.

Es gibt ein [[C-Tutorial]], das jedoch noch unvollständig und teilweise feherhaft ist (Stand 02/2006). Darüber hinaus gibt es ein [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial C-Tutorial bei www.mikrocontroller.net].

=Benutzer-Schnittstelle=

Die Benutzer-Schnittstelle von avr-gcc ist – wie für alle Programme, die aus der UNIX-Welt kommen – die Kommandozeile einer Shell, Console bzw. Eingabeaufforderung.

Im einfachsten Fall sieht ein Aufruf von avr-gcc also so aus:
> avr-gcc
Dabei das '<tt>></tt>' nicht mittippen, und ein ENTER am Ende der Zeile drücken.
Die Antwort bei korrekter Installation ist dann
avr-gcc: no input files
Was bedeutet: das Programm avr-gcc wurde vom Betriebssystem gefunden und konnte/durfte gestartet werden. Dann gibt avr-gcc eine Fehlermeldung aus und beendet die Ausführung, weil er keine Eingabedatei(en) bekommen hat  was ja auch stimmt. Soweit ist also alles in Butter.

Um eine C-Datei <tt>foo.c</tt> mir avr-gcc optimiert zu einem lauffähigen elf-Programm <tt>foo.elf</tt> für einen [[ATmega32]] zu compileren, würde man angeben
> avr-gcc -Os -mmcu=atmega32 foo.c -o foo.elf
Hat man seine Quellen auf zwei oder mehre Dateien verteilt, geht es analog:
> avr-gcc -Os -mmcu=atmega32 foo.c foo2.c -o foo.elf

Will man nur eine Objekt-Datei erstellen (nur compilieren, nicht linken), dann geht das wie folgt. Das kann günstig sein bei grösseren Projekten, wenn man das Projekt neu erzeugen will, aber nur in einer Quelldatei was geändert hat. Oder wenn das Objekt in einer Bibliothek landen soll.
> avr-gcc -Os -c -mmcu=atmega32 foo.c -o foo.o

Die ausführbare Gesamtdatei <tt>foo_all.elf</tt> erhält man dann, indem alle Objekte zusammenlinkt:
> avr-gcc -mmcu=atmega32 foo.o foo2.o foo3.o -o foo_all.elf

Um die ausführbare Datei in das oft verwendete Intex-HEX-Format umzuwandeln (einmal fürs Programm, einmal für ein Abbild des [[EEPROM]]s) gibt man an:
> avr-objcopy -O ihex -j .text -j .data foo_all.elf foo_all.hex
> avr-objcopy -O ihex -j .eeprom --change-section-lma .eeprom=1 foo_all.elf foo_all_eeprom.hex

----

[[GCC]] war immer Kommandozeilen-orientiert und wird es auch immer bleiben, denn das hat gute Gründe:
* ein Compiler ist ein Compiler (und keine grafische Bedienschnittstelle)
* die Plattformabhängigkeit wird auf ein Minimum reduziert
* es gibt die Möglichkeit, avr-gcc per Skript oder [[make]] zu starten
* avr-gcc kann durchaus in eine Umgebung integriert werden: in einen Editor oder in eine GUI wie neuere Versionen von AVR-Studio erfolgreich beweisen, etc. Der avr-gcc-Aufruf kann sogar von einem Server-Socket oder einer Web-Application heraus erfolgen, welche ein C-Programm empfängt, es von avr-gcc übersetzen lässt, und das Resultat zurückschickt oder sonst was damit anstellt.
* Lizenzgründe: eine Umgebung, die avr-gcc integriert, kann durchaus proprietär oder nicht quelloffen sein und muss nicht der [[Freie Software|GPL]] unterliegen. Wieder ist AVR-Studio ein Beispiel.

= Unterstützte AVR-Derivate=

:→ ''[http://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html GCC Manual: AVR Options]

Diese Liste der unterstützten Devices kann man anzeigen lassen mit
> avr-gcc --target-help
bzw. ab Version 4.7 mit
> avr-gcc --help=target

Siehe auch "AVR Options" in der GCC [[#Dokumentation|Dokumentation]].

=Kommandozeilen-Optionen=
Die Codegenerierung bei avr-gcc wird über Kommandozeilen-Optionen gesteuert. Diese legen fest, für welchen Controller Code zu erzeugen ist, wie stark optimiert wird, ob Debug-Informationen erzeugt werden, etc. Die Optionen teilen sich in zwei Gruppen: Optionen, die für alle GCC-Ports verfürgbar sind und maschinenspezifische Optionen, die nur für AVR verfügbar sind.

Aus der Masse an GCC-Optionen kann hier nur ein kleiner Auszug der wichtigsten und am häufigsten verwendeten Optionen vorgestellt werden. Eine Auflistung aller GCC-Optionen mit Kurzbeschreibung umfasst knapp 1000 Zeilen  ohne undokumentierte Optionen, versteht sich.

==Allgemeine Optionen für GCC==
; <tt>--help</tt>: Anzeige der wichtigsten Optionen
; <tt>--help -v</tt>: Überschüttet einen mit Optionen
; <tt>--target-help<br/>--help=target</tt>: Anzeige der wichtigsten maschinenspezifischen Optionen und der unterstützten AVR-Derivate
; <tt>-O0</tt>: keine Optimierung - sinnvoll zum debuggen
; <tt>-O1</tt>: Optimierung
; <tt>-Os</tt>: optimiert für Code-Größe – meist beste Wahl für µCs
; <tt>-O2</tt>: stärkere Optimierung für bessere Laufzeit
; <tt>-g</tt>: erzeugt Debug-Informationen
; <tt>-gdwarf-3 -gstrict-dwarf</tt>: erzeugt Debug-Informationen nachdem DWARF-3 Standard und ohne GNU-spezifische Erweiterungen.
; <tt>-c</tt>: (pre)compilert und assembliert nur bis zum Objekt (<tt>*.o</tt>), kein Link-Lauf
; <tt>-S</tt>: (pre)compilert nur und erzeugt Assembler-Ausgabe (<tt>*.s</tt>)
; <tt>-E</tt>: nur Precompilat (<tt>*.i</tt> bzw. <tt>*.ii</tt>) erzeugen, kein Compilieren, kein Assemblieren, kein Linken
; <tt>-o <filename></tt>: legt den Name der Ausgabedatei fest
; <tt>-v</tt>: zeigt Versionsinformationen an und ist geschwätzig (verbose): Anzeige der aufgerufenen tools
; <tt>-I<path></tt>: Angabe eines weiteren Include-Pfads, in dem Dateien mit <tt>#include <...></tt> gesucht werden
; <tt>-E -dM <filename></tt>: Anzeige aller Defines
; <tt>-MM</tt>: Für die angegebenen Eingabe-Dateien wird eine Ausgabe erzeugt, die als [[make|Makefile]]-Fragment dienen kann und die Anhängigkeiten (dependencies) der Objekte von den Quellen/Headern beschreibt.
; <tt>-D<name></tt>: Definiert Makro <tt><name></tt>
; <tt>-D<name>=<wert></tt>: Definiert Makro <tt><name></tt> zu <tt><wert></tt>
; <tt>-U<name></tt>: Undefiniert Makro <tt><name></tt>
; <tt>-save-temps</tt>: Temporäre Dateien (<tt>*.i</tt>, <tt>*.s</tt>) werden nicht gelöscht.
; <tt>-Wa,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Assembler (<tt>avr-as</tt>)
:;<tt>-Wa,-a=<filename></tt>: Assembler erzeugt ein Listing mit Name <tt><filename></tt>
; <tt>-Wp,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Preprozessor
; <tt>-Wl,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Linker (<tt>avr-ld</tt>)
:;<tt>-Wl,-Map=<filename></tt>: Linker erzeugt ein Map-File mit Name <tt><filename></tt>
:;<tt>-Wl,--section-start=<section>=<address></tt>: Linker legt die [[avr-gcc/Interna#Sections|Section]] <tt><section></tt> ab Adresse <tt><address></tt>, z.B: <tt>.eeprom=0x810001</tt>
; <tt>-Wall</tt>: gibt mehr Warnungen, aber immer noch nicht alle
; <tt>-std=gnu99</tt>: Sagt dem Compiler, dass er C99 mit GNU-C Erweiterungen akzeptieren soll. Das ist zum Beispiel der Fall, wenn man Embedded-C Code mit <tt>__flash</tt> verwenden will.
; <tt>-std=c89<br/>-ansi</tt>: bricht mit einer Fehlermeldung ab, wenn kein ANSI-C (ISO C89) verwendet wurde
; <tt>-std=c99</tt>: C99 mit einigen Erweiterungen, die nicht dem C99-Standard widersprechen
; <tt>-std=c99 -pedantic</tt>: Bricht mit einer Fehlermeldung ab, wenn kein ISO C99 verwendet wird

==Maschinenspezifische Optionen für avr-gcc==

Maschinenabhängige Optionen beginnen immer mit '''-m'''
;-mmcu=xxx: Festlegen des Targets (Zielsystem/Controller), für das Code generiert werden soll. Je nach Target muss avr-gcc unterschiedliche Instruktionen verwenden und andere Startup-Dateien (<tt>crtxxx.o</tt>) einbinden. avr-gcc setzt spezielle Defines, um auch in der Quelle zwischen den Targets unterscheiden zu können, falls das notwendig sein sollte:
:{| border="0" cellpadding="0" cellspacing="0"
|
<pre>
#ifdef __AVR_AT90S2313__
/* Code fuer AT90S2313 */
#elif defined (__AVR_ATmega8__) || defined (__AVR_ATmega32__)
/* Code fuer Mega8 und Mega32 */
#else
#error Das ist noch nicht implementiert für diesen Controller!
#endif
</pre>
|}

: Zwar gibt es für alle AVR-Derivate die <tt>avr/io.h</tt>, aber die AVR-Familien unterscheiden sich in ihrer Hardware; z.B. darin, wie I/O-Register heissen oder wie Hardware zu initialisieren ist. Diese Abhängigkeit kann man in unterschiedlichen Codestücken aufteilen und wie oben gezeigt bedingt übersetzen. Dadurch hat man Funktionalitäten wie <tt>uart_init</tt> auf unterschiedlichen Controllern und wahrt den Überblick, weil nicht für jede Controller-Familie eine extra Datei notwendig ist.

: Built-in Makros wie <tt>__AVR_ATmega8__</tt> und <tt>__AVR_ARCH__</tt> sind ab Version 4.7 im Kapitel "AVR Options" in der GCC [[#Dokumentation|Dokumentation]] erklärt, siehe z.B. [http://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html "AVR Built-in Macros"].

; -mint8: Datentyp <tt>int</tt> ist nur 8 Bit breit anstatt 16 Bit. Datentypen mit 64 Bit sind nicht verfügbar. 8-Bit <tt>int</tt> ist nicht C-Standard konform und wird nicht von der AVR Libc unterstützt (ausser in <tt>stdint.h</tt>).
; -mno-interrupts: Ändert den Stackpointer ohne Interrupts zu deaktivieren
; -mcall-prologues: Funktions-Prolog und -Epilog werden als Unterroutinen umgesetzt, um die Codegröße zu verkleinern
; -mtiny-stack: Nur die unteren 8 Bit des Stackpointers werden verändert

=C++=

:''"C++ is a complex language and an evolving one, and its standard definition (the ISO C++ standard) was only recently completed. As a result, your C++ compiler may occasionally surprise you, even when its behavior is correct."''

Zudem sollte der Einsatz von C++ aus Effizienzgründen sehr kritisch betrachtet werden:
:''"When programming C++ in space- and runtime-sensitive environments like microcontrollers, extra care should be taken to avoid unwanted side effects of the C++ calling conventions like implied copy constructors that could be called upon function invocation etc. These things could easily add up into a considerable amount of time and program memory wasted. Thus, casual inspection of the generated assembler code (using the <tt>-S</tt> compiler option) seems to be warranted."''

Weiterhin unterliegt der Einsatz von C++ je nach Compiler/Lib-Version bestimmten Einschränkungen:
*Einer kompletten C++ Implementierung fehlt die Unterstützung durch die <tt>libstdc++</tt>, dadurch fehlen Standardfunktionen, -Klassen und -Templates
* Die Operatoren <tt>new</tt> und <tt>delete</tt> sind nicht implementiert, ihre Verwendung führt zu unauflösbaren externen Referenzen (Linker-Fehler)
*Nicht alle Header sind C++-sicher und müssen in <tt>extern "C" {...}</tt> eingeschlossen werden.
*Exceptions werden nicht unterstützt und müssen via <tt>-fno-exceptions</tt> abgeschaltet werden, oder der Linker beschwert sich über eine unauflösbare externe Referenz zu <tt>__gxx_personality_sj0</tt>.

Als Treiber verwendet man wie immer avr-gcc. Standard-Endungen für C++ sind <tt>.c++</tt> und <tt>.cpp</tt>. Bei anderen Endungen teilt man mit <tt>-x c++</tt> mit, daß es sich um C++ Dateien handelt, oder ruft <tt>avr-c++</tt> direkt auf.

Interrupt-Service-Routinen (ISRs) sind C-Funktionen und werden definiert wie gehabt. Siehe auch [[#Interrupts|Interrupts]].
#include <avr/io.h>
#include <avr/interrupt.h>

#if defined (__cplusplus)
extern "C" {
#endif {{comment|__cplusplus}}

SIGNAL (SIG_NAME)
{
{{comment|machwas}}
}

INTERRUPT (SIG_NAME)
{
{{comment|mach was}}
}

#if defined (__cplusplus)
}
#endif {{comment|__cplusplus}}
<tt>__cplusplus</tt> ist ein Standard [[avr-gcc/Interna#Builtin Defines|GCC-Builtin-Define]].

Globale Konstruktoren werden in [[avr-gcc/Interna#Sections|Section]] <tt>.init6</tt> ausgeführt, die Destruktoren in <tt>.fini6</tt>.

=Code-Beispiele=
Dieser Abschnitt enthält Code-Schnippsel für avr-gcc. Es werden Besonderheiten besprochen, die für avr-gcc zu beachten sind.

Dieser Abschnitt ist ''kein'' [[C-Tutorial|Tutorial zur C-Programmierung]] und ''keine'' Einführung in die Programmiersprache C im allgemeinen. Dafür sei auf einschlägige Tutorials/Bücher verwiesen.

==Zugriff auf Special Function Registers (SFRs)==

===Zugiff auf Bytes und Worte===
Für den Zugriff auf die SFRs gibt es Defines über den Include
#include <avr/io.h>
Abhängig vom eingestellten Controller werden dann Defines eingebunden, über die auf SFRs wie auf normale Variablen zugegriffen werden kann. Die Namen der Defines sind i.d.R. die gleichen wie im AVR-Manual, also z.b. <tt>SREG</tt> für das Prozessorstatus-Register SREG:
#include <avr/io.h>

...
{{ccomment|SREG lesen}}
uint8_t sreg = SREG;
...
{{ccomment|SREG schreiben}}
SREG = sreg;

Für einen Überblick über die eingebundenen Defines kann ein Blick in den Controller-spezifischen Header hilfreich sein. Dieser befindet sich in
:<tt> <GCC_HOME>/avr/include/avr/io****.h</tt>
z.B. <tt>iom32.h</tt> für einen [[ATmega32]].

Dieser Zugriff geht auch für 16-Bit Register wie <tt>TCNT1</tt> oder <tt>ADC</tt>, für die eine bestimmte Reihenfolge für den Zugriff auf Low- und High-Teil eingehalten werden muss: avr-gcc generiert die Zugriffe in der richtigen Reihenfolge.
uint16_t tcnt1 = TCNT1;

{{FarbigerRahmen|
Zu beachten ist, daß dieser Zugriff nicht atomar erfolgt. Das Lesen/Schreiben mehrbytiger Werte muss vom Compiler in mehrere Byte-Zugriffe zerlegt werden. Zwischen diesen Zugriffen kann ein [[Interrupt]] auftreten, wenn Interrupts aktiviert sind. Je nach Programm und welche Aufgaben eine [[ISR]] erledigt, kann dies zu Fehlfunktion führen. In dem Fall müssen diese Code-Stücke atomar gemacht werden, damit sie nicht durch einen [[IRQ]] unterbrochen werden können!
}}

===Zugriff auf einzelne Bits===
Zugriff auf Bits geht wie gewohnt mit den Bitoperationen
<tt>&</tt> (and),
<tt>|</tt> (or),
<tt>^</tt> (xor) und
<tt>~</tt> (not)

Wieder gibt es Defines in den AVR-Headern, mit denen man Masken für den Zugriff erhalten kann, etwa:
<pre>
/* GIMSK / GICR */
#define INT1 7
#define INT0 6
#define IVSEL 1
#define IVCE 0
</pre>

Masken ergeben sich durch Schieben von <tt>1</tt> an die richtige Position:
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0) | (1<<PB1);
</pre>
erzeugt
<pre>
87 b3 in r24, 0x17
83 60 ori r24, 0x03
87 bb out 0x17, r24
</pre>

Etwas anders sieht der Code aus, wenn die Bits einzeln gesetzt werden und das Register im bitadressierbaren Bereich liegt (SRAM <tt>0x20</tt> bis <tt>0x3f</tt> resp. I/O <tt>0x0</tt> bis <tt>0x1f</tt>):
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0);
DDRB |= (1<<PB1);
</pre>
erzeugt
<pre>
b8 9a sbi 0x17, 0
b9 9a sbi 0x17, 1
</pre>

Um Bits zu löschen, erzeugt man eine Maske, die an der betreffenden Stelle eine  0 hat:
<pre>
// Ports B_2 als Eingang
DDRB &= ~(1<<PB2);
</pre>

{{FarbigerRahmen|
Auch hier ist zu beachten, daß es Probleme geben kann, wenn nicht atomarer Code erzeugt wird, weil der AVR-Befehlssatz nicht mehr hergibt:
<pre>
// toggle PORT B_0: wechseln 0 <--> 1
PORTB ^= (1<<PB0);
</pre>
ergibt
<pre>
88 b3 in r24, 0x18
; Wenn hier ein Interrupt auftritt, in dessen ISR PORTB verändert wird,
; dann wird die Änderung durch die letzte Instruktion wieder überschrieben!
91 e0 ldi r25, 0x01
; dito
89 27 eor r24, r25
; dito
88 bb out 0x18, r24
</pre>
}} 

Auch das Lesen einzelner Port-Pins geht über das Maskieren von SFRs:
<pre>
DDRB &= ~(1 << PB2); // PortB.2 als INPUT

if (PINB & (1 << PB2))
// PortB.2 ist HIGH
else
// PortB.2 ist LOW

if (!(PINB & (1 << PB2)))
// PortB.2 ist LOW
else
// PortB.2 ist HIGH
</pre>

==Interrupts==

: → ''[http://nongnu.org/avr-libc/user-manual/group__avr__interrupts.html AVR-Libc: Dokumentation zu <tt><avr/interrupt.h></tt>].

Um zu kennzeichnen, daß es sich bei einer Funktion um eine Interrupt Sevice Routine (ISR) handelt, gibt es spezielle Attribute. Diese brauchen nicht explizit hingeschrieben zu werden, ebensowenig wie die genaue Nummer des Interrupt Requests (IRQ). Dafür gibt es Includes aus der AVR Libc und die folgenden Makros.

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

{{ccomment|Eine nichtunterbrechbare Interrupt-Service-Routine}}
ISR (TIMER1_COMPA_vect)
{
{{ccomment|ISR-Code}}
}

{{ccomment|Eine unterbrechbare Interrupt-Service-Routine}}
ISR (TIMER0_OVF_vect, ISR_NOBLOCK)
{
{{ccomment|ISR-Code}}
}

Dadurch wird die Funktion mit dem richtigen Prolog/Epilog erzeugt, und es wird ein Eintrag in die Interrupt-Vektortabelle gemacht – bei obigem Beispiel also zwei Einträge.

Mit Ausführung einer ISR deaktiviert die AVR-Hardware die Interrupts, so daß die ISR nicht durch andere Interrupt-Anforderungen unterbrochen wird. Beim Verlassen der ISR werden Interrupts wieder automatisch durch die AVR-Hardware aktiviert. Tritt während der ISR ein IRQ auf, wird diese erst nach Beenden des ISR-Codes ausgeführt. Der Interrupt geht also nicht verloren. Dies gilt allerding nicht für Level-getriggerte IRQs wie für manche externen Interrupts oder TWI-Interrupts.

Zwischen zwei ISRs wird zusätzlich mindestens ein Befehl des normalen Programm-Codes abgearbeitet.

Nachschlagen kann man die ISR-Namen im Device-spezifischen Header, die im Installationsverzeichnis liegen:
:<tt><GCC_HOME>/avr/include/avr/ioxxxx.h</tt>

===Interrupts aktivieren===

Damit eine ISR überhaupt zur Ausführung kommt, müssen drei Bedingungen erfüllt sein
* Interrupts müssen global aktiviert sein
* Der entsprechen IRQ muss aktiviert worden sein
* Das zum IRQ gehörende Ereignis muss eintreten
#include <avr/io.h>
#include <avr/interrupt.h>

...
{{ccomment|enable OutputCompareA Interrupt für Timer1}}
TIMSK |= (1 << OCIE1A);

{{ccomment|disable OutputCompareA Interrupt für Timer1}}
TIMSK &= ~(1 << OCIE1A);

{{ccomment|Interrupts aktivieren}}
sei();

{{ccomment|Interrupts abschalten}}
cli();
Sperrt man eine Code-Sequenz durch Einschachteln in ein <tt>cli</tt>/<tt>sei</tt> Paar (man macht das Codestück "atomar", also ununterbrechbar), gehen währenddessen keine Interrupt-Anforderungen verloren. Die entsprechenden IRQ-Flags bleiben gesetzt, und nach dem <tt>sei</tt> werden die IRQs in der Reihenfolge ihrer Prioritäten abgearbeitet. Ausnahme ist, wenn in einem atomaren Block der selbe IRQ mehrfach auftritt. Der ISR-Code wird dann trotzdem nur einmal ausgeführt.

===default Interrupt===

Für nicht implementierte Interrupts macht avr-gcc in die Vektortabelle einen Eintrag,
der zu <tt>__bad_interrupt</tt> (definiert im Startup-Code <tt>crt*.o</tt>) springt
und von dort aus weiter zu Adresse 0.
Dadurch läuft der AVR wieder von neuem los, wenn ein Interrupt auftritt,
zu dem man keine ISR definiert hat
 allerdings ohne die Hardware zurückzusetzen wie bei einem echten Reset.

Möchte man diesen Fall abfangen, dann geht das über eine globale Funktion
namens <tt>__vector_default</tt>:
<pre>
#include <avr/interrupt.h>

ISR (__vector_default)
...
</pre>
Damit wird von <tt>__bad_interrupt</tt> aus nicht nach Adresse 0 gesprungen,
sondern weiter zu <tt>__vector_default</tt>, welches durch <tt>ISR()</tt> den üblichen ISR-Prolog/Epilog bekommt.

So kann man z.B. eine Meldung ausgeben, eine Warnlampe blinken, in einer Endlosschleife landen, oder über den [[Watchdog]] einen richtigen Hardware-Reset auslösen, siehe auch Abschnitt "[[#Reset auslösen|Reset auslösen]]".

===ISR mit eigenem Prolog/Epilog===

Wenn man in einer ISR komplett eigenes Zeug machen will,
dann definiert man eine naked Funktion.
Mit <tt>naked</tt> befreit man die Routine vom Standard-Prolog/Epilog.
{{FarbigerRahmen|
Dabei ist darauf zu achten, daß die ISR mit <tt>reti</tt> (return from interrupt)
zurückkehrt und evtl. verwendete Register und den Status (<tt>SREG</tt>) sichert.

Komplexer oder nicht optimierter C-Code, der einen Framepointer braucht, funktioniert nicht mehr weil ohne Prolog der Framepointer nicht initialisiert wird. Die geschieht wenn nicht alle Werte in Registern gehalten werden können und vom Compiler auf dem Stack zwischengespeichert werden.
}}
#include <avr/io.h>
#include <avr/interrupt.h>

ISR (TIMER0_OVF_vect, ISR_NAKED)
{
{{ccomment|Port B.6 = 0}}
{{ccomment|Diese Instruktion verändert nicht das SREG und kein anderes Register}}
{{ccomment|so daß der eigentliche Code nur 1 Befehl lang ist}}
__asm__ __volatile (
"cbi %0, %1" "\n\t"
"reti"
:
: "M" (_SFR_IO_ADDR (PORTB)), "i" (6)
);
}

Siehe auch [[Inline-Assembler in avr-gcc]].
Die ISR sieht dann so aus:
<pre>
__vector_9:
c6 98 cbi 0x18, 6
18 95 reti
</pre>

Wiederum kann man als Funktionsname <tt>__vector_default</tt> nehmen,
um nicht-implementierte IRQs abzufangen:
<pre>
void __attribute__ ((naked, used))
__vector_default (void)
...
</pre>

==SRAM, Flash, EEPROM: Datenablage am Beispiel Strings==
Die Programmiersprache C kennt selber keine Strings; das einzige, was C bekannt ist, ist der Datentyp <tt>char</tt>, der ein einzelnes Zeichen repräsentiert.
===Darstellung in C===
Ein String im Sinne von C ist ein Array von Charactern bzw. ein Zeiger auf den Anfang des Arrays. Die einzelnen Zeichen folgen im Speicher direkt aufeinander und werden in aufsteigenden Adressen gespeichert. Am String-Ende folgt als Abschluss der Character <tt>'\0'</tt>, um das Ende zu kennzeichnen. Dies ist besonders bei der Berechnung des Speicherplatzes für Strings zu berücksichtigen, denn für die 0 muss auch Platz reserviert werden.

===Bestimmen der Stringlänge===
<pre>
/* Bestimmt die Laenge des Strings ohne die abschliessende '\0' zu zaehlen */
unsigned int strlength (const char *str)
{
unsigned int len = 0;

while (*str++)
len++;

return len;
}
</pre>

Die Stringlänge kann auch mit der Standard-Funktion <tt>strlen</tt> bestimmt werden, deren Prototyp sich in <tt>string.h</tt> befindet:
<pre>
#include <string.h>
size_t strlen (const char*);
</pre>

===String im Flash belassen===
Oftmals werden Strings nur zu Ausgabezwecken verwendet und nicht verändert. Verwendet man Sequenzen der Gestalt
<pre>
char *str1 = "Hallo Welt!";
char str2[] = "Hallo Welt!";
</pre>
dann werden die Strings im SRAM abgelegt. Im Startup-Code werden die Strings vom Flash ins SRAM kopiert und belegen daher sowohl Platz im SRAM als auch im Flash. Wird ein String nicht verändert, braucht er nicht ins SRAM kopiert zu werden. Das spart Platz im knapp bemessenen SRAM. Allerdings muss anders auf den String zugegriffen werden, denn wegen der Harvard-Architektur des AVR-Kerns kann avr-gcc anhand der Adresse nicht unterscheiden, ob diese ins SRAM, ins Flash oder ins EEPROM zeigt.
<pre>
#include <avr/pgmspace.h>

const char str3[] PROGMEM = "Hallo Welt!";

size_t strlen_P (const char *str)
{
size_t len = 0;

while (1)
{
char c = (char) pgm_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}

void foo (void)
{
size_t len;
len = strlen_P (str3);
len = strlen_P (PSTR ("String im Flash"));
}
</pre>

===String ins EEPROM legen===
Dies geht nach dem gleichen Muster, nach dem Strings ins Flash gelegt werden. Der Zugriff wird vergleichsweise langsam, denn der EEPROM ist langsamer als SRAM bzw. Flash.
<pre>
#include <avr/eeprom.h>

const char str4[] EEMEM = "Hallo Welt!";

size_t strlen_EE (const char *str)
{
size_t len = 0;

while (1)
{
char c = (char) eeprom_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}
</pre>

==Reset auslösen==

Falls ein Reset per Software ausgelöst werden soll, dann geht das am besten über den [[Watchdog]].
Einfach nur an den Reset-Punkt an Adresse 0 zu springen
initialisiert zwar den Controller von neuem, aber es macht keinen wirkliches RESET mit Zurücksetzen der Hardware und allen I/O-Registern.

Durch den Watchdog kann man ein 'richtiges' RESET-Signal erzeugen lassen, so daß die AVR-Hardware genau so initialisiert ist, wie nach einem externen RESET. So kann man z.B. via [[UART]] ein RESET-Kommando schicken. Allerdings lässt sich der Watchdog nur minimal auf 15ms einstellen:

#include <avr/wdt.h>
#include <avr/interrupt.h>
...
cli(); {{ccomment|Interrupts global abschalten}}
wdt_enable (WDTO_15MS); {{ccomment|Watchdog aufziehen auf 15ms}}
while (1); {{ccomment|warten, bis er zubeisst...}}

Welches Ereignis einen RESET ausgelöst hat, kann man im Register '''MCUCSR''' (''MCU Control and Status Register'') erfahren. Es gibt 4 mögliche RESET-Quellen:
* Power-On Reset
* External Reset
* Brown-Out Reset
* Watchdog Reset

Soll der Inhalt von Variablen einen Reset überleben – eine Variable also nicht initialisiert werden – dann geht das so:
#include <avr/io.h>

{{ccomment| status informiert z.B. darüber, ob wir selber den Watchdog ausgelöst haben }}
{{ccomment| oder nicht, oder andere Informationen }}
uint8_t status __attribute__ ((__section__ (".noinit")));

int main (void)
{
{{ccomment|Wert von MCUSCR merken, möglichst früh im Programm }}
uint8_t mcucsr = MCUCSR;

{{ccomment|MCUCSR zurücksetzen }}
MCUCSR = 0;

{{ccomment|Watchdog-Reset }}
if (mcuscr & (1 << WDRF))
{
{{ccomment|status auswerten }}
}

{{ccomment|Power-On Reset: status auf definierten Wert setzen }}
if (mcuscr & (1 << PORF))
{
status = 0;
}

{{ccomment|status auswerten }}
...
}

; An Adresse 0 springen

Falls wirklich zu Adresse 0 gesprungen werden soll – was in einem Bootloader erforderlich sein kann – dann geschieht das mittels einer Funktion <tt>reset</tt> wie folgt:
extern void reset (void) __attribute__((noreturn));
reset();
<tt>reset</tt> wird bein Linken mittels <tt>-Wl,--defsym=reset=0</tt> auf 0 gesetzt.
Weitere Möglichkeit ist, im erzeugten Assembler <tt>0</tt> als Funktionsnamen zu verwenden:
extern void reset (void) __asm__("0") __attribute__((__noreturn__));
reset();

=Includes=

Die mit
#include <...>
angegebenen Includes werden von avr-gcc in den
mit der Option '<tt>-I</tt>' anegegenen Pfaden gesucht.
Dem Compiler bekannt sind die Pfade
<GCC_HOME>/avr/include Standard (stdio.h, ...)
<GCC_HOME>/avr/include/avr AVR-spezifisch (avr/io.h, ...)
<GCC_HOME>/lib/gcc/avr/<GCC_VERSION>/include Standard, compilerabh. (limits.h, ...)

Gibt man z.B. an
#include <stdio.h>
dann wird automatisch in diesem Verzeichnis nach <tt>stdio.h</tt> gesucht.
In den Verzeichnissen stehen Standard-Includes, die benötigt werden, wenn man libc-Funktionen
oder mathematische Funktionen etc. verwendet.
AVR-spezifische Dinge stehen im Unterverzeichnis <tt>avr</tt>, etwa:
#include <avr/io.h>
{{FarbigerRahmen|
Als Pfad-Separator wird immer ein '''<tt>/</tt>''' verwendet, auch auf Windows-Betriebssystemen! Also kein '''<tt>\</tt>''' !
}}

==Standard==

ctype.h Zeichen-Umwandlungs-Makros und ctype Makros
errno.h Symbolische Namen für Fehlercodes
stdint, inttypes.h C99 definiert [u]intN_t wenn man genau N [un]signed
Bits braucht
math.h Mathematische Funktionen: sin, cos, log, gamma, bessel, ...
setjmp.h libc unterstützt setjmp() und longjmp(), um direkt in eine
andere (nicht-lokale) Funktion zu springen.
stdio.h Standard I/O-Funktionen (printf, fscanf, ...)
stdlib.h Deklariert grundlegende ISO C Makros und Funktionen
sowie einige AVR-spezifische Erweiterungen
string.h Stringoperationen auf NULL-terminierten Strings. (strlen, ...)
stdarg.h Funktionen mit variabler Argumenanzahl
limits.h Min- und Max-Werte von Skalaren (UCHAR_MAX, LONG_MIN, ...)

==AVR-spezifisch==

Die AVR-spezifischen Includes finden sich wie gesagt im Unterverzeichnis <tt>avr</tt>.
Die meisten dort befindlichen Header wird man nie direkt durch Angabe im C-File erhalten,
sondern durch Angabe von
#include <avr/io.h>
Dadurch werden genau die I/O-Header eingebunden, die zum AVR-Modell passen, also z.B. <tt>avr/iom8.h</tt> für [[ATmega8]] etc. Verantwortlich für die Auswahl des richtigen Sub-Headers ist der Schalter '<tt>-mmcu=xxx</tt>'.

Obwohl diese Sub-Header nicht explizit angegeben werden müssen,
kann ein Blick dorthin hilfreich sein, um die Namen von [[SFR|SFRs]]
oder Signals nachzuschlagen.
Diese Header werden im folgenden nicht alle einzeln aufgelistet.
Ihre Namen sind immer <tt>avr/io*.h</tt>.
* für ATmega: <tt>avr/iom*.h</tt>
* für ATtiny: <tt>avr/iotn*.h</tt>
<pre>
avr/boot.h Bootloader Support
avr/eeprom.h EEPROM-Routinen
avr/interrupt.h sei(), cli(), ISR(), ...
avr/io.h RAMEND, ***_vect, SFRs: PORTB, DDRB, PINB, SREG, ...,
avr/pgmspace.h Zugriff aufs Flash: Byte lesen, PROGMEM, pgm_read_***, ...
avr/sleep.h Power-Safe und Sleep-Modes
avr/wdt.h Watchdog

util/crc16.h Prüfsumme CRC16
util/delay.h Verzögerungsschleifen für kurze, exakte Verzögerungen
util/parity.h Parität
util/twi.h I2C
</pre>

==Anwendungs-spezifisch==
Eigene Header, die nur innerhalb eigener Projekte gebraucht werden, includet man mit
#include "..."
Auch hier darf man Unterverzeichnisse angeben oder ins übergeordnete Verzeichnis:
#include "../../mein-zeug.h"
Mit der Option <tt>-I<path></tt> kann ein Pfad zu den bekannten Include-Pfaden hinzugefügt werden; im obigen Beispiel etwa <tt>-I../..</tt> und im Programm dann:
#include "mein-zeug.h"

= Optimierungen, Tipps & Tricks =
:→ ''Hauptartikel: [[avr-gcc/Optimierungen|avr-gcc Optimierungen]]''

=Abkürzungen und Bezeichnungen=
; [[GCC]]: GNU Compiler Collection
; gcc: GNU C-Compiler
; GPR: '''G'''eneral '''P'''urpose '''R'''egister
; [[ISR]]: [[Interrupt|'''I'''nterrupt]] '''S'''ervice '''R'''outine
; [[IRQ]]: '''I'''nterrupt '''R'''e'''q'''uest
; Prolog/Epilog: Code am Anfang/Ende jeder Funktionen/ISR, der dazu dient, verwendete Register zu sichern, den Stack-Frame für lokale [[Variable|Variablen]] anzulegen (falls benötigt), Stackpointer zu setzen, zurück zu springen (<tt>ret</tt>, <tt>reti</tt>), etc.
; SFR: '''S'''pecial '''F'''unction '''R'''egister
; Target: Zielsystem, in unserem Falle avr

=Siehe auch=
* [[C-Tutorial]]
'''Code-Beispiele'''
* [[Hallo Welt für AVR (LED blinken)]] - ein erstes Beispiel für avr-gcc
*[[:Kategorie:Quellcode_C|C-Codebeispiele]]
* [[Fallstricke bei der C-Programmierung]]

'''Details'''
* [[Inline-Assembler in avr-gcc|Inline-Assembler]]
* [[avr-gcc/Interna|Interna von avr-gcc]]

'''Installation (Linux)'''
* [[Linuxdistribution_Avr-live-cd]]
* [[avr-gcc und avrdude installieren]]
'''Sonstiges'''
* [[WinAVR]]
* [[Speicherverbrauch bestimmen mit avr-gcc]]
* [[Compiler]]
* [[Dev-Cpp IDE]]
* [[AVR]]
----
* [[Sourcevergleich]]
* [[Codevergleich AVR-Compiler]]

=Weblinks=
==Dokumentation==

;Offline:

Je nach Distribution wird diese mit offline-Dokumentation als pdf, HTML, etc. ausgeliefert, die dann z.B. in Ordern wie den folgenden befindet:

: <GCC_HOME>/doc/gcc/
: <GCC_HOME>/doc/avr-libc/
: etc.

; Online

* [http://gcc.gnu.org/onlinedocs/cpp.pdf cpp.pdf (470 kByte)] - Dokumentation des C-Präprozessors (en)
* [http://www.nongnu.org/avr-libc/user-manual/pages.html AVR Libc: User Manual] - Dokumentation zur [http://www.nongnu.org/avr-libc AVR Libc].
* [http://sourceware.org/binutils/docs/ Binutils: Documentation] – Dokumentation der Binutils: Assembler, Linker, ...
* [http://gcc.gnu.org/wiki/avr-gcc avr-gcc im GCC Wiki] – Dokumentation des Application Binary Interface (ABI): Registerverwendung, Calling Conventions, ...
{| {{Blauetabelle}}
! [http://gcc.gnu.org GCC] Version ||colspan="2"| [http://gcc.gnu.org/onlinedocs Dokumentation] || AVR Options || Release Notes
|-
! Aktuelle Entwicklung
| [http://gcc.gnu.org/onlinedocs/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-5/changes.html GCC 5]
|-
! 4.9.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.9/changes.html GCC 4.9]
|-
! 4.8.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.8.3/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.8.3/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.8.3/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.8/changes.html GCC 4.8]
|-
! 4.7.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.7.4/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.7.4/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.7.4/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.7/changes.html GCC 4.7]
|-
! 4.6.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.6/changes.html GCC 4.6]
|-
! 4.5.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.5.4/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.5.4/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.5.4/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.5/changes.html GCC 4.5]
|-
! 4.4.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.4/changes.html GCC 4.4]
|-
! 4.3.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.3.5/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.3.5/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.3.5/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.3/changes.html GCC 4.3]
|-
! 3.4.x
| [http://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-3.4/changes.html GCC 3.4]
|}

== Downloads==
* [http://sourceforge.net/projects/winavr/ WinAVR-Projekt bei sourceforge.net (en)]
* [http://cdk4avr.sourceforge.net/ avr-gcc und toolchain als Linux-Paket bei sourceforge.net (en)]
* [[Linuxdistribution_Avr-live-cd]]
== Tipps, Installation ==
*[http://www.nongnu.org/avr-libc/user-manual/install_tools.html ''"Installing the GNU Tool Chain"''] Hilfe zum Build und Installation von GCC, binutils, etc unter Linux
* Im GCC-Handbuch, siehe [[#Dokumentation|Dokumentation]].
* [http://www.linuxfocus.org/Deutsch/November2004/article352.shtml www.linuxfocus.org (Artikel)] - Tipps zu Build und Installation von avr-gcc, binutils und avr-libc unter Linux
* [http://users.rcn.com/rneswold/avr/ Rich Neswold: ''A GNU Development Environment for the AVR Microcontroller'']
* [http://www.mikrocontroller.net/topic/24166 www.mikrocontroller.net (Foren-Beitrag)] - Installation von GCC und Toolchain unter Mac OS X
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=125603#125603 www.roboternetz.de (Foren-Beitrag)] ''avrgcc + avrdude installieren''
* [http://roboternetz.de/download/c_tutorial.zip AVR-Studio & C-Tutorial mit Installationsanleitung]

== Sonstiges ==
* [http://gcc.gnu.org/ Offizielle Homepage von GCC (en)]
* [http://de.wikipedia.org/wiki/GNU_Compiler_Collection GCC in der deutschen Wikipedia]
* [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial avr-gcc-Tutorial auf mikrocontroller.net]
* [http://savannah.nongnu.org/projects/avr-libc/ Nützliche GCC Runtime-Libary]
* [http://www.stromflo.de/dokuwiki/doku.php Atxmega-C-Tutorial]

=Autor=

--[[Benutzer:SprinterSB|SprinterSB]] 11:27, 7. Dez 2005 (CET)

[[Kategorie:Grundlagen]]
[[Kategorie:Microcontroller]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]

Inline-Assembler in avr-gcc

2014-09-13T11:09:54Z

SprinterSB: /* Fallstricke */

In C versteht man unter '''Inline Assembler''' die Möglichkeit, direkt Assembler-Befehle in den Code einzufügen bzw. die eingefügten Assembler-Befehle selbst.

Neben den einzufügenden Befehlen muss beschrieben werden, welche Nebeneffekte die Befehle auf die Maschine haben und wo/wie Parameter übergeben werden, bzw. wie die Zuordnung von Variablen zu den Registern ist. Diese Beschreibung ist notwendig weil der [[Compiler]] keine Vorstellung davon hat, welche Effekte und Nebenwirkungen die Assembler-Kommandos auf Register, Variablen und Speicher haben, denn der Assembler-Schnippsel ist für den Compiler lediglich eine "Black Box".

Obgleich das dazu verwendete Schlüsselwort <tt>__asm</tt> zum ANSI-C-Standard gehört, ist dies in jedem C-Compiler anders implementiert. Das gilt insbesondere für die Schnittstellenbeschreibung Variablen/Register. Dieser Artikel bezieht sich auf den Inline Assembler von [[avr-gcc]].
Viele Erklärungen aus diesem Artikel sind auch gültig für Inline-Assembler anderer C-Compiler der [[gcc]]-Familie. Instruktionen und Registerklassen werden sich aber unterscheiden, weil diese natürlich abhängig sind vom verwendeten Controller bzw. der Controller-Familie.

=Assembler oder Inline-Assembler?=
;Assembler: Längere und komplexere Code-Stücke sind komfortabler direkt in Assembler auszudrücken. Dazu schreibt man Assembler-Funktionen und ruft diese von C aus auf. Natürlich können auch C-Funktionen von Assembler aus aufgerufen werden. Zudem kann man im Assembler den C-Präprozessor nutzen, was bei Inline-Assembler nur auf C-Ebene geht. Der Build-Prozess wird allerdings komplizierter, da extra asm-Dateien übersetzt werden müssen. Ein typischer Fall ist es, eine komplette ISR in Assembler zu schreiben.
;Inline-Assembler: Mit Inline-Assembler kann man kleine Assembler-Stückchen direkt in den C-Code einbetten. Es muss dann keine Assembler-Funktion aufgerufen werden. Dies kann von der Registerverwendung her deutlich günstiger sein, da [[gcc]] genau weiß, welche Register gebraucht werden und welche nicht.
:Eine (Assembler-)Funktion ist hingegen eine Black Box, bei der von der Standard-[[avr-gcc/Interna#Registerverwendung|Registerverwendung]] ausgegangen werden muss, auch wenn weniger Register in der Funktion verwendet werden. Ein Funktionsaufruf bedeutet also meistens einen Laufzeit-Overhead im Vergleich zu einem Inline-Code.
:Bei mehrfacher Verwendung einer längeren Codesequenz ist eine Funktion jedoch sparsamer im [[Flash]]-Verbrauch. Legt man eine Funktion als C-Funktion an und ihren Body als Inline-Assembler (eine s.g. Stub-Funktion, von engl. ''Stub'' = Stumpf), dann übernimmt gcc das Verwalten von Funktions-Argumenten, return-Wert, etc. und man brauch sich nicht selber um die Aufruf-Konvention zu kümmern. Auch innerhalb einer Funktion kann C mit Assembler gemischt werden.
:Ein Vorteil von Inline-Assembler ist, daß eine C-Funktion, die Inline-Assembler enthält, vom C-Compiler [[C-Tutorial#Inlining|geinlinet]] werden kann. Dies ist mit einer reinen Assembler-Funktion nicht möglich.

=Begriffe=
;Assembler-Template: Das Template (''Schablone'') ist ein statischer, konstanter String im Sinne von C. Es enthält die Assembler-Befehle sowie Platzhalter, in deren Stelle später die Operanden treten
;Constraint: Die Constraints (''Nebenbedingungen'') beschreiben Einschränkungen an die zu verwendeten Register. Dies ist notwendig, da nicht alle Maschinenbefehle auf alle Register anwendbar sind
;Clobber-List: Das ist eine Liste von Registern, deren Inhalt durch den Inline-Assembler zerstört wird

=Syntax und Semantik=
Das Schlüsselwort, um eine Inline-Assembler Sequenz einzuleiten, ist <tt>__asm</tt> (ANSI). Oft ist auch <tt>asm</tt> oder <tt>__asm__</tt> verwendbar. Um zu kennzeichnen, daß die Sequenz keinesfalls wegoptimiert werden darf – etwa dann, wenn der Assembler keine Wirkung auf C-Variablen hat – wird dem <tt>asm</tt> ein <tt>volatile</tt> bzw. <tt>__volatile</tt> nachgestellt. Danach folgen in runden Klammern die durch <tt>''':'''</tt> getrennten Abschnitte des Inline-Assemblers:
asm volatile ([[#Assembler-Template|asm-template]] : [[#Operanden und Constraints|output-operand-list]] : [[#Operanden und Constraints|input-operand-list]] : [[#Clobbers|clobber-list]]);

Abschnitte, die leer sind, können auch weggelassen werden, wenn dahinter kein weiterer Abschnitt folgt:
asm volatile (asm-template);

Oder, wenn weder Input- noch Output-Operanden gebraucht werden, aber Register oder Speicher verändert werden:
asm volatile (asm-template ::: clobber-list);

{{FarbigerRahmen |
Aus Compiler-Sicht werden die Assembler-Befehle im Template parallel, also ''gleichzeitig'' ausgeführt! Dies ist zu bedenken, wenn Register sowohl als Input als auch als Output verwendet werden.
}}

Ab Version 4.5 kennt GCC <tt>asm goto</tt>, mit dem ausgedrückt werden kann, dass der Codefluß des Assembler-Teils u.U. zu einem Stück C-Code springt:
asm goto ([[#Assembler-Template|asm-template]] : {{comment|Leer}} : [[#Operanden und Constraints|input-operand-list]] : [[#Clobbers|clobber-list]] : [[#asm goto mit C-Labels|C-labels]]);

== Assembler-Template ==

Im Template stehen die durch Zeilenumbrüche getrennten Assembler-Befehle. Das Template kann zudem <tt>%</tt>-Ausdrücke als Platzhalter enthalten, welche durch die Operanden ersetzt werden. Dabei bezieht sich <tt>%0</tt> auf den ersten Operanden, <tt>%1</tt> auf den zweiten Operanden, etc.
Die Operanden selbst werden im zweiten und dritten Abschnitt des Templates als Komma-getrennte Liste angegeben.
Diese Ersetzung findet jedoch nur dann statt, wenn das asm nicht nur aus einem String besteht:
asm ("10% mehr"); {{comment|"10% mehr"}}
asm ("10%% mehr" :); {{comment|"10% mehr"}}

Ein Platzhalter kann zusätzlich einen einbuchstabigen Modifier enthalten, um den Operanden in printf-ähnlicher Manier in einem speziellen Format darzustellen. Wird z.B. ein Wert ab Register <tt>r28</tt> (dem Y-Register) gehalten, dann wären folgende Ersetzungen denkbar (als erstes Argument):

:<tt>%0     →  r28</tt>

:<tt>%A0    →  r28</tt><br/>
:<tt>%B0    →  r29</tt><br/>
:<tt>%C0    →  r30</tt><br/>
:<tt>%D0    →  r31</tt>

:<tt>%a0    →  y  </tt>

Im einfachsten Falle enthält das Templater nur einen Befehl:
"nop"
oder sogar garkeinen Befehl oder lediglich einen Kommentar:
"; ein Kommentar"

:{| {{Blauetabelle}}
|+ '''Tabelle: asm-Platzhalter und ihre Modifier, Sonderzeichen'''
|- {{Hintergrund1}}
! Platzhalter || wird ersetzt durch || AVR-spezifisch
|- valign="top"
|<tt>%''n''</tt> || Wird ersezt durch Argument <tt>''n''</tt> mit <tt>''n''</tt> = 0...9
|
|- valign="top"
|<tt>%A''n''</tt> || das erste (untere) Register des Arguments <tt>''n''</tt> (Bits 0...7)
|align="center" rowspan="4"| '''X'''
|- valign="top"
|<tt>%B''n''</tt> || das zweite Register des Arguments <tt>''n''</tt> (Bits 8...15)
|- valign="top"
|<tt>%C''n''</tt> || das dritte Register des Arguments <tt>''n''</tt> (Bits 16...23)
|- valign="top"
|<tt>%D''n''</tt> || das vierte Register des Arguments <tt>''n''</tt> (Bits 24...31)
|- valign="top"
|<tt>%a''n''</tt> || Ausgabe des Arguments als Adress-Register,<br/>also als <tt>x</tt>, <tt>y</tt> bzw. <tt>z</tt>. Erlaubt zusammen mit Constraint <tt>b</tt>, <tt>e</tt>, <tt>x</tt>, <tt>y</tt>, <tt>z</tt>
|align="center"| '''X'''
|- valign="top"
|<tt>%i''n''</tt> || Ab 4.7. Ausgabe einer RAM-Adresse als I/0-Adresse. Beispiel: <tt>0x30</tt> wird auf Xmega-Controllern als <tt>0x30</tt> ausgegeben und auf nicht-Xmega als <tt>0x10</tt>.
|align="center"| '''X'''
|- valign="top"
|<tt>%r''n''</tt> || Ab 4.8. Ausgabe eines Registers ohne die Register-Präfix "r". Damit kann per Inline-Assembler auf 64-Bit Variablen zugegriffen werden, z.B. kann mit <tt>"clr %r0+7"</tt> das High-Byte gelöscht werden.
|align="center"| '''X'''
|- valign="top"
|<tt>%T''n''%T''m''</tt> || Ab 4.7. Gibt einen Doppel-Operanden aus wie er zum Beispiel in BLD oder BST benötigt wird, d.h. durch ein Komma getrennte Register- und Bitnummer. Das erste <tt>%T</tt> erhält ein Register und speichert es zwischen bis zum nächsten <tt>%T</tt>, das die konstante Bitnummer ''m'' enthält. Die Ausgabe erfolgt erst mit dem zweiten <tt>%T</tt>: Beispielsweite kann durch folgende Zeile das High-Bit von ''var'' gelöscht werden:
asm ("clt $ bld %T[v]%T[b]" : [v] "+r" (var) : [b] "n" (8*(sizeof var)-1));
|align="center"| '''X'''
|- valign="top"
|<tt>%T''n''%t''m''</tt> || Ab 4.7. Funktioniert wie <tt>%T''n''%T''m''</tt>, es wird aber nur das zum Bit ''m'' gehörende Register ausgegeben, d.h. weder Komma noch Bitnummer.
|align="center"| '''X'''
|- valign="top"
|<tt>%x''n''</tt> || Ab 4.5. Gibt ein Label ohne Operand-Modifier <tt>gs()</tt> aus.
|align="center"| '''X'''
|- valign="top"
|<tt>%~</tt> || wird auf AVR mit Flash bis max. 8kiByte durch ein <tt>r</tt> ersetzt, ansonsten bleibt es leer.<br/>Zum Aufbau von Sprungbefehlen, etwa "<tt>%~call foo</tt>"
|align="center"| '''X'''
|- valign="top"
|<tt>%!</tt> || Ab 4.4. Wird auf AVR mit Flash ab 128kiByte durch ein <tt>e</tt> ersetzt, ansonsten bleibt es leer.<br/>Zum Aufbau von indirekten Sprungbefehlen, etwa "<tt>%!icall</tt>"
|align="center"| '''X'''
|- valign="top"
|<tt>%=</tt> || eine für dieses asm-Template und die Übersetzungseinheit eindeutige Zahl.<br/>Zum Aufbau lokaler Sprungmarken.
|
|- {{Hintergrund1}}
! Sequenz || wird ersetzt durch Sonderzeichen || AVR-spezifisch
|- valign="top"
|<tt>%%</tt> || das <tt>%</tt>-Zeichen selbst
|
|- valign="top"
|<tt>\n</tt> || ein Zeilenumbruch zum Trennen mehrerer asm-Befehle/Zeilen
|
|- valign="top"
|<tt>$</tt> || trennt mehrere Befehle in der gleichen Zeile
|align="center"| '''X'''
|- valign="top"
|<tt>\t</tt> || ein TAB, zur Übersichtlichkeit im erzeugten asm ||
|- valign="top"
|<tt>\"</tt> || ein <tt>"</tt> wird eingefügt ||
|- valign="top"
|<tt>\\</tt> || das <tt>\</tt>-Zeichen selbst ||
|- {{Hintergrund1}}
! Kommentar || Beschreibung || AVR-spezifisch
|- valign="top"
|<tt>; ''Text''</tt> || einzeiliger Kommentar bis zum Ende des Templates bzw. nächsten Zeilenumbruch
|align="center"| '''X'''
|- valign="top"
|<tt>/* ''Text'' */</tt> || mehrzeiliger Kommentar wie in C ||
|}

== Operanden und Constraints ==

Ein Operand besteht aus der Angabe des Constraint-Strings (also der Registerklasse und Kennzeichnung, ob es sich um einen Output-Operanden handelt) und dahinter in runden Klammern der C-Ausdruck, der in Register der angegebenen Klasse geladen werden soll. Die Operanden werden mit 0 beginnend von links nach rechts durchnumeriert und über diese Nummer angesprochen, um sie ins Assembler-Schnippsel einzufügen.

Mehrere Input- bzw. Output-Operanden werden durch Komma getrennt.

:{| {{Blauetabelle}}
|+ '''Tabelle: Constraints und ihre Bedeutung'''
|- {{Hintergrund1}}
! Constraint || Register || Wertebereich
|rowspan="14"| 
! Constraint || Konstante || Wertebereich
|-
|<tt>a</tt>||einfache obere Register||<tt>r16</tt>...<tt>r23</tt>
|<tt>G</tt>||Floatingpoint-Konstante ||<tt>0.0</tt>
|-
|<tt>b</tt>||Pointer-Register ||<tt>y</tt>, <tt>z</tt>
|<tt>i</tt>||Konstante, entspricht <tt>"sn"</tt> || 
|-
|<tt>d</tt>||obere Register ||<tt>r16</tt>...<tt>r31</tt>
|<tt>s</tt>||symbolischer Wert ||  
|-
|<tt>e</tt>||Pointer-Register ||<tt>x</tt>, <tt>y</tt>, <tt>z</tt>
|<tt>n</tt>||Wert bekannt zur Compilezeit || 
|-
|<tt>l</tt>||untere Register ||<tt>r0</tt>...<tt>r15</tt>
|<tt>I</tt>||positive 6-Bit-Konstante ||0...63
|-
|<tt>q</tt>||Stack-Pointer ||<tt>SPH:SPL</tt>
|<tt>J</tt>||negative 6-Bit Konstante ||<tt>-</tt>63...0
|-
|<tt>r</tt>||ein Register ||<tt>r0</tt>...<tt>r31</tt>
|<tt>M</tt>||8-Bit Konstante ||0...255
|-
|<tt>t</tt>||Scratch-Register ||<tt>r0</tt>
|colspan="3" | 
|-
|<tt>w</tt>||obere Register-Paare ||<tt>r24</tt>, <tt>r26</tt>, <tt>r28</tt>, <tt>r30</tt>
!{{Hintergrund1}}| Constraint ||{{Hintergrund1}}| Memory ||{{Hintergrund1}}| Wertebereich
|-
|<tt>x</tt>||Pointer-Register X ||<tt>x</tt> (<tt>r27:r26</tt>)
|<tt>m</tt>|| Memory ||  
|-
|<tt>y</tt>||Pointer-Register Y ||<tt>y</tt> (<tt>r29:r28</tt>)
|colspan="3" rowspan="3"| 
|-
|<tt>z</tt>||Pointer-Register Z ||<tt>z</tt> (<tt>r31:r30</tt>)
|-
|<tt>0</tt>...<tt>9</tt>||colspan="2"|Identisch mit dem angegebenen Operanden<br/>Wird verwendet, wenn ein Operand sowohl als Input<br/>als auch als Output dient, um sich auf diesen<br/>Operanden zu beziehen
|}

:{| {{Blauetabelle}}
|+ '''Tabelle: Constraint Modifier'''
|- {{Hintergrund1}}
!Modifier || Bedeutung
|-
|<tt>=</tt> || der Operand ist Output-Operand
|-
|<tt>&</tt> || diesen Operanden ''nicht'' als Input-Operanden verwenden,<br/>sondern nur als Output-Operand
|-
|<tt>+</tt> || dieser Operanden ist Input- und Output-Operand
|}

Ein Input-Operand könnte also so aussehen, wobei <tt>foo</tt> eine C-Variable ist. Als Register dient ein (je nach Typ von <tt>foo</tt> auch mehrere) obere Register, irgendwo von <tt>r16</tt> bis <tt>r31</tt> (Constraint <tt>"d"</tt>):
"d" (foo)

In den Klammern kann ein beliebiger, gültiger C-Ausdruck stehen, der beim folgenden Beispiel in irgendeinem Register landet (Constraint <tt>"r"</tt>), ohne weitere Einschränkung an das Register:
"r" ((foo >= 0) ? foo : -foo)

Um einen Operanden als Output-Operanden zu kennzeichnen, wird dem Constraint ein <tt>"="</tt> vorangestellt.
Soll <tt>foo</tt> ein Output-Operand sein, der in den Registern <tt>r0</tt>...<tt>r15</tt> landen soll (Constraint <tt>"l"</tt>, sieht es so aus. Dabei muss <tt>foo</tt> ein sogenannter Lvalue sein, also ein Wert, dem etwas zugewiesen werden kann:
"=l" (foo)

Ist <tt>foo</tt> sowohl Input als auch Output, schreibt man <tt>foo</tt> als Output- und als Input-Operand hin. In der Input-Constraint bezieht man sich dann auf die Operanden-Nummer von <tt>foo</tt>. Hier ein komplettes Beispiel, das die Nibbles von <tt>foo</tt> tauscht. Weil <tt>swap</tt> auf alle Register anwendbar ist, kann als Registerklasse <tt>"r"</tt> genommen werden:
<pre>
unsigned char foo;
...
asm ("swap %0" : "=r" (foo) : "0" (foo));
</pre>
<tt>foo</tt> als Input-Operand soll im gleichen Register liegen wie <tt>foo</tt> als Output-Operand. Daher wird als Constraint <tt>"0"</tt> angegeben, d.h. es wird ins gleiche Register geladen wie der Operand Numero 0 <tt>"r" (foo)</tt>.

=== Benannte Constraints ===

Um das Assembler-Schnippsel besser lesbar zu halten, kann man Constraints einen Namen geben:
asm ("swap %[bar]" : [bar] "+r" (foo));
Damit ist der Assembler auch unabhängig von der Reihenfolge der Operanden. Das macht die Anpassung, wenn ein neuer Operand hinzukommt, wesentlich einfacher und den Schnippsel zudem besser lesbar.

Hier wird <tt>bar</tt> als Alias für die C-Variable <tt>foo</tt> benutzt; es könnte aber auch jeder andere gültige C-Bezeichner sein, also insbesondere auch <tt>foo</tt>.

=== Instruktionen und Constraints ===

Die folgende Tabelle enhält eine Auflistung von AVR-Instruktionen und dazu passende Argumente bzw. Constraints. Nicht alle Shorthands sind in der Tabelle enthalten, so ist "<tt>clr Rn</tt>" nur eine Abkürzung für "<tt>eor Rn, Rn</tt>", ähnliches gilt für den Zoo von Instruktionen rund um das SREG wie branch, bit set, bit clear, etc., die im Endeffekt auf nur vier Instruktionen abbilden. Instruktionen wie <tt>nop</tt>, die keine Argumente brauchen, sind ebenfalls nicht in der Tabelle enthalten. Gleiches gilt für den Krypto-Befehl <tt>des</tt>, für die keine Constraint verfügbar ist.

<tt>"load"</tt> ist ein <tt>"load from SRAM"</tt><br/>
<tt>"store"</tt> ist <tt>"store to SRAM"</tt><br/>

:{| {{Blauetabelle}}
|+'''Tabelle: Übersicht AVR-Instruktionen und passende Constraints'''
|- {{Hintergrund1}}
!Mnemonic || Constraint ||Bedeutung ||rowspan="35"| 
!Mnemonic || Constraint ||Bedeutung
|-
| <tt>adc</tt>||<tt>r,r</tt> || add with carry
| <tt>add</tt>||<tt>r,r</tt> || add
|-
| <tt>adiw</tt>||<tt>w,I</tt> || add immediate to word
| <tt>and</tt>||<tt>r,r</tt> || and
|-
| <tt>andi</tt>||<tt>d,M</tt> || and with immediate
| <tt>asr</tt>||<tt>r</tt> || arithmetic shift right
|-
| <tt>bclr</tt>||<tt>I</tt> || bit clear in SREG
| <tt>bld</tt>||<tt>r,I</tt> || bit load from T
|-
| <tt>brbc</tt>||<tt>I,label</tt> || branch if bit in SREG clear
| <tt>brbs</tt>||<tt>I,label</tt> || branch if bit in SREG set
|-
| <tt>bset</tt>||<tt>I</tt> || bit set in SREG
| <tt>bst</tt>||<tt>r,I</tt> || bit store from T
|-
| <tt>cbi</tt>||<tt>I,I</tt> || clear bit in I/O
| <tt>com</tt>||<tt>r</tt> || complement
|-
| <tt>cp</tt>||<tt>r,r</tt> || compare
| <tt>cpc</tt>||<tt>r,r</tt> || compare with carry
|-
| <tt>cpi</tt>||<tt>d,M</tt> || compare against immediate
| <tt>cpse</tt>||<tt>r,r</tt>|| compare, skip if equal
|-
| <tt>dec</tt>||<tt>r</tt> || decrement
| <tt>[e]lpm</tt>||<tt>r,z</tt>|| load from program memory<sup>1</sup>
|-
| <tt>eor</tt>||<tt>r,r</tt> || exclusive-or
| <tt>fmul*</tt>||<tt>a,a</tt> || fractional multiply
|-
| <tt>in</tt>||<tt>r,I</tt> || input from I/O
| <tt>inc</tt>||<tt>r</tt> || increment
|-
| <tt>lac</tt>||<tt>z,r</tt> || load and clear
| <tt>lat</tt>||<tt>z,r</tt> || load and toggle
|-
| <tt>las</tt>||<tt>z,r</tt> || load and set
|colspan="3"|  
|-
| <tt>ld</tt>||<tt>r,e</tt> || load indirect
| <tt>ld</tt>||<tt>r,e+</tt> || load indirect, post-increment
|-
| <tt>ld</tt>||<tt>r,-e</tt> || load indirect, pre-decrement
| <tt>ldd</tt>||<tt>r,b+I</tt> || load indirect with displacement
|-
| <tt>ldi</tt>||<tt>d,M</tt> || load immediate
| <tt>lds</tt>||<tt>r,label</tt> || load direct from SRAM
|-
| <tt>lpm</tt>||<tt>t,z</tt> || load from program memory<sup>1</sup>
| <tt>lsr</tt>||<tt>r</tt> || logical shift right
|-
| <tt>mov</tt>||<tt>r,r</tt> || move
| <tt>movw</tt>||<tt>r,r</tt> || move word
|-
| <tt>mul</tt>||<tt>r,r</tt> || multiply unsigned
| <tt>muls</tt>||<tt>d,d</tt> || multiply signed
|-
| <tt>mulsu</tt>||<tt>a,a</tt> || multiply signed/unsigned
|colspan="3"|  
|-
| <tt>neg</tt>||<tt>r</tt> || negate
| <tt>or</tt>||<tt>r,r</tt> || or
|-
| <tt>ori</tt>||<tt>d,M</tt> || or with immediate
| <tt>out</tt>||<tt>I,r</tt> || output to I/O
|-
| <tt>pop</tt>||<tt>r</tt> || pop from Stack
| <tt>push</tt>||<tt>r</tt> || push to Stack
|-
| <tt>ror</tt>||<tt>r</tt> || rotate right
|colspan="3"|  
|-
| <tt>sbc</tt>||<tt>r,r</tt> || subtract with carry
| <tt>sbci</tt>||<tt>d,M</tt> || subtract with carry immediate
|-
| <tt>sbic</tt>||<tt>I,I</tt> || skip if bit in I/O clear
| <tt>sbis</tt>||<tt>I,I</tt> || skip if bit in I/O set
|-
| <tt>sbi</tt>||<tt>I,I</tt> || set Bit in I/O
| <tt>sbiw</tt>||<tt>w,I</tt> || subtract immediate from word
|-
| <tt>sbrc</tt>||<tt>r,I</tt> || skip if bit in register clear
| <tt>sbrs</tt>||<tt>r,I</tt> || skip if bit in register set
|-
| <tt>st</tt>||<tt>e,r</tt> || store indirect
| <tt>st</tt>||<tt>e+,r</tt> || store indirect, post-increment
|-
| <tt>st</tt>||<tt>-e,r</tt> || store indirect, pre-decrement
| <tt>std</tt>||<tt>b,r</tt> || store indirect with displacement
|-
| <tt>sts</tt>||<tt>label,r</tt> || store direct
| <tt>sub</tt>||<tt>r,r</tt> || subtract
|-
| <tt>subi</tt>||<tt>d,M</tt> || subtract immediate
| <tt>swap</tt>||<tt>r</tt> || swap nibbles
|-
| <tt>xch</tt>||<tt>z,r</tt> || exchange
|colspan="3"| 
|}

<sup>1</sup> Je nach Derivat werden die folgenden <tt>lpm</tt>-Ausprägungen unterstützt oder nicht:
* <tt>lpm</tt>
* <tt>lpm r,z</tt> bzw. <tt>lpm r,z+</tt>
* <tt>elpm</tt>
* <tt>elpm r,z</tt> bzw. <tt>elpm r,z+</tt>

Hier noch ein paar der gebräuchlichsten Shorthands und deren Abbildung auf "Basis"-Instruktionen:

:{| {{Blauetabelle}}
|+'''Tabelle: Shorthands'''
|- {{Hintergrund1}}
!Shorthand || gleichbedeutend mit || Bedeutung ||rowspan="5"| 
!Shorthand || gleichbedeutend mit || Bedeutung
|-
| <tt>rol r</tt> || <tt>adc r,r</tt> || rotate left
| <tt>cbr r,M</tt> || <tt>andi r, ~M</tt> || clear bits in reg
|-
| <tt>clr r</tt> || <tt>eor r,r</tt> || clear reg to zero
| <tt>lsl r</tt> || <tt>add r,r</tt> || logical shift left
|-
| <tt>sbr d,M</tt> || <tt>ori d, M</tt> || set bits in reg
| <tt>ser d</tt> || <tt>ldi d, 0xff</tt> || set all bits in reg
|-
| <tt>tst r</tt> || <tt>and r,r</tt> || test against zero
|colspan="3"| 
|}

==Clobbers==

In der Komma-getrennten Clobber-Liste kann man angeben, welche Register durch den Inline-Assembler ihren Wert ändern. Ändern z.B. <tt>r2</tt> und <tt>r3</tt> ihre Werte, dann ist die Clobber-Liste
"r2", "r3"

Wird schreibend auf das RAM zugegriffen, dann muss man das auch mitteilen, damit RAM-Inhalte, die sich evtl. in Registern befinden, nach dem Inline-Assembler neu gelesen werden. Der Clobber dafür ist:
"memory"

'''Beispiel:'''

Es soll ein Inline-Assembler geschrieben werden, das den Inhalt zweier aufeinanderfolgender Speicherstellen austauscht. Die Adresse soll in <tt>addr</tt> stehen. Sie ist Input-Operand und muss in Register X, Y oder Z stehen, um den <tt>ld</tt> bzw. <tt>st</tt>-Befehl anwenden zu können. Die passende Constraint ist also <tt>"e"</tt>. Nach der Sequenz liegt <tt>addr</tt> unverändert vor.
<pre>
asm volatile (
"ld r2, %a0+" "\n\t"
"ld r3, %a0" "\n\t"
"st %a0, r2" "\n\t"
"st -%a0, r3"
: /* keine Output-Operanden */
: "e" (addr)
: "r2", "r3", "memory"
);
</pre>
avr-gcc entscheidet sich dazu, das Z-Register für <tt>addr</tt> zu verwenden:
<pre>
ld r2, Z+
ld r3, Z
st Z, r2
st -Z, r3
</pre>

Günstiger ist es jedoch, dem Compiler auch die Entscheidung zu überlassen, welche(s) Register als Hilfsregister verwendet werden sollen. Ein Register kann <tt>__tmp_reg__</tt> sein, für das zweite legen wir eine lokale 8-Bit-Variable <tt>hilf</tt> an:
<pre>
{
char hilf;

asm volatile (
"ld __tmp_reg__, %a1+" "\n\t"
"ld %0, %a1" "\n\t"
"st %a1, __tmp_reg__" "\n\t"
"st -%a1, %0"
: "=&r" (hilf)
: "e" (addr)
: "memory"
);
}
</pre>
<tt>__tmp_reg__</tt> (also <tt>r0</tt>) brauch nicht in die Clobber-Liste aufgenommen zu werden. Um das zweite benötigte Register (hier <tt>r24</tt>, in dem <tt>hilf</tt> lebt) kümmert sich avr-gcc und sichert es, falls nötig
<pre>
ld r0, Z+
ld r24, Z
st Z, r0
st -Z, r24
</pre>

{{FarbigerRahmen |
Falls das Register <tt>r1</tt> verändert wird – was z.B. geschieht, wenn man Multiplikationsbefehle verwendet – dann muss am Ende des Templates das Register wieder auf 0 gesetzt werden, denn bei avr-gcc enthält dieses Register immer den Wert 0.
Das Register in die Clobber-Liste aufzunehen bleibt wirkungslos. Hat man es zerstört,
dann schreibt man ans Ende des Templates ein
clr __zero_reg__
und stellt es dadurch wieder her.
}}

== asm goto mit C-Labels ==

Ab Version 4.5 kennt GCC <tt>asm goto</tt>, mit dem ausgedrückt werden kann, dass der Codefluß des Assembler-Teils u.U. zu einem Stück C-Code springt:

asm goto ([[#Assembler-Template|asm-template]] : {{comment|Leer}} : [[#Operanden und Constraints|input-operand-list]] : [[#Clobbers|clobber-list]] : [[#asm goto mit C-Labels|C-labels]]);

Die Codefluß-Analyse des Compilers muss wissen, daß die angegebenen C-Code Sequenzen verwendet werden, damit sie nicht wegoptimiert werden. Solch ein Inline-Assembler mit <tt>goto</tt> darf keine Output-Operanden haben, denn der Compiler hat keine Möglichkeit, Code für die entsprechenden Output-Reloads zu erzeugen.

;Beispiel:

extern void __attribute__((noreturn))
panic (void);

char panic_if_x (char x)
{
asm goto ("cpse %0, __zero_reg__" "\n\t"
"%~jmp %x1" "\n\t"
"%~jmp %x2"
:: "r" (x) :: proceed, do_panic);
__builtin_unreachable();

if (0)
{
do_panic:
panic();
}

if (0)
{
proceed:
x++;
}

return x;
}

Im Beispiel wird der Inline-Assembler nur über die Marken <tt>do_panic</tt> oder <tt>proceed</tt> verlassen, weshalb der Code direkt danach unerreichbar ist. Dies wird der Codefluß-Analyse per <tt>__builtin_unreachable()</tt> mitgeteilt. Es wird folgender Code erzeugt:

panic_if_x:
{{comment|#APP}}
cpse r24,__zero_reg__
rjmp .L2
rjmp .L3
{{comment|#NOAPP}}
.L3:
rcall panic
.L2:
subi r24,lo8(-(1))
ret

=Vordefinierte Bezeichner und Makros=
Je nach Assembler, für den avr-gcc Code erzeugt, gibt es unterschiedliche vordefinierte Funktionen/Makros, die von Inline-Assembler aus verwendbar sind.

== GNU-Assembler ==

:{| {{Blauetabelle}}
|+ '''Vordefinierte Makros und<br/>Relocatable Expression Modifiers'''<br/> 
|- {{Hintergrund1}}
! Bezeichner || Bedeutung
|-
|<tt>__SP_L__</tt> || unteres Byte des Stack-Pointers, für <tt>in</tt> bzw. <tt>out</tt>
|-
|<tt>__SP_H__</tt> || oberes Byte des Stack-Pointers, für <tt>in</tt> bzw. <tt>out</tt>
|-
|<tt>__SREG__</tt> || Status-Register, für <tt>in</tt> bzw. <tt>out</tt>
|-
|<tt>__tmp_reg__</tt> || ein Register zur temporären Verwendung (<tt>r0</tt>)
|-
|<tt>__zero_reg__</tt> || ein Register, das 0 enthält (<tt>r1</tt>)
|-
|<tt>lo8(''const'')</tt> || Bits 0...7 der Konstanten <tt>''const''</tt>
|-
|<tt>hi8(''const'')</tt> || Bits 8...15 der Konstanten <tt>''const''</tt>
|- valign="top"
|<tt>hlo8(''const'')</tt><br/><tt>hh8(''const'')</tt> || Bits 16...23 der Konstanten <tt>''const''</tt>
|-
|<tt>hhi8(''const'')</tt> || Bits 24...31 der Konstanten <tt>''const''</tt>
|- valign="top"
|<tt>pm(''const'')</tt> || Konstante <tt>''const''</tt> durch 2 geteilt,<br/>zur Berechnung von Word-Adressen für <tt>icall</tt> und <tt>ijmp</tt>.
|- valign="top"
|<tt>pm_lo8(''const'')</tt><br/><tt>pm_hi8(''const'')</tt><br/><tt>pm_hh8(''const'')</tt>
| Abkürzung für <tt>lo8(pm(''const''))</tt><br/>Abkürzung für <tt>hi8(pm(''const''))</tt><br/>Abkürzung für <tt>hh8(pm(''const''))</tt>
|- valign="top"
|<tt>gs(''label'')</tt> || Word-Adresse von <tt>''label''</tt>. Für Devices mit mehr als 128k Flash wird die Adresse eines Jump-Pads eingetragen. Der Linker erzeugt ein Jump-Pad, das einen direkten Sprung zu <tt>label</tt> erhält. <tt>gs(label)</tt> wird durch diese Adresse ersetzt.
|}

=Beispiele=

==nop==
Mit den bisherigen Vorkenntnissen ist zu <tt>nop</tt> nicht viel zu sagen:
asm volatile ("nop");
Oder als C-Makro:
#define nop() \
asm volatile ("nop")

<tt>nop</tt> hat weder Input- noch Output-Operanden, und Register/RAM ändern sich natürlich nicht. Bei der Makro-Definition ist lediglich darauf zu achten, daß das Makro nicht mit einem <tt>;</tt> endet, damit man den C-Code wie gewohnt mit <tt>;</tt> schreiben kann:
<pre>
if (x)
nop();
else
...
</pre>

==swap Nibbles==
Ein einfaches Beispiel für <tt>swap</tt> haben wir bereits oben kennen gelernt. Der Inline-Assembler dreht die Nibbles von <tt>foo</tt> um:
<pre>
unsigned char foo;
...
asm ("swap %0" : "+r" (foo));
</pre>

Wünschenswert wäre eher, <tt>swap</tt> wie eine normale C-Funktion verwenden zu können und hinzuschreiben:
a = swap(b);
ohne daß <tt>b</tt> seinen Wert ändert. Soll <tt>b</tt> geswappt werden, dann via
b = swap(b);
zudem soll das Argument ein Ausdruck sein können:
if (b == swap (b+1))
...

Dazu verwenden wir eine lokale Variable <tt>_x_</tt>, in die der ursprüngliche Wert <tt>x</tt> gesichert wird:
<pre>
#define swap(x) \
({ \
unsigned char _x_ = (unsigned char) x; \
asm ("swap %0" : "+r" (_x_)); \
_x_; \
})
</pre>
alternativ könnten wir eine inline-Funktion definieren:
<pre>
static inline unsigned char swap (unsigned char x)
{
asm ("swap %0" : "+r" (x));
return x;
}
</pre>

==swap Bytes==
Werden Zahlen zwischen verschiedenen Plattformen übertragen, kann es sein, daß diese unterschiedlich dargestellt werden: Das low-Byte kann in sich im unteren Byte befinden (AVR), es kann aber auch im oberen Byte sein. Ist das so, dann müssen die Werte beim Senden/Empfang umgewandelt werden, indem die Bytes getauscht werden. Liegt der 16-Bit-Wert in <tt>x_in</tt> und soll der konvertierte Wert nach <tt>x_out</tt> gespeichert werden, dann könnte man auf die Idee kommen, so etwas zu schreiben:
<pre>
asm (
"mov %A0, %B1" "\n\t"
"mov %B0, %A1"
: "=r" (x_out)
: "r" (x_in)
);
</pre>
Daraus könnte folgender Code entstehen:
<pre>
mov r24, r25
mov r25, r24
</pre>
Das ist offenbar Käse! Was ist passiert?

avr-gcc hat sich dazu entschieden, <tt>x_in</tt> in <tt>r25:r24</tt> anzulegen. Auch <tt>x_out</tt> wird in diesen Registern angelegt. Das ist erst mal in Ordnung, wenn <tt>x_in</tt> nach dem Inline nicht mehr gebraucht wird.

Allerdings wird das Inline nicht en bloc — also nicht zeitparallel — ausgeführt, sondern sequenziell. Bei ''gleichzeitiger'' Ausführung der beiden <tt>mov</tt>-Instruktionen wäre auch nichts dagegen zu sagen! Ein <tt>swap</tt>-Kommando z.B. tauscht die Nibbles ''gleichzeitig'', und der Input-Operand kann im gleichen Register leben wie der Output-Operand, wenn der Input nicht weiter verwendet wird.

Mit den beiden Bytes geht es aber nicht. Wir müssen daher kennzeichnen, daß sich <tt>x_out</tt> in einem Register befindet, das ''nur'' als Output dient, was durch das <tt>&</tt> in der Output-Constraint erreicht wird:
<pre>
asm (
"mov %A0, %B1" "\n\t"
"mov %B0, %A1"
: "=&r" (x_out)
: "r" (x_in)
);
</pre>
Damit erfolgt eine korrekte Registerzuordnung. <tt>x_out</tt> steht jetzt in <tt>r19:r18</tt> und überschneidet nich nicht mehr mit <tt>x_in</tt>:
<pre>
mov r18, r25
mov r19, r24
</pre>

Alternativ können wir wie bei [[#swap Nibbles|swap Nibbles]] eine lokale Variable verwenden, und alles als (inline-)Funktion machen.

== Zugriff auf SFRs ==
Um auf SFRs zuzugreifen, können im asm-Template keine Defines aus <tt>avr/io.h</tt> verwendet werden, weil der Präprozessor nicht mehr über den erzeugten Assembler-Code läuft (er läuft vor dem Compilieren). Um nicht die hex-Codes des SFRs angeben zu müssen, kann man dem Inline die Adressen als Konstanten übergeben. Weil die Adressen RAM-Adressen sind, müssen sie in das <tt>_SFR_IO_ADDR</tt> Makro verpackt werden, um den Offset für den I/O-Bereich abzuziehen. <tt>tcnt1</tt> wird auf den Inhalt von <tt>TCNT1</tt> gesetzt:
<pre>
#include <avr/io.h>
...
uint16_t tcnt1;

asm volatile (
"in %A0, %1" "\n\t"
"in %B0, %1+1"
: "=r" (tcnt1)
: "M" (_SFR_IO_ADDR (TCNT1))
);
</pre>
wird umgesetzt zu
<pre>
in r24, 44
in r25, 44+1
</pre>

Ab avr-gcc 4.7 kann auch der Operand-Modofier <tt>%i</tt> verwendet werden, um eine RAM-Adresse, wie sie von <tt>avr/io.h</tt> definiert werden, als I/O-Adresse auszugeben:
<pre>
uint16_t tcnt1;

asm volatile (
"in %A0, %i1" "\n\t"
"in %B0, %i1+1"
: "=r" (tcnt1)
: "n" (& TCNT1)
);
</pre>

Das nur als Beispiel. Von C aus geht das natürlich auch mit
uint16_t tcnt1 = TCNT1;

== Zugriff aufs SRAM ==
Auf bekannte globale Symbole kann man direkt von Assembler aus zugreifen:
<pre>
extern int einInt;

asm volatile (
"lds %A0, einInt" "\n\t"
"lds %B0, einInt+1"
: "=r" (...)
);
</pre>
ergibt
<pre>
lds r24, einInt
lds r25, einInt+1
</pre>
alternativ ginge
<pre>
asm volatile (
"lds %A0, %A1" "\n\t"
"lds %B0, %B1"
: "=r" (...)
: "m" (einInt)
);
</pre>

Falls die Adresse eines Objekts zur Compilezeit bekannt ist, kann man auch die Adresse von C aus übergeben:
<pre>
struct foo_t {
int a[2], b[2];
} foo;

...
{
asm volatile (
"lds %A0, %1" "\n\t"
"lds %B0, %1+1"
: "=r" (...)
: "i" (& foo.b[1])
);
}
</pre>
ergibt
<pre>
lds r24, einStruct+6
lds r25, einStruct+6+1
</pre>

Falls die Adresse zur Compilezeit nicht bekannt ist, muss sie natürlich in einem Adress- oder Basisregister übergeben werden:
<pre>
void blah (struct foo_t * pfoo)
{
asm volatile (
"ld %A0, %a1" "\n\t"
"ldd %B0, %a1+1"
: "=&r" (...)
: "b" (& pfoo->b[1])
);
}
</pre>
ergibt
<pre>
ld r24, Z
ldd r25, Z+1
</pre>
Auch hier muss der Output-Operand mit einem <tt>&</tt> gekennzeichnet werden, damit er nicht ins gleiche Register geladen wird wie die Adresse.

= Labels und Schleifen =
Für Labels in Sprüngen und Schleifen können keine festen Bezeichner verwendet werden, weil ein Label, der via Makro oder inline-Funktion in den Code eingefügt wird, nicht mehrfach vorkommen darf. Dazu kann man sich durch Einfügen von <tt>"%="</tt> Labels zusammenbauen, etwa <tt>L_a%=</tt>, <tt>L_b%=</tt>, etc. Das <tt>"%="</tt> wird durch eine für die Übersetzungseinheit und den Code-Schnippsel eindeutige Zahl ersetzt. Die obigen Sequenzen könnten also z.B. umgesetzt werden als <tt>L_a14</tt> und <tt>L_b14</tt>, wenn sie im gleichen Schnippsel stehen.

Etwas bequemer ist die Verwendung einer Ziffer als Label. Beim Sprung gibt man direkt hinter der Ziffer an, in welche Richtung das Label gesucht wird. Ist das Label <tt>''n''</tt>, dann sucht und springt
*<tt>''n''b</tt> zurück (backward)
*<tt>''n''f</tt> nach vorne (forward)

Es wird zum nächsten auffindbaren Label in der angegebenen Richtung gesprungen.

==Bits zählen==

Dieses Assembler-Schnippsel zählt die Anzahl der gesetzten Bits in einem Byte <tt>eingabe</tt>. Die Eingabe wird nach rechts ins Carry geschoben, und das Carry zum Ergebnis dazu addiert.
<pre>
static inline unsigned char count_bits (unsigned char eingabe)
{
unsigned char count;

asm (
"clr %0" "\n"
"0:" "\n\t"
"lsr %1" "\n\t"
"adc %0, __zero_reg__" "\n\t"
"tst %1" "\n\t"
"brne 0b"
: "=&r" (count), "+r" (eingabe)
);

return count;
}
</pre>
Damit kann man sich ein Parity bauen:
#define parity(x) (count_bits(x) & 1)
und hätte eine schlankere (aber etwas langsamere) Parity-Implementierung als in <tt>avr/parity.h</tt>. Ein
if (parity(foo))
...
wird in Assembler dann zu (<tt>r24 = eingabe</tt>, <tt>r25 = count</tt>):
<pre>
lds r24,foo
/* #APP */
clr r25
0:
lsr r24
adc r25, __zero_reg__
tst r24
brne 0b
/* #NOAPP */
sbrs r25,0
rjmp .L1
...
</pre>

=Fallstricke=
* Um die Sonderzeichen <tt>"%~"</tt> und <tt>"%="</tt> benutzen zu können, muss bei parameterlosen Inline Assembler dem Template ein Doppelpunkt folgen:
:<pre>asm volatile ("%~call some_function" :);</pre>
* Steht das <tt>asm</tt> an oberster Ebene — also außerhalb einer Funktion — ist weiter zu beachten:
** Jedes <tt>%</tt> wird als solches ausgegeben, und es sind keine Operanden erlaubt.
** Falls die Reihenfolge von <tt>asm</tt> und Funktionen beibehalten werden soll, muß mit <tt>-fno-toplevel-reorder</tt> compiliert werden.

=Quellen=

; Dokumentation

* AVR-LibC: [http://nongnu.org/avr-libc/user-manual/inline_asm.html ''Inline Assembler Cookbook'']
* GCC Wiki: [http://gcc.gnu.org/wiki/avr-gcc ''avr-gcc'']
* GCC: [http://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html ''Assembler Instructions with C Expression Operands'']
* GCC: [http://gcc.gnu.org/onlinedocs/gcc/Constraints.html ''Constraints for <tt>asm</tt> Operands'']
* GCC: [http://gcc.gnu.org/onlinedocs/gcc/Explicit-Reg-Vars.html ''Variables in Specified Registers'']
* GCC Internals: [http://gcc.gnu.org/onlinedocs/gccint/Constraints.html ''Operand Constraints'']

;GCC-Quellen:

* [http://gcc.gnu.org/viewcvs/trunk/gcc/config/avr/avr.md?content-type=text%2Fplain&view=co ./gcc/config/avr/avr.md]
* [http://gcc.gnu.org/viewcvs/trunk/gcc/config/avr/constraints.md?content-type=text%2Fplain&view=co ./gcc/config/avr/constraints.md]

=Siehe auch=
* [[AVR Assembler Einführung]]
* [[:Kategorie:Quellcode Assembler_AVR|Quellcode Assembler]]
* [[Sourcevergleich#GCC (Assembler einfügen)]]
* [[avr-gcc]]

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode_Assembler_AVR]]
[[Kategorie:Quellcode C]]

Avr-gcc

2014-09-13T08:58:07Z

SprinterSB: /* Dokumentation */ typo

'''avr-gcc''' ist ein freier C-[[Compiler]], mit dem C-Programme zu ausführbaren Programmen übersetzen werden können, die auf [[Microcontroller]]n der [[AVR]]-Familie lauffähig sind.
An Sprachen versteht avr-gcc sowohl C als auch [[#C%2b%2b|C++]].
Neben Standard-C bzw. ANSI-C versteht avr-gcc auch GNU-C, das etwas mehr Möglichkeiten und kleinere Spracherweiterungen bietet.

avr-gcc kann auch dazu verwendet werden, um C/C++ Programme nach Assembler zu übersetzen oder um Bibliotheken zu erstellen, die später in unterschiedlichen Projekten verwendet werden können.

Wie bei allen aus der UNIX-Welt kommenden Programmen ist das Kommando-Interface von avr-gcc die Shell bzw. die Kommandozeile, über die Optionen, Parameter, Einstellungen und die Namen der zu übersetzenden Dateien angegeben werden.

=How to Read=

Dieser Artikel bespricht avr-gcc Version 3.x. Er ist kein C-Tutorial und kein AVR-Handbuch – das würde den Umfang des Artikels bei weitem sprengen.

Der Artikel ist ein Handbuch zu avr-gcc. Er bespricht zum Beispiel, wie avr-gcc angenwendet wird und Besonderheiten von avr-gcc-C, die nicht zum Sprachumfang von C gehören.
Dazu zählen die Definition von [[#Interrupts|Interrupt]] Service Routinen ([[ISR|ISRs]])
oder wie man Daten ins [[EEPROM]] legt.

Es wird also besprochen, ''wie'' eine ISR zu definieren ist, aber nicht,
''warum'' das gegebenenfalls notwendig oder nicht notwendig ist.
''Warum'' etwas gemacht wird, ist abhängig von der gestellten Aufgabe,
etwa ''"Initialisiere den [[UART]] zur Benutzung mit 9600 Baud"''.
Dafür enthält dieser Artikel zusammen mit dem AVR-Handbuch das Rüstzeug,
bietet aber keine Lösungen für konkrete Aufgaben.

Neben diesem Artikel gibt es den Unterartikel [[avr-gcc/Interna|Interna von avr-gcc]] wo Dinge wie die Registerverwendung, Attribute, Builtins und Sections von avr-gcc dargestellt werden. Zudem findet sich dort ein Überblick über die Arbeitsweise von gcc mit den Schritten
* Precompilieren
* Compilieren
* Assemblieren
* Linken
Ein weiterer Unterartikel widmet sich dem Thema [[Inline-Assembler in avr-gcc]].

In den [[:Kategorie:Quellcode C|C-Codebeispielen]]
befindet sich das ausführlichere Beispiel "[[Hallo Welt für AVR (LED blinken)]]",
das nur eine [[Diode#Lumineszenzdiode|LED]] blinkt und zeigt,
wie ein kleines Projekt mit avr-gcc compiliert werden kann.

Es gibt ein [[C-Tutorial]], das jedoch noch unvollständig und teilweise feherhaft ist (Stand 02/2006). Darüber hinaus gibt es ein [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial C-Tutorial bei www.mikrocontroller.net].

=Benutzer-Schnittstelle=

Die Benutzer-Schnittstelle von avr-gcc ist – wie für alle Programme, die aus der UNIX-Welt kommen – die Kommandozeile einer Shell, Console bzw. Eingabeaufforderung.

Im einfachsten Fall sieht ein Aufruf von avr-gcc also so aus:
> avr-gcc
Dabei das '<tt>></tt>' nicht mittippen, und ein ENTER am Ende der Zeile drücken.
Die Antwort bei korrekter Installation ist dann
avr-gcc: no input files
Was bedeutet: das Programm avr-gcc wurde vom Betriebssystem gefunden und konnte/durfte gestartet werden. Dann gibt avr-gcc eine Fehlermeldung aus und beendet die Ausführung, weil er keine Eingabedatei(en) bekommen hat  was ja auch stimmt. Soweit ist also alles in Butter.

Um eine C-Datei <tt>foo.c</tt> mir avr-gcc optimiert zu einem lauffähigen elf-Programm <tt>foo.elf</tt> für einen [[ATmega32]] zu compileren, würde man angeben
> avr-gcc -Os -mmcu=atmega32 foo.c -o foo.elf
Hat man seine Quellen auf zwei oder mehre Dateien verteilt, geht es analog:
> avr-gcc -Os -mmcu=atmega32 foo.c foo2.c -o foo.elf

Will man nur eine Objekt-Datei erstellen (nur compilieren, nicht linken), dann geht das wie folgt. Das kann günstig sein bei grösseren Projekten, wenn man das Projekt neu erzeugen will, aber nur in einer Quelldatei was geändert hat. Oder wenn das Objekt in einer Bibliothek landen soll.
> avr-gcc -Os -c -mmcu=atmega32 foo.c -o foo.o

Die ausführbare Gesamtdatei <tt>foo_all.elf</tt> erhält man dann, indem alle Objekte zusammenlinkt:
> avr-gcc -mmcu=atmega32 foo.o foo2.o foo3.o -o foo_all.elf

Um die ausführbare Datei in das oft verwendete Intex-HEX-Format umzuwandeln (einmal fürs Programm, einmal für ein Abbild des [[EEPROM]]s) gibt man an:
> avr-objcopy -O ihex -j .text -j .data foo_all.elf foo_all.hex
> avr-objcopy -O ihex -j .eeprom --change-section-lma .eeprom=1 foo_all.elf foo_all_eeprom.hex

----

[[GCC]] war immer Kommandozeilen-orientiert und wird es auch immer bleiben, denn das hat gute Gründe:
* ein Compiler ist ein Compiler (und keine grafische Bedienschnittstelle)
* die Plattformabhängigkeit wird auf ein Minimum reduziert
* es gibt die Möglichkeit, avr-gcc per Skript oder [[make]] zu starten
* avr-gcc kann durchaus in eine Umgebung integriert werden: in einen Editor oder in eine GUI wie neuere Versionen von AVR-Studio erfolgreich beweisen, etc. Der avr-gcc-Aufruf kann sogar von einem Server-Socket oder einer Web-Application heraus erfolgen, welche ein C-Programm empfängt, es von avr-gcc übersetzen lässt, und das Resultat zurückschickt oder sonst was damit anstellt.
* Lizenzgründe: eine Umgebung, die avr-gcc integriert, kann durchaus proprietär oder nicht quelloffen sein und muss nicht der [[Freie Software|GPL]] unterliegen. Wieder ist AVR-Studio ein Beispiel.

= Unterstützte AVR-Derivate=

:→ ''[http://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html GCC Manual: AVR Options]

Diese Liste der unterstützten Devices kann man anzeigen lassen mit
> avr-gcc --target-help
bzw. ab Version 4.7 mit
> avr-gcc --help=target

Siehe auch "AVR Options" in der GCC [[#Dokumentation|Dokumentation]].

=Kommandozeilen-Optionen=
Die Codegenerierung bei avr-gcc wird über Kommandozeilen-Optionen gesteuert. Diese legen fest, für welchen Controller Code zu erzeugen ist, wie stark optimiert wird, ob Debug-Informationen erzeugt werden, etc. Die Optionen teilen sich in zwei Gruppen: Optionen, die für alle GCC-Ports verfürgbar sind und maschinenspezifische Optionen, die nur für AVR verfügbar sind.

Aus der Masse an GCC-Optionen kann hier nur ein kleiner Auszug der wichtigsten und am häufigsten verwendeten Optionen vorgestellt werden. Eine Auflistung aller GCC-Optionen mit Kurzbeschreibung umfasst knapp 1000 Zeilen  ohne undokumentierte Optionen, versteht sich.

==Allgemeine Optionen für GCC==
; <tt>--help</tt>: Anzeige der wichtigsten Optionen
; <tt>--help -v</tt>: Überschüttet einen mit Optionen
; <tt>--target-help<br/>--help=target</tt>: Anzeige der wichtigsten maschinenspezifischen Optionen und der unterstützten AVR-Derivate
; <tt>-O0</tt>: keine Optimierung - sinnvoll zum debuggen
; <tt>-O1</tt>: Optimierung
; <tt>-Os</tt>: optimiert für Code-Größe – meist beste Wahl für µCs
; <tt>-O2</tt>: stärkere Optimierung für bessere Laufzeit
; <tt>-g</tt>: erzeugt Debug-Informationen
; <tt>-gdwarf-3 -gstrict-dwarf</tt>: erzeugt Debug-Informationen nachdem DWARF-3 Standard und ohne GNU-spezifische Erweiterungen.
; <tt>-c</tt>: (pre)compilert und assembliert nur bis zum Objekt (<tt>*.o</tt>), kein Link-Lauf
; <tt>-S</tt>: (pre)compilert nur und erzeugt Assembler-Ausgabe (<tt>*.s</tt>)
; <tt>-E</tt>: nur Precompilat (<tt>*.i</tt> bzw. <tt>*.ii</tt>) erzeugen, kein Compilieren, kein Assemblieren, kein Linken
; <tt>-o <filename></tt>: legt den Name der Ausgabedatei fest
; <tt>-v</tt>: zeigt Versionsinformationen an und ist geschwätzig (verbose): Anzeige der aufgerufenen tools
; <tt>-I<path></tt>: Angabe eines weiteren Include-Pfads, in dem Dateien mit <tt>#include <...></tt> gesucht werden
; <tt>-E -dM <filename></tt>: Anzeige aller Defines
; <tt>-MM</tt>: Für die angegebenen Eingabe-Dateien wird eine Ausgabe erzeugt, die als [[make|Makefile]]-Fragment dienen kann und die Anhängigkeiten (dependencies) der Objekte von den Quellen/Headern beschreibt.
; <tt>-D<name></tt>: Definiert Makro <tt><name></tt>
; <tt>-D<name>=<wert></tt>: Definiert Makro <tt><name></tt> zu <tt><wert></tt>
; <tt>-U<name></tt>: Undefiniert Makro <tt><name></tt>
; <tt>-save-temps</tt>: Temporäre Dateien (<tt>*.i</tt>, <tt>*.s</tt>) werden nicht gelöscht.
; <tt>-Wa,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Assembler (<tt>avr-as</tt>)
:;<tt>-Wa,-a=<filename></tt>: Assembler erzeugt ein Listing mit Name <tt><filename></tt>
; <tt>-Wp,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Preprozessor
; <tt>-Wl,<options></tt>: übergibt Komma-getrennte Liste <tt><options></tt> an den Linker (<tt>avr-ld</tt>)
:;<tt>-Wl,-Map=<filename></tt>: Linker erzeugt ein Map-File mit Name <tt><filename></tt>
:;<tt>-Wl,--section-start=<section>=<address></tt>: Linker legt die [[avr-gcc/Interna#Sections|Section]] <tt><section></tt> ab Adresse <tt><address></tt>, z.B: <tt>.eeprom=0x810001</tt>
; <tt>-Wall</tt>: gibt mehr Warnungen, aber immer noch nicht alle
; <tt>-std=gnu99</tt>: Sagt dem Compiler, dass er C99 mit GNU-C Erweiterungen akzeptieren soll. Das ist zum Beispiel der Fall, wenn man Embedded-C Code mit <tt>__flash</tt> verwenden will.
; <tt>-std=c89<br/>-ansi</tt>: bricht mit einer Fehlermeldung ab, wenn kein ANSI-C (ISO C89) verwendet wurde
; <tt>-std=c99</tt>: C99 mit einigen Erweiterungen, die nicht dem C99-Standard widersprechen
; <tt>-std=c99 -pedantic</tt>: Bricht mit einer Fehlermeldung ab, wenn kein ISO C99 verwendet wird

==Maschinenspezifische Optionen für avr-gcc==

Maschinenabhängige Optionen beginnen immer mit '''-m'''
;-mmcu=xxx: Festlegen des Targets (Zielsystem/Controller), für das Code generiert werden soll. Je nach Target muss avr-gcc unterschiedliche Instruktionen verwenden und andere Startup-Dateien (<tt>crtxxx.o</tt>) einbinden. avr-gcc setzt spezielle Defines, um auch in der Quelle zwischen den Targets unterscheiden zu können, falls das notwendig sein sollte:
:{| border="0" cellpadding="0" cellspacing="0"
|
<pre>
#ifdef __AVR_AT90S2313__
/* Code fuer AT90S2313 */
#elif defined (__AVR_ATmega8__) || defined (__AVR_ATmega32__)
/* Code fuer Mega8 und Mega32 */
#else
#error Das ist noch nicht implementiert für diesen Controller!
#endif
</pre>
|}

: Zwar gibt es für alle AVR-Derivate die <tt>avr/io.h</tt>, aber die AVR-Familien unterscheiden sich in ihrer Hardware; z.B. darin, wie I/O-Register heissen oder wie Hardware zu initialisieren ist. Diese Abhängigkeit kann man in unterschiedlichen Codestücken aufteilen und wie oben gezeigt bedingt übersetzen. Dadurch hat man Funktionalitäten wie <tt>uart_init</tt> auf unterschiedlichen Controllern und wahrt den Überblick, weil nicht für jede Controller-Familie eine extra Datei notwendig ist.

: Built-in Makros wie <tt>__AVR_ATmega8__</tt> und <tt>__AVR_ARCH__</tt> sind ab Version 4.7 im Kapitel "AVR Options" in der GCC [[#Dokumentation|Dokumentation]] erklärt, siehe z.B. [http://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html "AVR Built-in Macros"].

; -mint8: Datentyp <tt>int</tt> ist nur 8 Bit breit anstatt 16 Bit. Datentypen mit 64 Bit sind nicht verfügbar. 8-Bit <tt>int</tt> ist nicht C-Standard konform und wird nicht von der AVR Libc unterstützt (ausser in <tt>stdint.h</tt>).
; -mno-interrupts: Ändert den Stackpointer ohne Interrupts zu deaktivieren
; -mcall-prologues: Funktions-Prolog und -Epilog werden als Unterroutinen umgesetzt, um die Codegröße zu verkleinern
; -mtiny-stack: Nur die unteren 8 Bit des Stackpointers werden verändert

=C++=

:''"C++ is a complex language and an evolving one, and its standard definition (the ISO C++ standard) was only recently completed. As a result, your C++ compiler may occasionally surprise you, even when its behavior is correct."''

Zudem sollte der Einsatz von C++ aus Effizienzgründen sehr kritisch betrachtet werden:
:''"When programming C++ in space- and runtime-sensitive environments like microcontrollers, extra care should be taken to avoid unwanted side effects of the C++ calling conventions like implied copy constructors that could be called upon function invocation etc. These things could easily add up into a considerable amount of time and program memory wasted. Thus, casual inspection of the generated assembler code (using the <tt>-S</tt> compiler option) seems to be warranted."''

Weiterhin unterliegt der Einsatz von C++ je nach Compiler/Lib-Version bestimmten Einschränkungen:
*Einer kompletten C++ Implementierung fehlt die Unterstützung durch die <tt>libstdc++</tt>, dadurch fehlen Standardfunktionen, -Klassen und -Templates
* Die Operatoren <tt>new</tt> und <tt>delete</tt> sind nicht implementiert, ihre Verwendung führt zu unauflösbaren externen Referenzen (Linker-Fehler)
*Nicht alle Header sind C++-sicher und müssen in <tt>extern "C" {...}</tt> eingeschlossen werden.
*Exceptions werden nicht unterstützt und müssen via <tt>-fno-exceptions</tt> abgeschaltet werden, oder der Linker beschwert sich über eine unauflösbare externe Referenz zu <tt>__gxx_personality_sj0</tt>.

Als Treiber verwendet man wie immer avr-gcc. Standard-Endungen für C++ sind <tt>.c++</tt> und <tt>.cpp</tt>. Bei anderen Endungen teilt man mit <tt>-x c++</tt> mit, daß es sich um C++ Dateien handelt, oder ruft <tt>avr-c++</tt> direkt auf.

Interrupt-Service-Routinen (ISRs) sind C-Funktionen und werden definiert wie gehabt. Siehe auch [[#Interrupts|Interrupts]].
#include <avr/io.h>
#include <avr/interrupt.h>

#if defined (__cplusplus)
extern "C" {
#endif {{comment|__cplusplus}}

SIGNAL (SIG_NAME)
{
{{comment|machwas}}
}

INTERRUPT (SIG_NAME)
{
{{comment|mach was}}
}

#if defined (__cplusplus)
}
#endif {{comment|__cplusplus}}
<tt>__cplusplus</tt> ist ein Standard [[avr-gcc/Interna#Builtin Defines|GCC-Builtin-Define]].

Globale Konstruktoren werden in [[avr-gcc/Interna#Sections|Section]] <tt>.init6</tt> ausgeführt, die Destruktoren in <tt>.fini6</tt>.

=Code-Beispiele=
Dieser Abschnitt enthält Code-Schnippsel für avr-gcc. Es werden Besonderheiten besprochen, die für avr-gcc zu beachten sind.

Dieser Abschnitt ist ''kein'' [[C-Tutorial|Tutorial zur C-Programmierung]] und ''keine'' Einführung in die Programmiersprache C im allgemeinen. Dafür sei auf einschlägige Tutorials/Bücher verwiesen.

==Zugriff auf Special Function Registers (SFRs)==

===Zugiff auf Bytes und Worte===
Für den Zugriff auf die SFRs gibt es Defines über den Include
#include <avr/io.h>
Abhängig vom eingestellten Controller werden dann Defines eingebunden, über die auf SFRs wie auf normale Variablen zugegriffen werden kann. Die Namen der Defines sind i.d.R. die gleichen wie im AVR-Manual, also z.b. <tt>SREG</tt> für das Prozessorstatus-Register SREG:
#include <avr/io.h>

...
{{ccomment|SREG lesen}}
uint8_t sreg = SREG;
...
{{ccomment|SREG schreiben}}
SREG = sreg;

Für einen Überblick über die eingebundenen Defines kann ein Blick in den Controller-spezifischen Header hilfreich sein. Dieser befindet sich in
:<tt> <GCC_HOME>/avr/include/avr/io****.h</tt>
z.B. <tt>iom32.h</tt> für einen [[ATmega32]].

Dieser Zugriff geht auch für 16-Bit Register wie <tt>TCNT1</tt> oder <tt>ADC</tt>, für die eine bestimmte Reihenfolge für den Zugriff auf Low- und High-Teil eingehalten werden muss: avr-gcc generiert die Zugriffe in der richtigen Reihenfolge.
uint16_t tcnt1 = TCNT1;

{{FarbigerRahmen|
Zu beachten ist, daß dieser Zugriff nicht atomar erfolgt. Das Lesen/Schreiben mehrbytiger Werte muss vom Compiler in mehrere Byte-Zugriffe zerlegt werden. Zwischen diesen Zugriffen kann ein [[Interrupt]] auftreten, wenn Interrupts aktiviert sind. Je nach Programm und welche Aufgaben eine [[ISR]] erledigt, kann dies zu Fehlfunktion führen. In dem Fall müssen diese Code-Stücke atomar gemacht werden, damit sie nicht durch einen [[IRQ]] unterbrochen werden können!
}}

===Zugriff auf einzelne Bits===
Zugriff auf Bits geht wie gewohnt mit den Bitoperationen
<tt>&</tt> (and),
<tt>|</tt> (or),
<tt>^</tt> (xor) und
<tt>~</tt> (not)

Wieder gibt es Defines in den AVR-Headern, mit denen man Masken für den Zugriff erhalten kann, etwa:
<pre>
/* GIMSK / GICR */
#define INT1 7
#define INT0 6
#define IVSEL 1
#define IVCE 0
</pre>

Masken ergeben sich durch Schieben von <tt>1</tt> an die richtige Position:
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0) | (1<<PB1);
</pre>
erzeugt
<pre>
87 b3 in r24, 0x17
83 60 ori r24, 0x03
87 bb out 0x17, r24
</pre>

Etwas anders sieht der Code aus, wenn die Bits einzeln gesetzt werden und das Register im bitadressierbaren Bereich liegt (SRAM <tt>0x20</tt> bis <tt>0x3f</tt> resp. I/O <tt>0x0</tt> bis <tt>0x1f</tt>):
<pre>
// Ports B_0 und B_1 als Ausgang
DDRB |= (1<<PB0);
DDRB |= (1<<PB1);
</pre>
erzeugt
<pre>
b8 9a sbi 0x17, 0
b9 9a sbi 0x17, 1
</pre>

Um Bits zu löschen, erzeugt man eine Maske, die an der betreffenden Stelle eine  0 hat:
<pre>
// Ports B_2 als Eingang
DDRB &= ~(1<<PB2);
</pre>

{{FarbigerRahmen|
Auch hier ist zu beachten, daß es Probleme geben kann, wenn nicht atomarer Code erzeugt wird, weil der AVR-Befehlssatz nicht mehr hergibt:
<pre>
// toggle PORT B_0: wechseln 0 <--> 1
PORTB ^= (1<<PB0);
</pre>
ergibt
<pre>
88 b3 in r24, 0x18
; Wenn hier ein Interrupt auftritt, in dessen ISR PORTB verändert wird,
; dann wird die Änderung durch die letzte Instruktion wieder überschrieben!
91 e0 ldi r25, 0x01
; dito
89 27 eor r24, r25
; dito
88 bb out 0x18, r24
</pre>
}} 

Auch das Lesen einzelner Port-Pins geht über das Maskieren von SFRs:
<pre>
DDRB &= ~(1 << PB2); // PortB.2 als INPUT

if (PINB & (1 << PB2))
// PortB.2 ist HIGH
else
// PortB.2 ist LOW

if (!(PINB & (1 << PB2)))
// PortB.2 ist LOW
else
// PortB.2 ist HIGH
</pre>

==Interrupts==

: → ''[http://nongnu.org/avr-libc/user-manual/group__avr__interrupts.html AVR-Libc: Dokumentation zu <tt><avr/interrupt.h></tt>].

Um zu kennzeichnen, daß es sich bei einer Funktion um eine Interrupt Sevice Routine (ISR) handelt, gibt es spezielle Attribute. Diese brauchen nicht explizit hingeschrieben zu werden, ebensowenig wie die genaue Nummer des Interrupt Requests (IRQ). Dafür gibt es Includes aus der AVR Libc und die folgenden Makros.

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

{{ccomment|Eine nichtunterbrechbare Interrupt-Service-Routine}}
ISR (TIMER1_COMPA_vect)
{
{{ccomment|ISR-Code}}
}

{{ccomment|Eine unterbrechbare Interrupt-Service-Routine}}
ISR (TIMER0_OVF_vect, ISR_NOBLOCK)
{
{{ccomment|ISR-Code}}
}

Dadurch wird die Funktion mit dem richtigen Prolog/Epilog erzeugt, und es wird ein Eintrag in die Interrupt-Vektortabelle gemacht – bei obigem Beispiel also zwei Einträge.

Mit Ausführung einer ISR deaktiviert die AVR-Hardware die Interrupts, so daß die ISR nicht durch andere Interrupt-Anforderungen unterbrochen wird. Beim Verlassen der ISR werden Interrupts wieder automatisch durch die AVR-Hardware aktiviert. Tritt während der ISR ein IRQ auf, wird diese erst nach Beenden des ISR-Codes ausgeführt. Der Interrupt geht also nicht verloren. Dies gilt allerding nicht für Level-getriggerte IRQs wie für manche externen Interrupts oder TWI-Interrupts.

Zwischen zwei ISRs wird zusätzlich mindestens ein Befehl des normalen Programm-Codes abgearbeitet.

Nachschlagen kann man die ISR-Namen im Device-spezifischen Header, die im Installationsverzeichnis liegen:
:<tt><GCC_HOME>/avr/include/avr/ioxxxx.h</tt>

===Interrupts aktivieren===

Damit eine ISR überhaupt zur Ausführung kommt, müssen drei Bedingungen erfüllt sein
* Interrupts müssen global aktiviert sein
* Der entsprechen IRQ muss aktiviert worden sein
* Das zum IRQ gehörende Ereignis muss eintreten
#include <avr/io.h>
#include <avr/interrupt.h>

...
{{ccomment|enable OutputCompareA Interrupt für Timer1}}
TIMSK |= (1 << OCIE1A);

{{ccomment|disable OutputCompareA Interrupt für Timer1}}
TIMSK &= ~(1 << OCIE1A);

{{ccomment|Interrupts aktivieren}}
sei();

{{ccomment|Interrupts abschalten}}
cli();
Sperrt man eine Code-Sequenz durch Einschachteln in ein <tt>cli</tt>/<tt>sei</tt> Paar (man macht das Codestück "atomar", also ununterbrechbar), gehen währenddessen keine Interrupt-Anforderungen verloren. Die entsprechenden IRQ-Flags bleiben gesetzt, und nach dem <tt>sei</tt> werden die IRQs in der Reihenfolge ihrer Prioritäten abgearbeitet. Ausnahme ist, wenn in einem atomaren Block der selbe IRQ mehrfach auftritt. Der ISR-Code wird dann trotzdem nur einmal ausgeführt.

===default Interrupt===

Für nicht implementierte Interrupts macht avr-gcc in die Vektortabelle einen Eintrag,
der zu <tt>__bad_interrupt</tt> (definiert im Startup-Code <tt>crt*.o</tt>) springt
und von dort aus weiter zu Adresse 0.
Dadurch läuft der AVR wieder von neuem los, wenn ein Interrupt auftritt,
zu dem man keine ISR definiert hat
 allerdings ohne die Hardware zurückzusetzen wie bei einem echten Reset.

Möchte man diesen Fall abfangen, dann geht das über eine globale Funktion
namens <tt>__vector_default</tt>:
<pre>
#include <avr/interrupt.h>

ISR (__vector_default)
...
</pre>
Damit wird von <tt>__bad_interrupt</tt> aus nicht nach Adresse 0 gesprungen,
sondern weiter zu <tt>__vector_default</tt>, welches durch <tt>ISR()</tt> den üblichen ISR-Prolog/Epilog bekommt.

So kann man z.B. eine Meldung ausgeben, eine Warnlampe blinken, in einer Endlosschleife landen, oder über den [[Watchdog]] einen richtigen Hardware-Reset auslösen, siehe auch Abschnitt "[[#Reset auslösen|Reset auslösen]]".

===ISR mit eigenem Prolog/Epilog===

Wenn man in einer ISR komplett eigenes Zeug machen will,
dann definiert man eine naked Funktion.
Mit <tt>naked</tt> befreit man die Routine vom Standard-Prolog/Epilog.
{{FarbigerRahmen|
Dabei ist darauf zu achten, daß die ISR mit <tt>reti</tt> (return from interrupt)
zurückkehrt und evtl. verwendete Register und den Status (<tt>SREG</tt>) sichert.
}}
#include <avr/io.h>
#include <avr/interrupt.h>

ISR (TIMER0_OVF_vect, ISR_NAKED)
{
{{ccomment|Port B.6 = 0}}
{{ccomment|Diese Instruktion verändert nicht das SREG und kein anderes Register}}
{{ccomment|so daß der eigentliche Code nur 1 Befehl lang ist}}
__asm__ __volatile (
"cbi %0, %1" "\n\t"
"reti"
:
: "M" (_SFR_IO_ADDR (PORTB)), "i" (6)
);
}

Siehe auch [[Inline-Assembler in avr-gcc]].
Die ISR sieht dann so aus:
<pre>
__vector_9:
c6 98 cbi 0x18, 6
18 95 reti
</pre>

Wiederum kann man als Funktionsname <tt>__vector_default</tt> nehmen,
um nicht-implementierte IRQs abzufangen:
<pre>
void __attribute__ ((naked))
__vector_default (void)
...
</pre>

==SRAM, Flash, EEPROM: Datenablage am Beispiel Strings==
Die Programmiersprache C kennt selber keine Strings; das einzige, was C bekannt ist, ist der Datentyp <tt>char</tt>, der ein einzelnes Zeichen repräsentiert.
===Darstellung in C===
Ein String im Sinne von C ist ein Array von Charactern bzw. ein Zeiger auf den Anfang des Arrays. Die einzelnen Zeichen folgen im Speicher direkt aufeinander und werden in aufsteigenden Adressen gespeichert. Am String-Ende folgt als Abschluss der Character <tt>'\0'</tt>, um das Ende zu kennzeichnen. Dies ist besonders bei der Berechnung des Speicherplatzes für Strings zu berücksichtigen, denn für die 0 muss auch Platz reserviert werden.

===Bestimmen der Stringlänge===
<pre>
/* Bestimmt die Laenge des Strings ohne die abschliessende '\0' zu zaehlen */
unsigned int strlength (const char *str)
{
unsigned int len = 0;

while (*str++)
len++;

return len;
}
</pre>

Die Stringlänge kann auch mit der Standard-Funktion <tt>strlen</tt> bestimmt werden, deren Prototyp sich in <tt>string.h</tt> befindet:
<pre>
#include <string.h>
size_t strlen (const char*);
</pre>

===String im Flash belassen===
Oftmals werden Strings nur zu Ausgabezwecken verwendet und nicht verändert. Verwendet man Sequenzen der Gestalt
<pre>
char *str1 = "Hallo Welt!";
char str2[] = "Hallo Welt!";
</pre>
dann werden die Strings im SRAM abgelegt. Im Startup-Code werden die Strings vom Flash ins SRAM kopiert und belegen daher sowohl Platz im SRAM als auch im Flash. Wird ein String nicht verändert, braucht er nicht ins SRAM kopiert zu werden. Das spart Platz im knapp bemessenen SRAM. Allerdings muss anders auf den String zugegriffen werden, denn wegen der Harvard-Architektur des AVR-Kerns kann avr-gcc anhand der Adresse nicht unterscheiden, ob diese ins SRAM, ins Flash oder ins EEPROM zeigt.
<pre>
#include <avr/pgmspace.h>

const char str3[] PROGMEM = "Hallo Welt!";

size_t strlen_P (const char *str)
{
size_t len = 0;

while (1)
{
char c = (char) pgm_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}

void foo (void)
{
size_t len;
len = strlen_P (str3);
len = strlen_P (PSTR ("String im Flash"));
}
</pre>

===String ins EEPROM legen===
Dies geht nach dem gleichen Muster, nach dem Strings ins Flash gelegt werden. Der Zugriff wird vergleichsweise langsam, denn der EEPROM ist langsamer als SRAM bzw. Flash.
<pre>
#include <avr/eeprom.h>

const char str4[] EEMEM = "Hallo Welt!";

size_t strlen_EE (const char *str)
{
size_t len = 0;

while (1)
{
char c = (char) eeprom_read_byte (str);
if ('\0' == c)
return len;
len++;
str++;
}
}
</pre>

==Reset auslösen==

Falls ein Reset per Software ausgelöst werden soll, dann geht das am besten über den [[Watchdog]].
Einfach nur an den Reset-Punkt an Adresse 0 zu springen
initialisiert zwar den Controller von neuem, aber es macht keinen wirkliches RESET mit Zurücksetzen der Hardware und allen I/O-Registern.

Durch den Watchdog kann man ein 'richtiges' RESET-Signal erzeugen lassen, so daß die AVR-Hardware genau so initialisiert ist, wie nach einem externen RESET. So kann man z.B. via [[UART]] ein RESET-Kommando schicken. Allerdings lässt sich der Watchdog nur minimal auf 15ms einstellen:

#include <avr/wdt.h>
#include <avr/interrupt.h>
...
cli(); {{ccomment|Interrupts global abschalten}}
wdt_enable (WDTO_15MS); {{ccomment|Watchdog aufziehen auf 15ms}}
while (1); {{ccomment|warten, bis er zubeisst...}}

Welches Ereignis einen RESET ausgelöst hat, kann man im Register '''MCUCSR''' (''MCU Control and Status Register'') erfahren. Es gibt 4 mögliche RESET-Quellen:
* Power-On Reset
* External Reset
* Brown-Out Reset
* Watchdog Reset

Soll der Inhalt von Variablen einen Reset überleben – eine Variable also nicht initialisiert werden – dann geht das so:
#include <avr/io.h>

{{ccomment| status informiert z.B. darüber, ob wir selber den Watchdog ausgelöst haben }}
{{ccomment| oder nicht, oder andere Informationen }}
uint8_t status __attribute__ ((__section__ (".noinit")));

int main (void)
{
{{ccomment|Wert von MCUSCR merken, möglichst früh im Programm }}
uint8_t mcucsr = MCUCSR;

{{ccomment|MCUCSR zurücksetzen }}
MCUCSR = 0;

{{ccomment|Watchdog-Reset }}
if (mcuscr & (1 << WDRF))
{
{{ccomment|status auswerten }}
}

{{ccomment|Power-On Reset: status auf definierten Wert setzen }}
if (mcuscr & (1 << PORF))
{
status = 0;
}

{{ccomment|status auswerten }}
...
}

; An Adresse 0 springen

Falls wirklich zu Adresse 0 gesprungen werden soll – was in einem Bootloader erforderlich sein kann – dann geschieht das mittels einer Funktion <tt>reset</tt> wie folgt:
extern void reset (void) __attribute__((noreturn));
reset();
<tt>reset</tt> wird bein Linken mittels <tt>-Wl,--defsym=reset=0</tt> auf 0 gesetzt.
Weitere Möglichkeit ist, im erzeugten Assembler <tt>0</tt> als Funktionsnamen zu verwenden:
extern void reset (void) __asm__("0") __attribute__((__noreturn__));
reset();

=Includes=

Die mit
#include <...>
angegebenen Includes werden von avr-gcc in den
mit der Option '<tt>-I</tt>' anegegenen Pfaden gesucht.
Dem Compiler bekannt sind die Pfade
<GCC_HOME>/avr/include Standard (stdio.h, ...)
<GCC_HOME>/avr/include/avr AVR-spezifisch (avr/io.h, ...)
<GCC_HOME>/lib/gcc/avr/<GCC_VERSION>/include Standard, compilerabh. (limits.h, ...)

Gibt man z.B. an
#include <stdio.h>
dann wird automatisch in diesem Verzeichnis nach <tt>stdio.h</tt> gesucht.
In den Verzeichnissen stehen Standard-Includes, die benötigt werden, wenn man libc-Funktionen
oder mathematische Funktionen etc. verwendet.
AVR-spezifische Dinge stehen im Unterverzeichnis <tt>avr</tt>, etwa:
#include <avr/io.h>
{{FarbigerRahmen|
Als Pfad-Separator wird immer ein '''<tt>/</tt>''' verwendet, auch auf Windows-Betriebssystemen! Also kein '''<tt>\</tt>''' !
}}

==Standard==

ctype.h Zeichen-Umwandlungs-Makros und ctype Makros
errno.h Symbolische Namen für Fehlercodes
stdint, inttypes.h C99 definiert [u]intN_t wenn man genau N [un]signed
Bits braucht
math.h Mathematische Funktionen: sin, cos, log, gamma, bessel, ...
setjmp.h libc unterstützt setjmp() und longjmp(), um direkt in eine
andere (nicht-lokale) Funktion zu springen.
stdio.h Standard I/O-Funktionen (printf, fscanf, ...)
stdlib.h Deklariert grundlegende ISO C Makros und Funktionen
sowie einige AVR-spezifische Erweiterungen
string.h Stringoperationen auf NULL-terminierten Strings. (strlen, ...)
stdarg.h Funktionen mit variabler Argumenanzahl
limits.h Min- und Max-Werte von Skalaren (UCHAR_MAX, LONG_MIN, ...)

==AVR-spezifisch==

Die AVR-spezifischen Includes finden sich wie gesagt im Unterverzeichnis <tt>avr</tt>.
Die meisten dort befindlichen Header wird man nie direkt durch Angabe im C-File erhalten,
sondern durch Angabe von
#include <avr/io.h>
Dadurch werden genau die I/O-Header eingebunden, die zum AVR-Modell passen, also z.B. <tt>avr/iom8.h</tt> für [[ATmega8]] etc. Verantwortlich für die Auswahl des richtigen Sub-Headers ist der Schalter '<tt>-mmcu=xxx</tt>'.

Obwohl diese Sub-Header nicht explizit angegeben werden müssen,
kann ein Blick dorthin hilfreich sein, um die Namen von [[SFR|SFRs]]
oder Signals nachzuschlagen.
Diese Header werden im folgenden nicht alle einzeln aufgelistet.
Ihre Namen sind immer <tt>avr/io*.h</tt>.
* für ATmega: <tt>avr/iom*.h</tt>
* für ATtiny: <tt>avr/iotn*.h</tt>
<pre>
avr/boot.h Bootloader Support
avr/eeprom.h EEPROM-Routinen
avr/interrupt.h sei(), cli(), ISR(), ...
avr/io.h RAMEND, ***_vect, SFRs: PORTB, DDRB, PINB, SREG, ...,
avr/pgmspace.h Zugriff aufs Flash: Byte lesen, PROGMEM, pgm_read_***, ...
avr/sleep.h Power-Safe und Sleep-Modes
avr/wdt.h Watchdog

util/crc16.h Prüfsumme CRC16
util/delay.h Verzögerungsschleifen für kurze, exakte Verzögerungen
util/parity.h Parität
util/twi.h I2C
</pre>

==Anwendungs-spezifisch==
Eigene Header, die nur innerhalb eigener Projekte gebraucht werden, includet man mit
#include "..."
Auch hier darf man Unterverzeichnisse angeben oder ins übergeordnete Verzeichnis:
#include "../../mein-zeug.h"
Mit der Option <tt>-I<path></tt> kann ein Pfad zu den bekannten Include-Pfaden hinzugefügt werden; im obigen Beispiel etwa <tt>-I../..</tt> und im Programm dann:
#include "mein-zeug.h"

= Optimierungen, Tipps & Tricks =
:→ ''Hauptartikel: [[avr-gcc/Optimierungen|avr-gcc Optimierungen]]''

=Abkürzungen und Bezeichnungen=
; [[GCC]]: GNU Compiler Collection
; gcc: GNU C-Compiler
; GPR: '''G'''eneral '''P'''urpose '''R'''egister
; [[ISR]]: [[Interrupt|'''I'''nterrupt]] '''S'''ervice '''R'''outine
; [[IRQ]]: '''I'''nterrupt '''R'''e'''q'''uest
; Prolog/Epilog: Code am Anfang/Ende jeder Funktionen/ISR, der dazu dient, verwendete Register zu sichern, den Stack-Frame für lokale [[Variable|Variablen]] anzulegen (falls benötigt), Stackpointer zu setzen, zurück zu springen (<tt>ret</tt>, <tt>reti</tt>), etc.
; SFR: '''S'''pecial '''F'''unction '''R'''egister
; Target: Zielsystem, in unserem Falle avr

=Siehe auch=
* [[C-Tutorial]]
'''Code-Beispiele'''
* [[Hallo Welt für AVR (LED blinken)]] - ein erstes Beispiel für avr-gcc
*[[:Kategorie:Quellcode_C|C-Codebeispiele]]
* [[Fallstricke bei der C-Programmierung]]

'''Details'''
* [[Inline-Assembler in avr-gcc|Inline-Assembler]]
* [[avr-gcc/Interna|Interna von avr-gcc]]

'''Installation (Linux)'''
* [[Linuxdistribution_Avr-live-cd]]
* [[avr-gcc und avrdude installieren]]
'''Sonstiges'''
* [[WinAVR]]
* [[Speicherverbrauch bestimmen mit avr-gcc]]
* [[Compiler]]
* [[Dev-Cpp IDE]]
* [[AVR]]
----
* [[Sourcevergleich]]
* [[Codevergleich AVR-Compiler]]

=Weblinks=
==Dokumentation==

;Offline:

Je nach Distribution wird diese mit offline-Dokumentation als pdf, HTML, etc. ausgeliefert, die dann z.B. in Ordern wie den folgenden befindet:

: <GCC_HOME>/doc/gcc/
: <GCC_HOME>/doc/avr-libc/
: etc.

; Online

* [http://gcc.gnu.org/onlinedocs/cpp.pdf cpp.pdf (470 kByte)] - Dokumentation des C-Präprozessors (en)
* [http://www.nongnu.org/avr-libc/user-manual/pages.html AVR Libc: User Manual] - Dokumentation zur [http://www.nongnu.org/avr-libc AVR Libc].
* [http://sourceware.org/binutils/docs/ Binutils: Documentation] – Dokumentation der Binutils: Assembler, Linker, ...
* [http://gcc.gnu.org/wiki/avr-gcc avr-gcc im GCC Wiki] – Dokumentation des Application Binary Interface (ABI): Registerverwendung, Calling Conventions, ...
{| {{Blauetabelle}}
! [http://gcc.gnu.org GCC] Version ||colspan="2"| [http://gcc.gnu.org/onlinedocs Dokumentation] || AVR Options || Release Notes
|-
! Aktuelle Entwicklung
| [http://gcc.gnu.org/onlinedocs/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-5/changes.html GCC 5]
|-
! 4.9.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.9.1/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.9/changes.html GCC 4.9]
|-
! 4.8.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.8.3/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.8.3/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.8.3/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.8/changes.html GCC 4.8]
|-
! 4.7.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.7.4/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.7.4/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.7.4/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.7/changes.html GCC 4.7]
|-
! 4.6.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.6/changes.html GCC 4.6]
|-
! 4.5.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.5.4/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.5.4/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.5.4/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.5/changes.html GCC 4.5]
|-
! 4.4.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.4.7/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.4/changes.html GCC 4.4]
|-
! 4.3.x
| [http://gcc.gnu.org/onlinedocs/gcc-4.3.5/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-4.3.5/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-4.3.5/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-4.3/changes.html GCC 4.3]
|-
! 3.4.x
| [http://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/ HTML]
| [http://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc.pdf pdf]
| [http://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/AVR-Options.html online]
| [http://gcc.gnu.org/gcc-3.4/changes.html GCC 3.4]
|}

== Downloads==
* [http://sourceforge.net/projects/winavr/ WinAVR-Projekt bei sourceforge.net (en)]
* [http://cdk4avr.sourceforge.net/ avr-gcc und toolchain als Linux-Paket bei sourceforge.net (en)]
* [[Linuxdistribution_Avr-live-cd]]
== Tipps, Installation ==
*[http://www.nongnu.org/avr-libc/user-manual/install_tools.html ''"Installing the GNU Tool Chain"''] Hilfe zum Build und Installation von GCC, binutils, etc unter Linux
* Im GCC-Handbuch, siehe [[#Dokumentation|Dokumentation]].
* [http://www.linuxfocus.org/Deutsch/November2004/article352.shtml www.linuxfocus.org (Artikel)] - Tipps zu Build und Installation von avr-gcc, binutils und avr-libc unter Linux
* [http://users.rcn.com/rneswold/avr/ Rich Neswold: ''A GNU Development Environment for the AVR Microcontroller'']
* [http://www.mikrocontroller.net/topic/24166 www.mikrocontroller.net (Foren-Beitrag)] - Installation von GCC und Toolchain unter Mac OS X
* [http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=125603#125603 www.roboternetz.de (Foren-Beitrag)] ''avrgcc + avrdude installieren''
* [http://roboternetz.de/download/c_tutorial.zip AVR-Studio & C-Tutorial mit Installationsanleitung]

== Sonstiges ==
* [http://gcc.gnu.org/ Offizielle Homepage von GCC (en)]
* [http://de.wikipedia.org/wiki/GNU_Compiler_Collection GCC in der deutschen Wikipedia]
* [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial avr-gcc-Tutorial auf mikrocontroller.net]
* [http://savannah.nongnu.org/projects/avr-libc/ Nützliche GCC Runtime-Libary]
* [http://www.stromflo.de/dokuwiki/doku.php Atxmega-C-Tutorial]

=Autor=

--[[Benutzer:SprinterSB|SprinterSB]] 11:27, 7. Dez 2005 (CET)

[[Kategorie:Grundlagen]]
[[Kategorie:Microcontroller]]
[[Kategorie:Praxis]]
[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]

Regelungstechnik

2014-09-13T08:50:00Z

SprinterSB: /* Dimensionierung des Reglers */ wikify tabelle

'''Regelungen''' sind ein Bestandteil unseres Lebens und das nicht nur seit Erfindung der Dampfmaschine.

Allein schon der aufrechte Gang funktioniert nur mit Regelung. Dabei wirken die Sinne als Sensoren, das Gehirn als Regler und die Muskeln als Aktuatoren. Weitere Regelungen in unserem Körper sind z.B. die Konstanthaltung der Körpertemperatur, der Blutdruck, die Anpassung der Pupille auf Helligkeitsänderungen usw.

Im technischen Zeitalter ist der erste geschichtlich bedeutende Regler der Fliehkraftregler von James Watt, der für die Drehzahlregelung seiner Dampfmaschine eingesetzt wurde. Seitdem ist die Regelungstechnik aus keinem Technikbereich mehr wegzudenken. Die Regelungstechnik begegnet uns im täglichen Leben auf Schritt und Tritt: Der Temperaturregler der Zentralheizung, der Temperaturregler des Kühlschranks, der Regler für die Belichtungsautomatik im Fotoapparat, das ABS-System im Auto und die Netzspannungs- und Frequenzregelung des europäischen Versorgungsnetzes sind nur einige wenige Beispiele aus diesem Bereich.

''Autor Waste''

==Einleitung==

Der Begriff ''Regelung'' ist zu unterscheiden von dem im allgemeinen Sprachgebrauch oft synonym gebrauchten Begriff der ''Steuerung''. Das Steuern ist ein rein vorwärts gerichteter Prozess ohne Rückkopplung. Die Ausgangsgröße wird dabei nicht überwacht und kann sich durch Störungen von außen verändern. Ein Beispiel ist die Steuerung eines Motors mit einer einstellbaren Spannung. Durch Laständerungen wird sich die Drehzahl des Motors ändern. Soll nun die Drehzahl konstant gehalten werden, bedarf es einer Rückkopplung um über die Spannung die Drehzahl anzupassen. Diese Rückkopplung ist das Kennzeichen einer Regelung.

Das Regeln ist ein Vorgang, bei dem die Ausgangsgröße, im Beispiel die Drehzahl, fortlaufend überwacht wird und bei Abweichung über die Stellgröße, im Beispiel die Spannung, korrigiert wird. Der sich dabei ergebende Wirkungsablauf findet in einem geschlossenen Kreis, dem Regelkreis, statt.

==Der Regelkreis==

[[Bild:Regelkreis1.png|right|thumb|300px|Ein Regelkreis (Prinzip)]]

Das Prinzip einer Regelung ist das fortlaufende: '''Messen – Vergleichen – Stellen'''

;Messen: Die Regelgröße wird direkt oder mittels Sensoren gemessen.
;Vergleichen: Der Wert der Regelgröße wird mit dem Sollwert verglichen. Die Differenz ist die ''Regelabweichung''.
;Stellen: Aus der Regelabweichung wird unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke die ''Stellgröße'' bestimmt.

{{Absatz}}

[[Bild:Regelkreis2.png|thumb|350px|Wirkunsweise einer Regelung]]

Ein Regelkreis dient dazu, eine vorgegebene physikalische Größe, die ''Regelgröße'', auf einen gewünschten Wert (Sollwert) zu bringen und dort zu halten, unabhängig von eventuell auftretenden Störungen.
Um die Regelungsaufgabe zu erfüllen, muss der Augenblickswert der Regelgröße – der Istwert – gemessen und mit dem Sollwert verglichen werden. Bei auftretenden Abweichungen muss in geeigneter Art und Weise nachgestellt werden.

Um nun diese Aufgabe technisch zu lösen, gibt es die Regelungstechnik. Sie baut im wesentlichen auf die mathematische Beschreibung und Modellbildung des Systems Regelkreis. Zur Modellierung, Beschreibung und Simulation werden Blockschaltbilder mit diskreten Signalgliedern verwendet.

{{Absatz}}

[[Bild:Regelkreis3.png|thumb|350px|Beispiel einer Geschwindigkeitsregelung]]

Ein typisches Beispiel für einen Regelkreis – eine Geschwindigkeitsregelung – wird im nebenstehenden Bild gezeigt. Die Sollgeschwindigkeit ist 80 km/h. Durch eine äußere Störung, in dem Fall eine Steigung, verlangsamt sich das Fahrzeug auf 70 km/h. Die Abweichung wird durch das Tachometer erfasst. Als Korrekturmaßnahme wird mehr Gas gegeben, um wieder auf die Sollgeschwindigkeit von 80 km/h zu kommen.

{{Absatz}}

=== Begriffe ===

[[Bild:Regelkreis4.png|right]]

Ein Regelkreis besteht entsprechend des vereinfachten Blockschaltbildes, wie es oft in der Regelungstechnik verwendet wird, aus den Hauptteilen ''Regler'' und ''Regelstrecke'':

;Regler: Ist der Teil des Regelkreises, der unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke aus der Regelabweichung die Korrekturmaßnahmen zum Ausregeln ergreift.

;Regelstrecke: Ist der Teil des Regelkreises, der vom Regler ausgeregelt werden soll.

;Führungsgröße (Sollwert) w: Vorgegebener Wert, auf dem die Regelgröße durch die Regelung gehalten werden soll. Sie ist eine von der Regelung nicht beeinflusste Größe und wird von außen zugeführt.

;Regelgröße (Istwert) x: Ist die Ausgangsgröße der Regelstrecke, die zum Zweck des Regelns erfasst und zum Vergleich rückgeführt wird. In vielen Fällen ist in der Rückführung noch eine Messeinrichtung (Sensor) gezeichnet, die den Istwert erfasst, hier der Einfachheit halber weggelassen.

;Regelabweichung e: Differenz zwischen Führungsgröße und Regelgröße '''e = w – x''', bildet die eigentliche Eingangsgröße des Reglers.

;Stellgröße y: Ausgangsgröße der Regeleinrichtung und zugleich Eingangsgröße der Strecke. Sie überträgt die steuernde Wirkung des Reglers auf die Strecke.

;Störgröße z: Eine von außen wirkende Größe, die eine Änderung des Istwertes der Regelgröße bewirkt und einen Regelvorgang auslöst.

==Die Regelstrecke==
Die Regelstrecke stellt den zu regelnden Teil bzw. den zu regelnden Prozess dar und umfasst normalerweise eine Reihe von einzelnen Gliedern. Die Glieder werden entsprechend ihrem Zeitverhalten charakterisiert. Um das Zeitverhalten herauszufinden, legt man an den Eingang ein Testsignal an und zeichnet die Antwort auf. Im einfachsten Fall wird der Eingang mit einer sprunghaften Änderung beaufschlagt. Die Antwort auf die sprunghafte Änderung der Eingangsgröße wird Sprungantwort genannt und gibt Aufschluss über die Art der Regelstrecke und kann eventuell bereits genutzt werden, um die Parameter der Regelstrecke zu bestimmen.

Für den Aufbau eines gut funktionierenden Regelkreises und die Auslegung von Reglern ist es eine Voraussetzung zu wissen, wie die Regelstrecke reagiert. Ohne ein genaues Wissen um das dynamische Verhalten der Regelstrecke ist es nicht möglich geeignete Regler auszuwählen und diese zu parametrieren.

Die wichtigsten dynamischen Grundelemente zur Charakterisierung der Regelstrecke sind nachfolgend aufgelistet. Jedes Element wird mit einem Block dargestellt und darin durch ein Symbol oder der stilisierten Sprungantwort gekennzeichnet.

----

===Proportionalglied (P-Glied)===
[[File:pglied.gif]]

Die einfachste Art einer Regelstrecke.
;Beispiele: Hebel, Getriebe, Verstärker, Spannungsteiler, Sensoren bei denen das Zeitverhalten vernachlässigt werden kann

----

===Integrator (I-Glied)===
[[File:iglied.gif]]

Strecke ohne Ausgleich, ist häufig in Regelstrecken vorhanden.
;Beispiele: Beschleunigung → Geschwindigkeit → Weg, Strom → Kondensatorspannung

----

===Verzögerungsglied 0.Ordnung (Totzeitglied)===
[[File:ttglied.gif]]

Entsteht durch Laufzeiten von Material oder Signalen. Je größer die Verzögerungszeit einer Regelstrecke ist, um so schwieriger ist sie zu regeln.
;Beispiele: Förderband, Rechenzeit, A/D-Wandler

Nicht zu verwechseln mit der Totzeit, die durch das asynchrone Auftreten eines Ereignisses auf einen Zyklus entsteht. Vom Verzögerungsglied 0.Ordnung unterscheidet sich diese dadurch, daß sie mit einer gleichverteilten Wahrscheinlichkeit zwischen "gar nicht" und dem gesamten Umfang auftritt. Diese Totzeit ist mechanisch mit einem Spiel vergleichbar das "gar nicht" bis zum vollen Umfang zu einem Fehler beiträgt.
;Beispiele: Erkennen eines Signals an einem Mikroprozessor

----

===Verzögerungsglied 1.Ordnung (PT1-Glied)===
[[File:pt1glied.gif]]

Viele einfache Regelstrecken haben ein solches Verhalten bzw. können näherungsweise damit beschrieben werden. Ist ein P-Glied mit nicht vernachlässigbarem Zeitverhalten.
;Beispiele: Gleichstrommotor (Spannung → Drehzahl), näherungsweise; Widerstand-Kondensator-Schaltung (RC-Glied)

----

===Verzögerungsglied 2.Ordnung (PT2-Glied)===
Man unterscheidet schwingungsfähige und nicht schwingungsfähige PT2-Glieder. Zur Charakterisierung gibt es die Parameter Dämpfung D und Eckfrequenz w<sub>0</sub> oder die Zeitkonstanten T<sub>1</sub> und T<sub>2</sub>. Für Dämpfung D<1 ist es schwingungsfähig.

'''Schwingfähiges PT2-Glied:'''<br/>
[[File:pt2aglied.gif]]
;Beispiele: Mechanischer Schwinger (Feder-Masse-System), elektrischer Schwingkreis (RLC-Kreis)

'''Nicht schwingfähiges PT2-Glied:'''<br/>
[[File:pt2bglied.gif]]
;Beispiele: Zwei hintereinander geschaltete PT1-Glieder, Gleichstrommotor (Spannung → Drehzahl) mit berücksichtigter Induktivität

==Der Regler==
Der Regler hat die Aufgabe, die Regelgröße zu messen, sie mit dem Sollwert zu vergleichen und bei Abweichungen die Stellgröße so zu verändern, dass Soll- und Istwert der Regelgröße wieder übereinstimmen bzw. die Differenz minimal wird.

Die Wahl eines bestimmten Reglertyps richtet sich nach dem geforderten Zeitverhalten und der geforderten Regelgenauigkeit der Regelstrecke. Nachfolgend finden Sie eine Zusammenfassung der wichtigsten klassischen Reglertypen:

===P-Regler===
Der proportionalwirkende Regler multipliziert die Regelabweichung mit seinem Verstärkungsfaktor '''Kp''' und gibt das Ergebnis unverzögert weiter. Er unterscheidet sich prinzipiell nicht vom dynamischen Element P-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der P-geregelte Kreis ist einfach und mittelschnell im Vergleich zu anderen Regelungen. Das Problem ist die bleibende Regelabweichung!

[[File:pregler.gif]]

'''Software P-Regler:'''
y = Kp * e

----

===I-Regler===
Der integralwirkende Regler summiert die Regelabweichung über der Zeit auf und multipliziert die Summe (d.h. das Integral) mit dem Faktor '''Ki'''. Je länger eine Regelabweichung ansteht, desto größer wird die Stellgröße des I-Reglers. Er unterscheidet sich prinzipiell nicht vom dynamischen Element I-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der I-geregelte Kreis ist langsam im Vergleich zu anderen Regelungen. Er hat aber den Vorteil, dass die Abweichung vollständig eliminiert wird.

[[File:iregler.gif]]

'''Software I-Regler:'''
esum = esum + e
y = Ki * Ta * esum

'''esum''' ist die Summe aller bisherigen Abweichungen '''e'''. Der Parameter des Software I-Reglers ist abhängig von der Rechenschrittweite '''Ta''' (Abtastzeit). Je öfter gerechnet wird, desto öfter wird auch hinzugezählt (aufintegriert). Eine kleine Abtastzeit erfordert also einen kleineren Faktor, dies wird durch die Multiplikation mit '''Ta''' verwirklicht.

----

===PI-Regler===
Der PI-Regler ist die Kombination aus P- und I-Regler und kombiniert den Vorteil des P-Reglers, nämlich schnelle Reaktion, mit dem Vorteil des I-Reglers, der exakten Ausregelung. Der PI-geregelte Kreis ist also genau und mittelschnell.

[[File:piregler.gif]]

'''Software PI-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum

----

===PD-Regler===
Der proportional-differential wirkende Regler kombiniert den P-Regler mit einem D-Anteil.
Der D-Anteil bewertet die Änderung einer Regelabweichung (er differenziert) und berechnet so deren Änderungsgeschwindigkeit. Diese wird mit dem Faktor '''Kd''' multipliziert und zum P-Anteil hinzuaddiert. Der PD-Regler reagiert damit schon auf Ankündigungen von Veränderungen, das bewirkt sozusagen ein Vorhalten beim Regeln.

Der PD-geregelte Kreis ist sehr schnell im Vergleich zu anderen Regelungen, und manche Regelkreise (solche mit zweifacher Integration) sind ohne D-Anteil überhaupt nicht stabilisierbar. Das Problem der proportionalen Regler, die bleibende Regelabweichung, ist beim PD-Regler allerdings weiterhin vorhanden!

Ein Nachteil aller Regler mit D-Anteil kann die Unruhe im Kreis sein. Ist das Sensorsignal verrauscht, so wird dieses Rauschen durch die Differenziation weiter verstärkt und wieder in den Kreis hineingegeben. Dadurch wird der Aktuator stärker belastet. Macht der Regler insbesondere sehr hohe Ausschläge als Folge von schnellen Änderungen des Sollwertes, dann kann es sein, dass das Stellglied oder der Aktuator diese nicht umsetzen kann - die Wirkung des D-Anteils würde dann durch die Begrenzung verpuffen, und das Einschwingverhalten wäre nicht wie berechnet, sondern meist langsamer. Dies gilt aber nur für große Sprünge. Bei den normalen kleinen Regelvorgängen zum Ausgleich von Störeinflüssen wirkt der D-Anteil wie beabsichtigt.

[[File:pdregler.gif]]

'''Software PD-Regler:'''
y = Kp * e + Kd * (e – ealt)/Ta
ealt = e

Mit der neuesten Regelabweichung '''e''' und der vorhergehenden '''ealt''' wird der D-Anteil berechnet. Die Differenziation erfolgt damit angenähert durch Bildung des Differenzquotienten (e - ealt)/Ta.

----

===PID-Regler===
Der PID Regler ist der universellste der klassischen Regler und vereinigt die guten Eigenschaften der anderen Regler. Zur Beschreibung der Eigenschaften des P-, I- und D-Anteils siehe die anderen Reglertypen. Der PID-geregelte Kreis ist genau und sehr schnell. In den meisten Anwendungen kommt deshalb der PID-Regler zum Einsatz.

[[File:pidregler.gif]]

'''Software PID-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum + Kd * (e – ealt)/Ta
ealt = e

'''Alternative PID-Reglerstruktur:'''

Es gibt 2 Darstellungsmöglichkeiten, die inhaltlich identisch sind. In der analogen Regeltechnik ist noch die Darstellung mit der Nachstellzeit '''Tn''' und der Vorhaltezeit '''Tv''' üblich. Die Umrechnung zwischen den beiden Strukturen ist mit den angegebenen Formeln möglich.

[[Bild:PIDstruktur.gif]]

==Vergleich der Reglertypen==
In der folgenden Abbildung ist der Vergleich von P-, I-, PI-, PD- und PID-Regler in einem Regelkreis mit PT2-Glied als Regelstrecke dargestellt. Es ist deutlich zu sehen, dass die Regler ohne I-Anteil (P und PD) eine bleibende Regelabweichung aufweisen. Erst die Regler mit I-Anteil können auf den Endwert von 1 ausregeln. Beim reinen I-Regler geht das so langsam, dass es gar nicht mehr auf dem Diagramm zu sehen ist. Der Hauptzweck eines I-Anteils ist also die Vermeidung bleibender Regelabweichungen. Daher ist ein
I-Anteil normalerweise nicht nötig, wenn die Strecke schon einen I-Anteil besitzt.
Ausnahme: Es wird ein doppelter I-Anteil zur Vermeidung von Schleppfehlern benötigt.

Die schnellsten Regler sind die mit einem D-Anteil (PD und PID). Der D-Anteil kommt deshalb hauptsächlich zum Einsatz, wenn schnelle Dynamik gefragt ist oder die Strecke selbst schon instabil ist. Voraussetzung für die Schnelligkeit ist allerdings, dass keine Begrenzung im Stellglied oder Aktuator auftritt. In der Praxis ist eine Begrenzung meistens nicht zu vermeiden, deshalb gilt die Sprungantwort in der Praxis nur für kleine Sprünge.

Die Regler ohne D-Anteil, aber mit P-Anteil (P und PI) sind mittelschnell. Für einfache Regelaufgaben reicht auch oft schon ein reiner P-Regler aus, wenn die bleibende Regelabweichung vernachlässigt werden kann oder weil die Strecke schon einen I-Anteil besitzt.

[[File:reglervergleich.gif]]

Aus diesem Vergleich wird klar, warum der PID-Regler so beliebt ist, er vereinigt die Vorzüge aller anderen Regler.

==Digitaler Regler==
Durch die Einführung leistungsfähiger und preiswerter Mikroprozessoren hat sich der digitale Regler mehr und mehr durchgesetzt. Im Gegensatz zum analogen Regler werden die Signale nicht mehr analog mit Operationsverstärker verarbeitet, sondern mit einem Mikroprozessor errechnet. Bevor das Signal vom Mikroprozessor bearbeitet werden kann, muss zunächst das Eingangssignal (Istwert) mit einem Analog-Digital-Umsetzer (ADU) digitalisiert werden, d.h. in einen Zahlenwert umgewandelt werden. Das vom digitalen Regler errechnete Ausgangssignal (Stellgröße) wird wiederum zur Ansteuerung des Stellglieds mit einem Digital-Analog-Umsetzer (DAU) in ein analoges Signal gewandelt. Funktionell unterscheiden sich analoger und digitaler Regler jedoch nicht wesentlich, es müssen nur die Schnittstellen angepasst werden.

[[File:digreg.gif|right|framed|Digitaler Regler (Prinzip)]]

Da die Wandlungen und das Regelprogramm eine gewisse Zeit beanspruchen, vergeht pro Durchlauf die sogenannte Takt- oder Abtastzeit. Diese Zeit wirkt sich im Regelkreis wie ein Totzeitglied mit der halben Abtastzeit als Totzeit aus. Das verursacht eine zusätzliche Phasenverschiebung, was sich ungünstig auf die Stabilität des Regelkreises auswirken kann. Ist die Abtastzeit sehr viel kleiner als die dominierende Zeitkonstante der Strecke, dann spricht man von quasi-kontinuierlichem Verhalten, da sich der digitale Regler ähnlich wie ein analoger Regler verhält. Der digitale Regler kann dann wie ein analoger dimensioniert werden. Ist die Abtastzeit größer, kann sie nicht mehr vernachlässigt werden, dann muss sie auch beim Reglerentwurf berücksichtigt werden.

'''Vorteile digitaler Regler:'''
* Die Verarbeitung erfolgt driftfrei.
* Es lassen sich nichtlineare Kennlinien, intelligentes Verhalten oder adaptive Regelung leichter realisieren.
* Der Regler kann bei Bedarf per Software neu konfiguriert und parametriert werden

'''Digitale Realisierung am Beispiel des PID-Algorithmus'''

Ausgehend von der Differentialgleichung für kontinuierliche Systeme wird die Differenzengleichung für zeitdiskrete Systeme erstellt. Daraus folgt dann der Stellungsalgorithmus in allgemeiner Form.

Ta = Abtastzeit; k = Nummer der Abtastung

Kp = Proportionalbeiwert; Ki = Integrierbeiwert; Kd = Differenzierbeiwert



'''Differentialgleichung für den kontinuierlichen PID-Regler:'''
:<math>
y(t) \;=\; Kp \!\cdot\! e(t)
+ Ki \int_0^t e(\tau) \, d\tau
+ Kd \, \frac{de(t)}{dt}
</math>

'''Differenzengleichung für den zeitdiskreten PID-Regler:'''
:<math>
y_k \;=\; Kp \!\cdot\! e_k
+ Ki \!\cdot\! Ta \sum_{i=0}^k e_i
+ \frac{Kd}{Ta}\, ( e_k - e_{k-1} )
</math>

'''PID Stellungs-Algorithmus:
:''' <math>
y_k \;=\; y_{k-1}
+ q_0 \!\cdot\! e_k
+ q_1 \!\cdot\! e_{k-1}
+ q_2 \!\cdot\! e_{k-2}
</math>

Mit den Parametern:
:<math>
q_0 \,=\, Kp + Ki \!\cdot\! Ta + \frac{Kd}{Ta}
\, , \quad
q_1 \,=\, -Kp - 2 \, \frac{Kd}{Ta}
\, , \quad
q_2 \,=\, \frac{Kd}{Ta}
</math>

'''Umsetzung in Code nach der Differenzengleichung:'''

Im Code wurden einige Variablen umbenannt, da die Indexschreibweise nicht möglich ist.

y entspricht y<sub>k</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, esum ist die Summenbildung

In der Praxis wird man die Ausdrücke Ki*Ta und Kd/Ta vorab berechnen und mit Ersatzvariablen in die Reglergleichung einsetzen. Der Verständlichkeit halber wurde es hier im Code belassen. Des weiteren kann eine Begrenzung von esum notwendig werden, um einen Variablenüberlauf oder Windup-Effekt zu vermeiden.

Der nachfolgende Code wird im Rhythmus der Abtastzeit Ta immer wieder aufgerufen.
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
y = Kp*e + Ki*Ta*esum + Kd/Ta*(e – ealt); //Reglergleichung
ealt = e;
----

'''Alternative Umsetzung in Code nach dem Stellungsalgorithmus:'''<br/>
y entspricht y<sub>k</sub>, yalt entspricht y<sub>k-1</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, ealt2 entspricht e<sub>k-2</sub>
e = w - x; //Vergleich
y = yalt + q0*e + q1*ealt + q2*ealt2; //Reglergleichung
ealt2 = ealt;
ealt = e;
yalt = y;

==Dimensionierung des Reglers==
Die Auswahl des Reglertyps ist heutzutage bei den digitalen Reglern nicht mehr so kritisch, da der Mehraufwand in Software für einen PID-Regler gegenüber einfacheren Typen kaum zu Buche schlägt. Im Prinzip ist man deshalb mit einem PID-Regler fast immer auf der richtigen Seite, mit einer Ausnahme, bei einer Strecke mit reiner Totzeit. Die folgende Tabelle gibt eine Hilfestellung zur Auswahl des Reglers.

:{| {{Blauetabelle}}
|+ '''Geeignete Reglertypen für die unterschiedlichen Regelstrecken'''
!rowspan=2 | Strecke
!colspan=4 | Regler
|-
! P || PD || PI || PID
|-
|reine Totzeit
| 
| 
|<div align="center">geeignet</div>
| 
|-
|1.Ordnung mit kleiner Totzeit
| 
| 
|gut geeignet
|gut geeignet
|-
|2.Ordnung mit kleiner Totzeit
| 
| 
| 
|gut geeignet
|-
|höhere Ordnung
| 
| 
| 
|gut geeignet
|-
|I-Glied und Verzögerung
|geeignet
|gut geeignet
|<div align="center">geeignet</div>
|gut geeignet
|}

Nachdem man einen geeigneten Reglertyp ausgewählt hat, stellt sich noch die Frage, wie man die Reglerparameter Kp, Ki, und Kd optimiert. Im Laufe der Zeit wurden viele Methoden zur Dimensionierung der Reglerparameter entwickelt, aber es können hier nicht alle aufgelistet werden. Diese Aufzählung beschränkt sich auf die einfacheren und gängigen Methoden der Parametrierung.

===Dimensionierung durch Probieren (Empirisches Einstellen)===

====Methode 1====

Diese Methode ist geeignet um einfache Systeme zu dimensionieren, insbesondere wenn man bereits Erfahrung mit ähnlichen Regelkreisen hat. Man fängt mit einer unkritischen Einstellung (Kp klein, Ki = 0, Kd = 0) an und erhöht langsam die Verstärkung Kp, bis die Dämpfung schlecht wird. Falls eine Schwingneigung auftritt, muss die Verstärkung wieder etwas zurück genommen werden. Dann nimmt man allmählich den Integralanteil hinzu, erhöht ihn in Schritten und probiert solange herum, bis das Ergebnis einigermaßen passt. Bei Bedarf kann noch ein D-Anteil (PID-Struktur) probiert werden. Wenn dabei die Regelung stabiler wird, kann noch mal Kp und Ki erhöht werden, bis man endgültig zufrieden ist.

====Methode 2====
Alle Anteile erstmal auf 0. Dann erhöht man Kp so lange bis das System deutlich schwingt. Danach wird der Kd so lange erhöht bis das System nicht mehr schwingt. Anschliessend kann noch ein kleiner Ki Anteil hinzugegeben werden.

Es dürfte klar sein, dass so eine Optimierung im Blindflug nicht immer das Optimum ergibt, aber es ist eine gängige praktische Methode zur Ermittlung der Reglerparameter. Besser sieht es aus, wenn in einer Simulation empirisch optimiert wird. Zusätzliche Informationen über die Stabilität erlauben hierbei eine gezieltere Optimierung. Zudem ist das Probieren im Simulator gefahrlos möglich, was in der Realität nicht immer der Fall ist. Geeignete Programme zur Simulation sind [[Regelungstechnik#Hilfsprogramme_zur_Analyse_und_Optimierung| hier]] vorgestellt. Allerdings muss für eine Simulation die Regelstrecke bekannt sein. Ist das nicht der Fall, so bleibt nur das einfache Probieren oder das Einstellen nach der Schwingungsmethode wie im folgenden beschrieben.

===Dimensionierung nach Einstellregeln===

Die Dimensionierung nach Rezept ist eine praktische Methode ohne viel Rechnerei und Hilfsmittel, eine Methode also für den Praktiker. Die bekanntesten Einstellregeln sind von Ziegler/Nichols und von Chien/Hrones/Reswick. Darüber hinaus gibt es noch eine Vielzahl anderer Einstelltabellen, auf die hier aber verzichtet wird, das würde den Rahmen dieses Artikels sprengen. An der Vielzahl kann man schon ersehen, dass es kein universell gültiges Rezept gibt und mit diesen Tabellen nicht unbedingt das Optimum erreicht wird, eine Nachoptimierung kann nötig sein.

Bei Ziegler/Nichols unterscheidet man noch zwischen der Schwingungsmethode und der Einstellung nach der Sprungantwort.

'''Einstellung nach der Schwingungsmethode:'''

Bei der Schwingungsmethode nach Ziegler/Nichols werden die Reglerparameter so verstellt, dass die Stabilitätsgrenze erreicht wird und der Regelkreis zu schwingen beginnt, d.h. die Regelgröße periodische Schwingungen ausführt. Aus der so gefundenen Einstellung können die Reglerparameter ermittelt werden. Dieses Verfahren ist nur auf Regelstrecken anwendbar, bei denen ein Schwingen keinen Schaden anrichtet und die überhaupt instabil gemacht werden können. Die Vorgehensweise ist folgende:
# Einstellung des Reglers als reinen P-Regler: Ki = 0 und Kd = 0
# Die Reglerverstärkung Kp wird solange vergrößert, bis sich der geschlossene Regelkreis an der Stabilitätsgrenze befindet und Dauerschwingungen ausführt.
# Der dabei eingestellte Wert Kp wird als Kp<sub>krit</sub> bezeichnet.
# Die Periodendauer der sich einstellenden Dauerschwingung T<sub>krit</sub> wird gemessen.
# Anhand der folgenden Tabelle werden dann die Reglerparameter bestimmt.

{| cellpadding=10
|
{| {{Blauetabelle}}
! Regler || Kp || Tn || Tv
|-
! P
| 0.5·Kp<sub>krit</sub> || ||
|-
! PI
| 0.45·Kp<sub>krit</sub> || 0.85·T<sub>krit</sub> ||
|-
! PID
| 0.6·Kp<sub>krit</sub> || 0.5·T<sub>krit</sub> || 0.12·T<sub>krit</sub>
|}
|
{| border=0 cellpadding=4
! Ki = Kp/Tn
|-
! Kd = Kp·Tv
|}
|}

Der Vorteil dieses Verfahrens liegt darin, dass die Untersuchung während des Betriebes und ohne Öffnen des Regelkreises durchgeführt werden kann. Der Nachteil an dem Verfahren ist, dass es nur auf Strecken angewendet werden kann, die auch zum Schwingen gebracht werden können.

'''Einstellung nach der Sprungantwort:'''<br/>
Diese Methode der Parameterbestimmung beruht auf der Aufnahme der Sprungantwort der Regelstrecke. Es eignet sich auch für Strecken, die nicht zum Schwingen gebracht werden können. Der Regelkreis muss allerdings geöffnet werden.
Vorgehensweise: Es wird die Sprungantwort aufgenommen und durch Einzeichnen der Wendetangente die Verzugszeit Tu und die Ausgleichszeit Tg ermittelt.

[[Bild:Tu_Tg.gif]]

Mit den so festgestellten Werten werden die Parameter für den einzusetzenden Regler gemäß nachstehenden Tabellen ermittelt.

{| cellpadding=10
|
{| {{Blauetabelle}}
|+ '''Einstellregeln nach<br/>Ziegler/Nichols'''
! Regler || Kp || Tn || Tv
|-
! P
| 1/Ks·Tg/Tu || ||
|-
! PI
| 0.9/Ks·Tg/Tu || 3.3·Tu ||
|-
! PID
| 1.2/Ks·Tg/Tu || 2·Tu || 0.5·Tu
|}
|
|
{| {{Blauetabelle}}
|+ '''Einstellregeln nach<br/>Chien/Hrones/Reswick'''
! Regler || Kp || Tn || Tv
|-
! P
| 0.3/Ks·Tg/Tu || ||
|-
! PI
| 0.35/Ks·Tg/Tu || 1.2·Tg ||
|-
! PID
| 0.6/Ks·Tg/Tu || Tg || 0.5·Tu
|}
|}

{| cellpadding=10
|
{| border=0 cellpadding=4
! Ki = Kp/Tn
|-
! Kd = Kp·Tv
|}
|
{| cellpadding=4 width=420
|Die Parameter Tn und Tv sind aus der analogen Regelungstechnik und sind dort sehr geläufig. Die Umrechnung in die Parameter Ki und Kd erfolgt mit nebenstehenden Formeln, siehe auch [[Regelungstechnik#PID-Regler| PID-Regler]].
|}
|}

===Dimensionierung mit dem Bodediagramm===

Ein Bode-Diagramm ist die grafische Darstellung des Frequenzganges. Es werden der Betrag der Übertragungsfunktion (Amplitudengang) und der Verlauf des Phasenwinkels (Phasengang) als Funktion der Frequenz aufgetragen. Die Frequenzachse und die Amplitudenachse werden logarithmisch dargestellt. Die logarithmische Darstellung hat den Vorteil, dass eine Multiplikation auf eine einfache Addition zurückgeführt wird. Somit wird eine Hintereinanderschaltung von Systemen im Blockschaltbild zu einer einfachen Addition im Bodediagramm.

Das Zeitverhalten des rückgekoppelten Regelkreises hängt entscheidend vom Verlauf
des Frequenzganges der offenen Regelschleife in der Umgebung des Durchtretens durch
die 0dB-Achse ab. In der Regelungstechnik wird daher der offene Regelkreis im Bode-Diagramm aufgetragen. Das erlaubt einen schnellen Überblick über Stabilität und möglichen Reserven zur Optimierung. Ein Kriterium für die Stabilität der Schleife ist der Phasenrand und der Amplitudenrand. Der Phasenrand ist der Abstand (Phasenreserve) zur -180°-Linie bei der Durchtrittsfrequenz. Die Durchtrittsfrequenz ist diejenige Frequenz, bei der der Amplitudengang durch die 0dB-Linie geht. Siehe auch folgendes Bode-Diagramm.

[[Bild:Phasenrand.gif]]

{| {{Blauetabelle}}
|'''Regel:''' Eine geschlossene Regelschleife arbeitet genau dann stabil, wenn der Phasenrand positiv ist.
|}
Wird diese Bedingung verletzt, so wird in diesem Frequenzbereich die im Rückführzweig der Regelung eingebrachte Gegenkopplung zu einer Mitkopplung und das System kann schwingen.

'''Beim Reglerentwurf sind folgende Punkte zu beachten:'''
* Der Phasenrand muss positiv sein. Der geschlossene Regelkreis kann sonst instabil sein.
* Je größer der Phasenrand ist, desto größer ist die Stabilitätsreserve des Regelkreises und desto höher ist die Dämpfung des Regelkreises. Üblich sind Werte von 40°...70° für gutes Führungsverhalten und 20°...50° für gutes Störverhalten.
* Die Durchtrittsfrequenz ist ein Maß für die Schnelligkeit des Regelkreises, je höher, desto schneller ist die Reaktion auf Änderungen der Führungsgröße oder Störungen.

Hier ein Beispiel zur Dimensionierung mit dem Bode-Diagramm.

[[Bild:Bode1.gif]]

Die Strecke ist rot dargestellt und besteht in dem Beispiel aus einem nicht schwingfähigem PT2-Glied. Man sucht sich den Punkt, wo die Strecke für sich alleine noch ausreichend Phasenreserve hat, z.B. 70°. In dem Beispiel also die Frequenz, bei der die Strecke –110° Phasendrehung aufweist. Das ist etwa bei 15Hz. Da hat die Strecke ungefähr eine Dämpfung von 25dB. Wenn man nun diese Dämpfung durch eine Verstärkung von 25dB kompensiert, dann wird dieser Punkt zur Durchtrittsfrequenz. D.h. man wählt den P-Anteil des Reglers Kp=18, denn 25dB entspricht ungefähr dem Faktor 18. Um die Regelabweichung zu minimieren, wird noch ein I-Anteil hinzugefügt.

Üblicherweise wählt man für die Grenzfrequenz des PI-Reglers die Grenzfrequenz des dominierenden Streckenteils, in dem Beispiel ca. 1.4Hz. Damit ergibt sich ein I-Anteil von 170. Im Bode-Diagramm ist der PI-Regler als schwarze Kurve eingezeichnet. Die Addition der Strecke und des Reglers im Bode-Diagramm führt dann zum Frequenzgang des offenen Regelkreises (blaue Kurve). Die resultierende Durchtrittsfrequenz ist wie gewählt bei etwa 15Hz. Der Phasenrand hat sich durch den I-Anteil im Regler auf ca. 60° reduziert, ist aber noch ausreichend. Das Einschwingen des geschlossenen Regelkreises für diese Dimensionierung sieht dann folgendermaßen aus:

[[Bild:Sprungantwort3.gif]]

Bei Bedarf könnte noch ein D-Anteil (PID-Regler) hinzugenommen werden, das würde die Phase anheben und man könnte dadurch die Durchtrittsfrequenz weiter nach oben schieben. In der Praxis wird dies allerdings wegen der wahrscheinlichen Begrenzung des Stellglieds kein schnelleres Einschwingen mehr bringen.

Begrenzungen oder Nichtlinearitäten werden bei der Dimensionierung mit dem Bode-Diagramm nicht berücksichtigt. Das ist ein Nachteil dieser Methode. Eventuell muss deshalb noch einmal im Zeitbereich nachoptimiert werden.

===Dimensionierung mit der Ortskurve===
Eine Alternative zur Dimensionierung mit dem Bodediagramm stellt die Methode über die Ortskurve des offenen Regelkreises dar. Bei diesem Verfahren ist schnell auf einem Blick ersichtlich ob der Regelkreis stabil ist.

Liegt der Punkt –1 auf der Realteilachse links von der Ortskurve in Richtung steigendem ω (omega) so ist der Regelkreis stabil.
Der Abstand zu der kritischen Kreisfrequenz ω<sub>Krit</sub> von der Imaginärteilachse ist die Verstärkung Vr. Mit diesem Wert lässt sich der Amplitudenrand nach folgender Formelermitteln: Ar = 20 lg (1/Vr) in dB

Die Durchtrittskreisfrequenz ω<sub>D</sub> liegt an dem Punkt, wo der Betrag aus Realteil und Imaginärteil 1 ergibt. Wenn man weiß, wo die Durchtrittskreisfrequenz ist, dann kann man den Phasenrand bestimmen.
Dies ist der Winkel zwischen der –180°-Linie zu ω<sub>D</sub>.

[[Bild:Ortskurve.jpg]]

==Hilfsprogramme zur Analyse und Optimierung==
Die Analyse und Optimierung von Regelkreisen wird wesentlich erleichtert durch die Zuhilfenahme von Programmen. Es erspart einem eine komplizierte Rechnerei von Hand oder umfangreiche Testläufe. Stellvertretend für all die verfügbaren Programme werden hier zwei Freeware-Programme vorgestellt, die dafür gut geeignet sind. Die Beschreibung hier ersetzt aber keine Tutorials, es wird nur die Anwendung für die Regelungstechnik beschrieben.

===Scilab/Scicos===
Scilab ist ein wissenschaftlich-technisches Softwarepaket für numerische Berechnungen. Scicos ist eine Erweiterung dazu, die eine blockorientierte und modellbasierte Simulation und Analyse von dynamischen Systemen bietet. Dieses Softwarepaket kann von der [http://www.scilab.org/ Scilab Homepage] herunter geladen werden.

====Scilab====
Mit Scilab ist es sehr einfach ein Bode-Diagramm zu zeichnen, es bedarf nur 3 Zeilen Code.
s=poly(0,'s');
G=syslin('c',0.72/(0.11*s+1));
bode(G)
Die 1.Zeile '''s=poly(0,'s');''' legt die Variable s als Polynomvariable fest. Dies braucht in einer Sitzung nur einmal gemacht zu werden. Die 2.Zeile '''G=syslin('c',0.72/(0.11*s+1));''' definiert ein lineares System mit der Übertragungsfunktion 0.72/(0.11s+1). Die 3.Zeile '''bode(G)''' zeichnet das Bode-Diagramm des zuvor mit syslin definierten Systems G. Zu beachten ist, dass Scilab auf der x-Achse im Bode-Diagramm die Frequenz in Hertz und nicht wie üblich die Kreisfrequenz darstellt. Anstelle des Bode-Diagramms kann auch die Sprungantwort gezeichnet werden. Dies geschieht mit folgenden Befehlen:
xbasc();
t=[0:0.001:2];
y=csim('step',t,G);
plot2d(t,y)
'''xbasc()''' löscht den letzten Plot mit dem Bode-Diagramm und mit '''t=[0:0.001:2]''' wird ein Vektor t mit den angegebenen Zeiten im Intervall von 1ms definiert. Die Zeile '''y=csim('step',t,G)''' berechnet die Sprungantwort des zuvor mit syslin definierten Systems G und speichert sie in y ab. Das Ergebnis wird dann mit '''plot2d(t,y)''' dargestellt. Bei Bedarf können noch Gitternetzlinien mit dem Befehl '''xgrid()''' hinzugefügt werden.

Ergänzend hier noch ein Scilab-Skript, welches recht hilfreich bei der Dimensionierung mit dem Bode-Diagramm ist. Den nachfolgenden Code einfach in das SciPad-Fenster (Editor von Scilab) kopieren und starten. Es werden 2 Grafikfenster angezeigt, eines mit dem Bode-Diagramm und ein zweites mit der Sprungantwort. Man kann im Skript die Streckencharakteristik anpassen und verschiedene Reglerparameter ausprobieren.

<pre>
Ks=0.72; // Verstärkung der Strecke
T1=0.11; // Zeitkonstante 1
T2=0.005; // Zeitkonstante 2
Kp=18; // Proportionalbeiwert
Ki=170; // Integralbeiwert
Kd=0; // Differenzialbeiwert

s=poly(0,'s'); // definiert s als Polynomvariable
P=(T1*s+1)*(T2*s+1); // Streckencharakteristik
Gs=syslin('c',Ks,P) // Übertragungsfunktion der Strecke

RZ=poly([Ki Kp Kd],'s','coeff') // Zählerpolynom des Reglers
RN=poly([0 1],'s','coeff') // Nennerpolynom des Reglers
Gr=syslin('c',RZ,RN) // Übertragungsfunktion des Reglers

G=Gr*Gs // Übertragungsfunktion gesamt
xset("window",0);
xbasc(0);
bode([Gr;G;Gs],0.1,100,['Regler';'gesamt';'Strecke'])

Gcl=G/(G+1) // geschlossene Regelschleife
t=0:0.001:0.2;
y=csim('step',t,Gcl); // berechnet Sprungantwort
xset("window",1);
xbasc(1);
plot2d(t,y,2);
xgrid();
xtitle("Sprungantwort","sec");
</pre>

====Scicos====
Eine weitere Möglichkeit zur Simulation im Zeitbereich bietet Scicos. Die Modellierung geschieht mit einem grafischen Editor, in dem Blöcke mit vordefinierten oder selbstgemachten Funktionen miteinander verbunden werden. Ein einfaches Modell eines Regelkreises mit PID-Regler sieht folgendermaßen aus:

[[Bild:Scicos_anaReg.gif]]

Der PID-Regler ist mit seinen 3 Zweigen (P, I und D) dargestellt. In den Verstärkerblöcken kann durch Ändern der Reglerparameter (KP, KI und KD) der Regler optimiert werden. Die Strecke ist in diesem Beispiel nur ein einzelner Block, in dem die Übertragungsfunktion eingegeben wird. Man kann die Strecke auch detaillierter mit einzelnen Funktionsblöcken darstellen. Ein Beispiel eines komplexen Blockschaltbilds für einen balancierenden Bot ist unter diesem [http://www.roboternetz.de/phpBB2/download.php?id=5082 Link] zu finden.

Der Vorteil der Simulation mit Scicos ist die Möglichkeit Nichtlinearitäten zu berücksichtigen und die Kombination von kontinuierlichen und diskreten Funktionen. Das heißt, man kann einen digitalen Regler mit seinen diskreten Schritten und eine analoge Strecke, als kontinuierliche Funktion eingegeben, zusammen simulieren. Scicos bietet sogar einen 'Scifunc'-Block, mit dem Rechenschritte des digitalen Reglers nachgebildet werden können. Damit wird sowohl das dynamische Verhalten, verursacht durch die Abtastzeit Ta, als auch die etwas unterschiedliche Dynamik durch die digitale Ausführung eines I- und D-Anteils richtig simuliert. Ein Beispiel für den Einsatz des Scifunc-Blocks ist in folgendem Blockschaltbild zu sehen.

[[Bild:Scicos_digReg.png]]

Beispiel: [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlregelung]] mit digitalem Regler

Die globalen Variablen für die Reglerparameter und die Abtastzeit werden unter dem Menüpunkt „Edit - Context“ abgelegt.
Kp=18;
Ki=60;
Ta=0.01;
In den Taktgeber für den digitalen Regler wird als Clock-Periode die Abtastzeit Ta eingetragen. In das Dialogfenster zum Scifunc-Block wird folgender Code zur Simulation des digitalen PI-Reglers eingetragen:
<pre>
z=z+Ki*Ta*u1
if z>5 then
z=5;
end
y1=Kp*u1+z
if y1>5 then
y1=5;
end
</pre>
z entspricht der Variable esum vom Beispiel des [[Regelungstechnik#Realisierung_mit_digitalem_Regler| digitalen Drehzahlreglers]]; u1 ist die Eingangsvariable und y1 die Ausgangsvariable des Scifunc-Blocks.
In den Block für die Strecke wird die Übertragungsfunktion eingetragen. Als Zähler die Verstärkung Ks, also 0.72. Im Nenner das Polynom (1+0.11*s) für die Charakteristik der Strecke. Mit ‚Simulate – Run’ wird die Simulation gestartet. Als Ergebnis sollte das Einschwingen der Stellgröße (schwarz) und der Regelgröße (grün), wie in folgender Abbildung erscheinen.

[[Bild:Sprungantwort_DZR.png]]

Man kann nun mit den Reglerparametern und verschiedenen Abtastzeiten spielen, um zu sehen wie sich die Änderungen auswirken. Zum Beispiel wird bei einer Verdopplung der Abtastzeit der Regelkreis bereits instabil.

Diese Beispiele sind nur ein kurzer Auszug von den Möglichkeiten mit Scilab/Scicos für den Einsatz in der Regelungstechnik. Darüber hinaus ist es auch sehr gut geeignet bei anderen Optimierungsverfahren wie z.B. beim WOK-Verfahren (Wurzelortskurven) oder zur Analyse und Optimierung von modernen Reglern wie z.B. Zustandsregler und Kalmanfilter.

===LTspice/SwitcherCad III===
Dieses Programm ist ein SPICE-Derivat von der Firma Linear Technology und ist unter den 2 Namen LTspice und SwitcherCad III bekannt. Der Einfachheit halber wird für die weitere Beschreibung hier nur der Name LTspice verwendet. Das Programm ist Freeware und kann unter diesem Link herunter geladen werden. http://ltspice.linear.com/software/LTspiceIV.exe

LTspice ist ein Simulationsprogramm zur Analyse von elektronischen Schaltungen. Mit LTspice kann sowohl im Zeitbereich als auch im Frequenzbereich analysiert werden und bietet sich dadurch mit den entsprechenden Modellen auch für den Einsatz in der Regelungstechnik an. Wer sich bereits mit SPICE-Programmen auskennt, für den sollte es auch in der Regelungstechnik die 1.Wahl sein.

Der Vorteil von LTspice ist die Möglichkeit einer sehr detaillierten Analyse, vorausgesetzt die Modelle sind auch so detailliert nachgebildet. Insbesondere für analoge Regler, wo die elektrische Schaltung direkt umgesetzt werden kann, empfiehlt sich der Einsatz von LTspice. Der Nachteil ist, LTspice ist nicht auf regeltechnische Belange ausgelegt worden und spezifische Symbole für die Regelungstechnik müssen selbst erstellt werden. Einige selbst erstellte Symbole für dynamische Grundelemente in LTspice sind hier abgebildet.

[[Bild:LTSpiceSymb.png]]

Die 3 Symbole können [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=285 hier] heruntergeladen werden. Weitere Symbole können anhand dieser Beispiele sehr leicht selbst erstellt werden. Ein P-Glied kann durch eine spannungsgesteuerte Spannungsquelle (E-Source) oder Operationsverstärker mit einstellbarer Verstärkung dargestellt werden.

'''Analyse im Zeitbereich'''

Das Beispiel des [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlreglers]] mit analogem Regler wird hier mit LTspice simuliert. Das Schaltbild des Regelkreises zeigt nachfolgende Abbildung.

[[Bild:LTspice_TRAN.png]]

Der Vergleicher (U1) und der analoge PI-Regler (U2) sind so dargestellt, wie es auch in Wirklichkeit ausgeführt werden kann. Da der PI-Regler in der Schaltung bereits invertiert, wurden die Eingänge am Vergleicher vertauscht, damit die Polarität wieder stimmt. Der Rest des Regelkreises wurde stark vereinfacht, kann aber nach Bedarf auch ausführlicher dargestellt werden. Das PT1-Glied U3 simuliert die Strecke des Regelkreises und der Verstärker U4 dient nur zur Umrechnung auf die Drehzahl. Zur Simulation im Zeitbereich wird auf den Führungswert w mit der Spannungsquelle V1 ein Sprung gegeben. In der Reglerschaltung wurde bewusst ein Operationsverstärker mit Versorgungsspannung gewählt, damit auch der Einfluss einer Begrenzung mit simuliert wird. Die Zeitbereichsanalyse wird durch den LTspicebefehl .TRAN erreicht. Die Sprungantwort (Tachospannung) bei diesem Regelkreis sieht dann folgendermaßen aus.

[[Bild:Tacho2.png]]

Durch Ändern der Bauelemente R5, R6 und C1 kann man den Regler optimieren. Eine Umrechnung auf die Reglerparameter Kp und Ki ist mit folgenden Formeln möglich, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5

Ki = 1/(R5*C1)

Mit einem Mausklick auf den entsprechenden Knoten in der Schaltung können noch weitere Signale, wie z.B. die Stellgröße y angezeigt werden. Durch Verändern der Versorgungsspannung V3, V4 kann man sich auch die Auswirkung der Begrenzung ansehen.

'''Analyse im Frequenzbereich'''

Für die Darstellung des Bode-Diagramms der offenen Regelschleife in LTspice muss ein Trick angewendet werden, denn durch das Auftrennen der Regelschleife würde der Arbeitspunkt verloren gehen und dadurch die offene Schleife ohne Gegenkopplung an den Anschlag fahren.

Mit einer zusätzlichen Spannungsquelle in der Schleife kann man dieses Problem umgehen. Die Schleife bleibt für den Erhalt des Arbeitspunktes weiterhin geschlossen und man kann trotzdem die Verstärkung der offenen Schleife durch das Verhältnis der Spannung vor und hinter der Spannungsquelle bestimmen. Das erweiterte Blockschaltbild sieht folgendermaßen aus.

[[Bild:LTspice_AC.png]]

V2 ist die zusätzliche Spannungsquelle für die AC-Analyse. Die Spannungsquelle V1 wird von Pulsform auf Gleichspannung umgestellt. Sie wird so gewählt, dass sich der gewünschte Arbeitspunkt einstellt. Durch den LTspicebefehl .AC wird die Analyse im Frequenzbereich veranlasst. Um das Bode-Diagramm des offenen Regelkreises darzustellen, wird als Kurve nicht ein einzelner Knoten ausgewählt, sondern das Verhältnis der Spannung vom Ende zum Anfang des Regelkreises, in unserem Beispiel also V(tacho)/V(x). Zur Anzeige kommt dann das Bode-Diagramm (grüne Kurve) der offenen Schleife, wie in der folgenden Abbildung zu sehen. Für den Amplitudengang (durchgezogene Linien) gilt die linke Skala in dB, für den Phasengang (gestrichelte Linien) die rechte Skala in Grad.

[[Bild:LTspice_Bode.png]]

Zusätzlich ist noch das Bode-Diagramm der Strecke (rote Kurve) zu sehen. Dies ist durch einfaches Hinzufügen einer weiteren Kurve mit dem Ausdruck V(tacho)/V(y) durchgeführt worden.

Im Gegensatz zur üblichen Darstellung des Bode-Diagramms eines offenen Regelkreises, beinhaltet das mit LTspice erstellte Bode-Diagramm auch die -180 Grad Phasendrehung der Gegenkopplung. Der Phasenrand ist deshalb nicht auf -180 Grad sondern auf 0 Grad zu beziehen. In unserem Beispiel ist der Phasenrand etwa 90 Grad, also ein sehr stabiler Regelkreis. Zu beachten ist, dass die Frequenzachse des Bode-Diagramms wie auch schon bei Scilab in der Einheit Hertz anstatt wie üblich in der Kreisfrequenzeinheit rad/s dargestellt ist.

==Modellierung eines Motors/Antriebs==
[[Bild:ESB_Motor.png|thumb|320px|Ersatzschaltbild DC-Motor]]
Der Motor ist ein oft verwendeter Aktuator in der Robotik. Deshalb wird hier am Beispiel des Gleichstrommotors mit Permanentmagnet (Nebenschlussmotor) die Modellbildung gezeigt. Zur Modellierung gibt es mehrere Möglichkeiten. Je nachdem wie detailliert die Simulation sein soll, kann man sich ein Modell, von sehr einfach bis sehr detailliert, auswählen. Zwei Zeitkonstanten bestimmen die Dynamik eines Gleichstrommotors. Eine davon ist die mechanische Zeitkonstante, die ist meistens die dominierende Zeitkonstante und wird durch das Trägheitsmoment J des Rotors verursacht. Die zweite Zeitkonstante ist die elektrische Zeitkonstante, sie wird durch die Induktivität L bestimmt. Bei einfachen Regelungen kann in den meisten Fällen die elektrische Zeitkonstante vernachlässigt werden, damit reduziert sich das Modell auf ein einzelnes PT1-Glied.

'''Definition: Motor und Antrieb'''

Als '''Motor''' wird hier der Motor alleine verstanden. Die Ausgangsgröße ist die Winkelgeschwindigkeit w (Drehzahl).

Als '''Antrieb''' wird hier der komplette Antrieb eines Fahrzeugs verstanden, also Motor inklusive Getriebe und Masse des Fahrzeugs. Für die Dynamik ist nicht nur das Trägheitsmoment des Motors sondern auch die Masse des Fahrzeugs verantwortlich. Die Ausgangsgröße der Einheit „Antrieb“ ist die Geschwindigkeit v.

Die hier vorgestellten Modelle gelten sowohl für einen Motor als auch für einen kompletten Antrieb, wenn man die Elastizität und das Spiel des Getriebes vernachlässigt.

===Einfaches Modell mit PT1-Glied===
Die einfachste Art einen Motor oder Antrieb zu simulieren, ist mit einem PT1-Glied als Modell. Das Simulationsprogramm [[Regelungstechnik#Scicos|Scicos]] bietet dazu einen Block zur Eingabe der Übertragungsfunktion (num(s)=Zähler, den(s)=Nenner der Übertragungsfunktion).
{| border=0 cellpadding=10
|Übertragungsfunktion:

<math>G(s)=\frac{K}{1+Ts}</math>

|Beispiel:
num(s) = K = 0.72
den(s) = 1 + Ts = 1 + 0.11s
|[[Bild:Scicos_TF.png]]
|}

Wird nicht nur das Ausgangssignal, also die Geschwindigkeit oder Drehzahl in der Simulation benötigt, sondern auch die Beschleunigung, dann kann nachfolgendes Modell verwendet werden. Dieses Modell ist der Differentialgleichung eines PT1-Glieds nachempfunden und liefert das gleiche Ergebnis wie vorheriges Modell, bietet aber noch den Zugriff auf das Beschleunigungssignal.
{| border=0 cellpadding=10
|Differentialgleichung:

<math>v'=\frac{K}{T}U-\frac{1}{T}v</math>

|
v = Geschwindigkeit
v’= Beschleunigung (Ableitung von v)
K = Übertragungsmaß
T = Zeitkonstante
U = Eingangsgröße (z.B. Spannung)
|[[Bild:Antrieb_PT1.png|thumb|Einfaches Modell eines Antriebs]]
|}

Die beiden Parameter K und T müssen ausgemessen werden, wenn sie nicht bekannt sind. Die Zeitkonstante T kann in einem Anlaufversuch ermittelt werden. Dazu wird auf den Motor ein Spannungssprung gegeben und die Sprungantwort am Ausgang nachgemessen. Bei einem Antrieb erspart diese Methode die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente (Motor, Getriebe, Fahrzeug). Bei der Ermittlung des Übertragungsmaß K ist zu beachten, dass sich möglicherweise der Motor durch starke Reibung erst ab einer bestimmten Spannung dreht. Hier ist die Steigung der Kennlinie mit delta v / delta U auszuwerten, wie im folgenden Bild zu sehen ist.

[[Bild:Antrieb_stat.png]]

Die einfachen Modelle gelten nur für den linearen Teil der Kennlinie. Soll auch die Nichtlinearität durch Reibung modelliert werden, dann sind detailliertere Modelle, wie im Folgenden beschrieben, zu verwenden. Die Auswirkung einer Haftreibung ist auch in dem Geschwindigkeitsdiagramm durch die Hysterese in der Kennlinie zu sehen. Beim Hochfahren der Ansteuerspannung bewegt sich das Fahrzeug erst ab ca. 1.25V, während beim Herunterfahren der Ansteuerspannung das Fahrzeug noch bis 0.75V rollt und erst unter 0.75V stehen bleibt.

===Detailliertes Modell===

[[Bild:Motor_Model.png|thumb|350px|Detailliertes Motormodell]]
Ein detailliertes Motormodell ist rechts in dem Bild zu sehen. Es hat auf der linken Seite den elektrischen Teil mit den Parametern R (Widerstand) und L (Induktivität) und auf der rechten Seite den mechanischen Teil mit den Blöcken Trägheitsmoment und Reibung. Der elektrische Teil liefert das Stromsignal i, welches mit der Motorkonstante Km in das Drehmoment M umgerechnet wird. Mit dem folgenden Summierglied kann über einen zusätzlichen Eingang auch ein extern angreifendes Lastmoment mit simuliert werden. Am Ausgang des mechanischen Teils steht die Winkelgeschwindigkeit w in der Einheit [rad/s] bzw. über den Umrechnungsfaktor 9.55 die Drehzahl in [Upm] zur Verfügung. Die Reibung wird in einem nichtlinearen Block mittels Lookup-Table simuliert. In der einschlägigen Literatur wird die Reibung meistens mit einem Dämpfungsfaktor (linear) simuliert, was einer viskosen Reibung entspricht. Das passt aber nicht so gut für Kleinmotoren, da überwiegt vor allem die trockene Reibung. Die trockene Reibung hat ein konstantes Bremsmoment wenn sich der Motor dreht (unabhängig von Drehzahl, Vorzeichen abhängig von Drehrichtung). So eine Funktion kann sehr einfach mit einer Lookup-Table realisiert werden. Die Lookup-Table kann auch dazu verwendet werden, Mischformen von trockener, viskoser und turbulenter Reibung und sogar noch Haftreibung in einem Block zu simulieren, wenn man will.

Bei einigen Herstellern, wie z.B. Faulhaber und Maxon, kann man die für das Modell nötigen Parameter im Datenblatt finden. Das Bremsmoment der Reibung berechnet sich aus dem Leerlaufstrom wie folgt: Bremsmoment = Motorkonstante * Leerlaufstrom

Falls die Daten nicht verfügbar sind, muss man sie selbst ausmessen. Eine Hilfestellung zur Bestimmung der Motorkonstante und des Trägheitsmoments gibt es hier:
*http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=96750&highlight=#96750
*http://www.roboternetz.de/phpBB2/viewtopic.php?t=12793

[[Bild:Antrieb_Modell.png|thumb|350px|Modell eines Antriebs]]

Das detaillierte Motormodell kann auch für einen Antrieb verwendet werden, wenn man eine starre Kopplung zwischen Motor und Antriebsrad voraussetzt, also Elastizität und Spiel des Getriebes vernachlässigt. Anstelle der rotatorischen Kenngrößen (Drehmoment M, Trägheitsmoment J, Winkelgeschwindigkeit w) werden die translatorischen Kenngrößen (Kraft F, Masse m, Geschwindigkeit v) eingesetzt. Das Drehmoment wird mittels Getriebeübersetzung ü und Radius r des Antriebsrades in die entsprechende Vortriebskraft umgerechnet. Daraus ergibt sich die Kraftkonstante Kf, die für das Antriebsmodell verwendet wird.

Die Umrechnung ist: Kf = Km * ü/r

Bei der Trägheitsmasse m muss neben der Masse des Fahrzeugs auch das Trägheitsmoment des Motors mit berücksichtigt werden. Die Umrechnung von Trägheitsmoment in eine äquivalente Masse = J * (ü/r)²

Der Reibungsblock in diesem Modellbeispiel enthält eine Mischform aus Haftreibung, trockener und viskoser Reibung, wie sie typisch für einen Kleinbot mit 2 Antriebsrädern und einem Gleitpin ist.

==Beispiel: Drehzahlregelung==
Es wird ein Gleichstrommotor in der Drehzahl geregelt. Als Sensor ist ein Tachogenerator vorhanden, der direkt auf der Motorwelle sitzt. Das System ist in einem kleinen Modellfahrzeug eingebaut und wird zur Geschwindigkeitsregelung eingesetzt, da die Drehzahl proportional zur Geschwindigkeit ist.

Das Funktionsschaltbild sieht folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl1.gif

Als Störgröße können unterschiedliche Reibwerte oder Steigung und Gefälle rückwirkend über das Getriebe die Drehzahl beeinflussen. Das Getriebe und die Last sind zwar außerhalb der Regelschleife, beeinflussen aber durch die feste Kopplung des Getriebes die Dynamik des Regelkreises. Durch die starre Kopplung kann das Trägheitsmoment des Motors und die Masse des Fahrzeugs zusammengefasst werden. Das Gleiche gilt auch für die Reibwerte. Damit vereinfacht sich die Modellierung und das Blockschaltbild reduziert sich auf folgende Schaltung:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl2.gif

Zur Ermittlung des dynamischen Verhaltens der Regelstrecke wird die Sprungantwort gemessen. Dazu wird auf den Eingang der Regelstrecke (Stellglied) ein Spannungssprung gegeben und die Antwort am Ausgang des Tachogenerators nachgemessen. Diese Methode erspart die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente der Regelstrecke (Motor, Getriebe, Fahrzeug). Die Messung ergab folgende Sprungantwort der Regelstrecke:

http://www.roboternetz.de/wiki/uploads/Main/tacho.gif

Wie zu erwarten, ist die Sprungantwort annähernd ein Verzögerungsglied 1.Ordnung. Die abgelesene Zeitkonstante ist 0.11s. Die Verstärkung der Regelstrecke ist Ks = 0.72. Das Übertragungsmaß des Tachogenerators ist 1V pro 2480Upm. Damit kann auf die Drehzahl rückgerechnet werden.

Da die Regelstrecke nur aus einem PT1-Glied besteht, könnte eine analoge Regelung fast beliebig schnell gemacht werden. Wegen der Begrenzung bringt aber das Ausreizen der Optimierung für das Führungsverhalten nicht viel, nur für das Störverhalten wäre eine schnellere Regelung sinnvoll. Um aber einen Vergleich zwischen analogem und digitalem Regler anstellen zu können wird eine Parametrierung gewählt, die auch für den digitalen Regler mit seiner Totzeit noch stabil ist. Es wird deshalb auch auf einen D-Anteil im Regler verzichtet und nur ein PI-Regler realisiert. Das vereinfachte Blockschaltbild mit den dynamischen Elementen sieht damit folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl3.gif

Zur Veranschaulichung wurde ein analoger als auch ein digitaler Regler realisiert. Die Parametrierung des analogen Reglers wurde mit dem Programm [[Regelungstechnik#LTspice.2FSwitcherCad_III| LTspice]] durchgeführt. Es bot sich an, da die analoge Reglerschaltung exakt simuliert werden konnte. Für die Optimierung des digitalen Reglers wurde dann [[Regelungstechnik#Scicos| Scicos]] verwendet.

===Realisierung mit analogem Regler===
Die elektrische Schaltung für einen analogen PI-Regler ist in der nächsten Abbildung zu sehen. Der erste Operationsverstärker vergleicht den Sollwert w mit dem Istwert x. Der zweite Operationsverstärker bildet den PI-Regler. Die Werte R5, R6 und C1 sind für die Charakteristik des PI-Reglers zuständig. Mit R6 kann der P-Anteil und mit C1 der I-Anteil eingestellt werden. Die Optimierung der Werte wurde empirisch in einer Simulation mit LTspice durchgeführt. Da die Schaltung des PI-Reglers invertiert, wurden zum Ausgleich am Vergleicher die Eingänge an U1 vertauscht, so dass sich über die gesamte Schaltung wieder die richtige Polarität ergibt.

[[Bild:Analogregler.png]]

Zum Umrechnen auf Kp und Ki können diese Formeln verwendet werden, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5 = 18

Ki = 1/(R5*C1) = 147

===Realisierung mit digitalem Regler===
Im digitalen Regelkreis wird der Istwert '''x''' vom Tachogenerator mit einem A/D-Wandler digitalisiert. Der Sollwert '''w''' wird dem µC als digitaler Wert übergeben. Die Stellgröße '''y''' entspricht dem PWM-Wert für den Motortreiber. Um zum analogen Regler vergleichbar zu sein, wurde sowohl für den A/D-Wandler als auch für den PWM-Steller eine 8-Bit-Breite vorgesehen. Damit ist die Verstärkung in beiden Fällen gleich und analoger und digitaler Regler besser vergleichbar.

Eigentlich könnte man bei kleiner Abtastzeit direkt die Parametrierung des analogen Reglers für die digitale Realisierung übernehmen. Aber es gibt doch kleine Unterschiede in der Dynamik zwischen analoger und digitaler Ausführung und um sicher zu gehen, dass die gewählte Abtastzeit einen nicht zu großen Einfluss hat, wird noch einmal mit [[Regelungstechnik#Scicos| Scicos]] nachoptimiert. Mit einer Abtastzeit Ta = 10ms und den Parametern des analogen Reglers ergibt sich ein Überschwingen, das nur sehr langsam auf den Endwert abklingt. Durch Verringern des I-Anteils auf 60 wird ein optimales Einschwingen für den digitalen Regler erreicht. Die Parameter sind:

Kp = 18

Ki = 60

Ta = 0.01

Zur Umsetzung in einen Code wurde die Programmiersprache C gewählt. Da der Code sehr einfach ist, sollte es auch kein Problem sein, den Code als Beispiel für andere Sprachen zu verwenden. Der Algorithmus wird im Takt der Abtastzeit, also alle 10ms aufgerufen. In der Reglergleichung kann zur Vereinfachung das Produkt Ki*Ta durch eine Ersatzvariable, die gleich das Ergebnis aus dem Produkt 60*0.01 = 0.6 hat, ersetzt werden. Zum besseren Verständnis wurde es hier beim Ki*Ta belassen. Um einen Windup-Effekt zu verhindern, wird die Summenbildung esum auf +-400 begrenzt. Der Wert wurde so gewählt, dass noch eine volle Aussteuerung durch den I-Anteil möglich ist. Zum Schluss wird die Stellgröße y auf die mögliche Aussteuerung des Stellglieds (0...255) begrenzt.

'''Programmbeispiel digitaler PI-Regler:'''

<pre>
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
if (esum < -400) {esum = -400;} //Begrenzung I-Anteil
if (esum > 400) {esum = 400;}
y = Kp*e + Ki*Ta*esum; //Reglergleichung
if (y < 0) {y = 0;} //Begrenzung Stellgröße
if (y > 255) {y = 255;}
PWM = y; //Übergabe Stellgröße
</pre>

== Beispiel: Lageregelung ==
Unter einer Lageregelung versteht man die Positionierung von Objekten. Als Beispiel soll hier ein kleiner Bot mit Radencoder eine bestimmte Weglänge fahren. Gegenüber der Drehzahl- oder Geschwindigkeitsregelung ist bei der Lageregelung noch ein zusätzlicher Integrator in der Strecke vorhanden. Die gesamte Strecke ist damit ein I-Glied mit Verzögerung. Laut Tabelle im Abschnitt „Dimensionierung des Reglers“ ist dafür ein PD-Regler gut geeignet. Der PD-Regler wird digital ausgeführt, zur Simulation und Parametrierung bietet sich deshalb Scicos an.

Da bei einer Lageregelung der Geschwindigkeitsbereich von Null aus geht, also über den nichtlinearen Bereich geht, sollte auch in der Simulation die Nichtlinearität berücksichtigt sein. Für das Beispiel wird deshalb das Modell eines Antriebs mit Haft- und Gleitreibung genommen, wie es unter "Modellierung eines Antriebs – detailliertes Modell" bereits vorgestellt wurde. Im Scicos-Modell ist der Antrieb der Übersichtlichkeit wegen als Superblock ausgeführt. Das Blockschaltbild des Antriebs im Detail ist [http://www.roboternetz.de/wissen/images/7/73/Antrieb_Modell.png hier] zu sehen. Die Daten sind:

R = 16 Ohm; L = 6 mH; m = 0.31 kg; Kf = 6.6 N/A

Als Sensor kommt ein Inkrementalgeber zum Einsatz, allerdings muss der richtungssensibel sein, sonst ist keine Lageregelung möglich. Der Sensor wird in Scicos mit der Rundungsformel (round(u1*500)) simuliert. Das ergibt bei einer Auflösung von 2mm ganzzahlige Schritte, wie es auch die Hardware (Inkrementalgeber mit nachfolgendem Zähler) in Wirklichkeit macht.

[[Bild:Lageregelung.png]]

Nach dem Regler folgt ein Block mit der Verstärkung (5/255), der den PWM-Wert auf die Ansteuerspannung für den Motor umsetzt. Der Bruch 5/255 entspricht der Ansteuerspannung von 5V bei PWM=255. Der PD-Regler kann damit in Scicos exakt so simuliert werden, wie er schlussendlich auch als C-Code umgesetzt wird. Dazu wird der Code des PD-Reglers als Funktion in den Scifunc-Block eingegeben. Der Code ist etwas unterschiedlich zum C-Code des realen Bots, da die Syntax in Scicos doch geringfügig anders ist und die Eingangs- und Ausgangsvariablen nur bestimmte Bezeichnungen haben dürfen. Im nachfolgenden Codefenster sind beide Varianten im Vergleich zu sehen.
{|
| '''Scifunc-Code:'''
<pre>

y1=Kp*u1+Kd/Ta*(u1-z);
z=u1;
if y1>255 then
y1=255;
end
if y1<-255 then
y1=-255;
end
</pre>
| '''C-Code für µC:'''
<pre>
e = w - x;
y = Kp*e + Kd/Ta*(e-ealt);
ealt = e;
if (y > 255) {
y = 255;
}
if (y < -255) {
y = -255;
}
</pre>
| '''Kommentar:'''
<pre>
Vergleich
PD-Reglergleichung
alten Wert speichern

pos. Begrenzung

neg. Begrenzung

</pre>
|}

In der praktischen Umsetzung des C-Codes wird man den Bruch Kd/Ta durch eine Ersatzvariable oder Konstante ersetzen. Dabei ergibt sich (wie in diesem Beispiel 2/0.01 = 200) meistens ein ganzzahliger Wert, was sich positiv auf die Rechenzeit auswirkt.

Für die Abtastzeit Ta wurde 10ms gewählt. Das ist einerseits nicht zu schnell für einen µC und andererseits nicht zu lang, um die Regelung unnötig zu verlangsamen. Die Parametrierung von Kp und Kd erfolgte empirisch durch Probieren in der Simulation. Begonnen wurde mit einem reinen P-Regler und kleinem P-Anteil (Kp=1, Kd=0). In groben Schritten wurde Kp solange erhöht, bis sich deutlich Überschwinger zeigten. Dann wurde ein D-Anteil hinzugefügt und Kd so variiert, dass der Überschwinger verschwindet. Mit ein bisschen Feintuning ergaben sich so die Werte Kp=61 und Kd=2. Das Simulationsergebnis für Ansteuerspannung, Geschwindigkeit und Weg sieht damit folgendermaßen aus:

[[Bild:Lage_antwort.png]]

==Autoren==
* [[Benutzer:Waste|Waste]]

==Siehe auch==
* [[SwitcherCAD-Tutorial]]

== External links ==
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=11818 Post: Line follower with PID controller]
*[http://www.scicos.org/ Scicos Homepage]
* [http://www.scicoslab.org/ ScicosLab Homepage]
* [http://www.scilab.org/ Scilab Homepage]
* [http://ltspice.linear.com/software/swcadiii.exe LTspice / SwitcherCAD III Download]
* [http://www.kahlert.com/web set_download.php demo version of WinFACT 7]
* [http://www.physi.uni-heidelberg.de/fp/anleitg/E01.pdf instructions for electronic placement, the last part is based PID controller]
* [http://www.simapp.com/ SimApp website] with trial
* [http://www.expertcontrol.com/ ExpertControl Homepage, Automatische Reglerauslegung mit ecICP] ecICP-Trial über Support-Seite verfügbar
* [http://www.me.th-mittelhessen.de/personen/professoren/orlowski/simulation-regelungstechnik/ TH-Mittelhessen Prof. Peter F. Orlowski, Simulationsprogramm SIMLER-PC]

[[Category: Microcontroller]]
[[Category: Software]]
[[Category: Elektronik]]

Regelungstechnik

2014-09-13T08:18:20Z

SprinterSB: /* Vergleich der Reglertypen */ wikify

'''Regelungen''' sind ein Bestandteil unseres Lebens und das nicht nur seit Erfindung der Dampfmaschine.

Allein schon der aufrechte Gang funktioniert nur mit Regelung. Dabei wirken die Sinne als Sensoren, das Gehirn als Regler und die Muskeln als Aktuatoren. Weitere Regelungen in unserem Körper sind z.B. die Konstanthaltung der Körpertemperatur, der Blutdruck, die Anpassung der Pupille auf Helligkeitsänderungen usw.

Im technischen Zeitalter ist der erste geschichtlich bedeutende Regler der Fliehkraftregler von James Watt, der für die Drehzahlregelung seiner Dampfmaschine eingesetzt wurde. Seitdem ist die Regelungstechnik aus keinem Technikbereich mehr wegzudenken. Die Regelungstechnik begegnet uns im täglichen Leben auf Schritt und Tritt: Der Temperaturregler der Zentralheizung, der Temperaturregler des Kühlschranks, der Regler für die Belichtungsautomatik im Fotoapparat, das ABS-System im Auto und die Netzspannungs- und Frequenzregelung des europäischen Versorgungsnetzes sind nur einige wenige Beispiele aus diesem Bereich.

''Autor Waste''

==Einleitung==

Der Begriff ''Regelung'' ist zu unterscheiden von dem im allgemeinen Sprachgebrauch oft synonym gebrauchten Begriff der ''Steuerung''. Das Steuern ist ein rein vorwärts gerichteter Prozess ohne Rückkopplung. Die Ausgangsgröße wird dabei nicht überwacht und kann sich durch Störungen von außen verändern. Ein Beispiel ist die Steuerung eines Motors mit einer einstellbaren Spannung. Durch Laständerungen wird sich die Drehzahl des Motors ändern. Soll nun die Drehzahl konstant gehalten werden, bedarf es einer Rückkopplung um über die Spannung die Drehzahl anzupassen. Diese Rückkopplung ist das Kennzeichen einer Regelung.

Das Regeln ist ein Vorgang, bei dem die Ausgangsgröße, im Beispiel die Drehzahl, fortlaufend überwacht wird und bei Abweichung über die Stellgröße, im Beispiel die Spannung, korrigiert wird. Der sich dabei ergebende Wirkungsablauf findet in einem geschlossenen Kreis, dem Regelkreis, statt.

==Der Regelkreis==

[[Bild:Regelkreis1.png|right|thumb|300px|Ein Regelkreis (Prinzip)]]

Das Prinzip einer Regelung ist das fortlaufende: '''Messen – Vergleichen – Stellen'''

;Messen: Die Regelgröße wird direkt oder mittels Sensoren gemessen.
;Vergleichen: Der Wert der Regelgröße wird mit dem Sollwert verglichen. Die Differenz ist die ''Regelabweichung''.
;Stellen: Aus der Regelabweichung wird unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke die ''Stellgröße'' bestimmt.

{{Absatz}}

[[Bild:Regelkreis2.png|thumb|350px|Wirkunsweise einer Regelung]]

Ein Regelkreis dient dazu, eine vorgegebene physikalische Größe, die ''Regelgröße'', auf einen gewünschten Wert (Sollwert) zu bringen und dort zu halten, unabhängig von eventuell auftretenden Störungen.
Um die Regelungsaufgabe zu erfüllen, muss der Augenblickswert der Regelgröße – der Istwert – gemessen und mit dem Sollwert verglichen werden. Bei auftretenden Abweichungen muss in geeigneter Art und Weise nachgestellt werden.

Um nun diese Aufgabe technisch zu lösen, gibt es die Regelungstechnik. Sie baut im wesentlichen auf die mathematische Beschreibung und Modellbildung des Systems Regelkreis. Zur Modellierung, Beschreibung und Simulation werden Blockschaltbilder mit diskreten Signalgliedern verwendet.

{{Absatz}}

[[Bild:Regelkreis3.png|thumb|350px|Beispiel einer Geschwindigkeitsregelung]]

Ein typisches Beispiel für einen Regelkreis – eine Geschwindigkeitsregelung – wird im nebenstehenden Bild gezeigt. Die Sollgeschwindigkeit ist 80 km/h. Durch eine äußere Störung, in dem Fall eine Steigung, verlangsamt sich das Fahrzeug auf 70 km/h. Die Abweichung wird durch das Tachometer erfasst. Als Korrekturmaßnahme wird mehr Gas gegeben, um wieder auf die Sollgeschwindigkeit von 80 km/h zu kommen.

{{Absatz}}

=== Begriffe ===

[[Bild:Regelkreis4.png|right]]

Ein Regelkreis besteht entsprechend des vereinfachten Blockschaltbildes, wie es oft in der Regelungstechnik verwendet wird, aus den Hauptteilen ''Regler'' und ''Regelstrecke'':

;Regler: Ist der Teil des Regelkreises, der unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke aus der Regelabweichung die Korrekturmaßnahmen zum Ausregeln ergreift.

;Regelstrecke: Ist der Teil des Regelkreises, der vom Regler ausgeregelt werden soll.

;Führungsgröße (Sollwert) w: Vorgegebener Wert, auf dem die Regelgröße durch die Regelung gehalten werden soll. Sie ist eine von der Regelung nicht beeinflusste Größe und wird von außen zugeführt.

;Regelgröße (Istwert) x: Ist die Ausgangsgröße der Regelstrecke, die zum Zweck des Regelns erfasst und zum Vergleich rückgeführt wird. In vielen Fällen ist in der Rückführung noch eine Messeinrichtung (Sensor) gezeichnet, die den Istwert erfasst, hier der Einfachheit halber weggelassen.

;Regelabweichung e: Differenz zwischen Führungsgröße und Regelgröße '''e = w – x''', bildet die eigentliche Eingangsgröße des Reglers.

;Stellgröße y: Ausgangsgröße der Regeleinrichtung und zugleich Eingangsgröße der Strecke. Sie überträgt die steuernde Wirkung des Reglers auf die Strecke.

;Störgröße z: Eine von außen wirkende Größe, die eine Änderung des Istwertes der Regelgröße bewirkt und einen Regelvorgang auslöst.

==Die Regelstrecke==
Die Regelstrecke stellt den zu regelnden Teil bzw. den zu regelnden Prozess dar und umfasst normalerweise eine Reihe von einzelnen Gliedern. Die Glieder werden entsprechend ihrem Zeitverhalten charakterisiert. Um das Zeitverhalten herauszufinden, legt man an den Eingang ein Testsignal an und zeichnet die Antwort auf. Im einfachsten Fall wird der Eingang mit einer sprunghaften Änderung beaufschlagt. Die Antwort auf die sprunghafte Änderung der Eingangsgröße wird Sprungantwort genannt und gibt Aufschluss über die Art der Regelstrecke und kann eventuell bereits genutzt werden, um die Parameter der Regelstrecke zu bestimmen.

Für den Aufbau eines gut funktionierenden Regelkreises und die Auslegung von Reglern ist es eine Voraussetzung zu wissen, wie die Regelstrecke reagiert. Ohne ein genaues Wissen um das dynamische Verhalten der Regelstrecke ist es nicht möglich geeignete Regler auszuwählen und diese zu parametrieren.

Die wichtigsten dynamischen Grundelemente zur Charakterisierung der Regelstrecke sind nachfolgend aufgelistet. Jedes Element wird mit einem Block dargestellt und darin durch ein Symbol oder der stilisierten Sprungantwort gekennzeichnet.

----

===Proportionalglied (P-Glied)===
[[File:pglied.gif]]

Die einfachste Art einer Regelstrecke.
;Beispiele: Hebel, Getriebe, Verstärker, Spannungsteiler, Sensoren bei denen das Zeitverhalten vernachlässigt werden kann

----

===Integrator (I-Glied)===
[[File:iglied.gif]]

Strecke ohne Ausgleich, ist häufig in Regelstrecken vorhanden.
;Beispiele: Beschleunigung → Geschwindigkeit → Weg, Strom → Kondensatorspannung

----

===Verzögerungsglied 0.Ordnung (Totzeitglied)===
[[File:ttglied.gif]]

Entsteht durch Laufzeiten von Material oder Signalen. Je größer die Verzögerungszeit einer Regelstrecke ist, um so schwieriger ist sie zu regeln.
;Beispiele: Förderband, Rechenzeit, A/D-Wandler

Nicht zu verwechseln mit der Totzeit, die durch das asynchrone Auftreten eines Ereignisses auf einen Zyklus entsteht. Vom Verzögerungsglied 0.Ordnung unterscheidet sich diese dadurch, daß sie mit einer gleichverteilten Wahrscheinlichkeit zwischen "gar nicht" und dem gesamten Umfang auftritt. Diese Totzeit ist mechanisch mit einem Spiel vergleichbar das "gar nicht" bis zum vollen Umfang zu einem Fehler beiträgt.
;Beispiele: Erkennen eines Signals an einem Mikroprozessor

----

===Verzögerungsglied 1.Ordnung (PT1-Glied)===
[[File:pt1glied.gif]]

Viele einfache Regelstrecken haben ein solches Verhalten bzw. können näherungsweise damit beschrieben werden. Ist ein P-Glied mit nicht vernachlässigbarem Zeitverhalten.
;Beispiele: Gleichstrommotor (Spannung → Drehzahl), näherungsweise; Widerstand-Kondensator-Schaltung (RC-Glied)

----

===Verzögerungsglied 2.Ordnung (PT2-Glied)===
Man unterscheidet schwingungsfähige und nicht schwingungsfähige PT2-Glieder. Zur Charakterisierung gibt es die Parameter Dämpfung D und Eckfrequenz w<sub>0</sub> oder die Zeitkonstanten T<sub>1</sub> und T<sub>2</sub>. Für Dämpfung D<1 ist es schwingungsfähig.

'''Schwingfähiges PT2-Glied:'''<br/>
[[File:pt2aglied.gif]]
;Beispiele: Mechanischer Schwinger (Feder-Masse-System), elektrischer Schwingkreis (RLC-Kreis)

'''Nicht schwingfähiges PT2-Glied:'''<br/>
[[File:pt2bglied.gif]]
;Beispiele: Zwei hintereinander geschaltete PT1-Glieder, Gleichstrommotor (Spannung → Drehzahl) mit berücksichtigter Induktivität

==Der Regler==
Der Regler hat die Aufgabe, die Regelgröße zu messen, sie mit dem Sollwert zu vergleichen und bei Abweichungen die Stellgröße so zu verändern, dass Soll- und Istwert der Regelgröße wieder übereinstimmen bzw. die Differenz minimal wird.

Die Wahl eines bestimmten Reglertyps richtet sich nach dem geforderten Zeitverhalten und der geforderten Regelgenauigkeit der Regelstrecke. Nachfolgend finden Sie eine Zusammenfassung der wichtigsten klassischen Reglertypen:

===P-Regler===
Der proportionalwirkende Regler multipliziert die Regelabweichung mit seinem Verstärkungsfaktor '''Kp''' und gibt das Ergebnis unverzögert weiter. Er unterscheidet sich prinzipiell nicht vom dynamischen Element P-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der P-geregelte Kreis ist einfach und mittelschnell im Vergleich zu anderen Regelungen. Das Problem ist die bleibende Regelabweichung!

[[File:pregler.gif]]

'''Software P-Regler:'''
y = Kp * e

----

===I-Regler===
Der integralwirkende Regler summiert die Regelabweichung über der Zeit auf und multipliziert die Summe (d.h. das Integral) mit dem Faktor '''Ki'''. Je länger eine Regelabweichung ansteht, desto größer wird die Stellgröße des I-Reglers. Er unterscheidet sich prinzipiell nicht vom dynamischen Element I-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der I-geregelte Kreis ist langsam im Vergleich zu anderen Regelungen. Er hat aber den Vorteil, dass die Abweichung vollständig eliminiert wird.

[[File:iregler.gif]]

'''Software I-Regler:'''
esum = esum + e
y = Ki * Ta * esum

'''esum''' ist die Summe aller bisherigen Abweichungen '''e'''. Der Parameter des Software I-Reglers ist abhängig von der Rechenschrittweite '''Ta''' (Abtastzeit). Je öfter gerechnet wird, desto öfter wird auch hinzugezählt (aufintegriert). Eine kleine Abtastzeit erfordert also einen kleineren Faktor, dies wird durch die Multiplikation mit '''Ta''' verwirklicht.

----

===PI-Regler===
Der PI-Regler ist die Kombination aus P- und I-Regler und kombiniert den Vorteil des P-Reglers, nämlich schnelle Reaktion, mit dem Vorteil des I-Reglers, der exakten Ausregelung. Der PI-geregelte Kreis ist also genau und mittelschnell.

[[File:piregler.gif]]

'''Software PI-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum

----

===PD-Regler===
Der proportional-differential wirkende Regler kombiniert den P-Regler mit einem D-Anteil.
Der D-Anteil bewertet die Änderung einer Regelabweichung (er differenziert) und berechnet so deren Änderungsgeschwindigkeit. Diese wird mit dem Faktor '''Kd''' multipliziert und zum P-Anteil hinzuaddiert. Der PD-Regler reagiert damit schon auf Ankündigungen von Veränderungen, das bewirkt sozusagen ein Vorhalten beim Regeln.

Der PD-geregelte Kreis ist sehr schnell im Vergleich zu anderen Regelungen, und manche Regelkreise (solche mit zweifacher Integration) sind ohne D-Anteil überhaupt nicht stabilisierbar. Das Problem der proportionalen Regler, die bleibende Regelabweichung, ist beim PD-Regler allerdings weiterhin vorhanden!

Ein Nachteil aller Regler mit D-Anteil kann die Unruhe im Kreis sein. Ist das Sensorsignal verrauscht, so wird dieses Rauschen durch die Differenziation weiter verstärkt und wieder in den Kreis hineingegeben. Dadurch wird der Aktuator stärker belastet. Macht der Regler insbesondere sehr hohe Ausschläge als Folge von schnellen Änderungen des Sollwertes, dann kann es sein, dass das Stellglied oder der Aktuator diese nicht umsetzen kann - die Wirkung des D-Anteils würde dann durch die Begrenzung verpuffen, und das Einschwingverhalten wäre nicht wie berechnet, sondern meist langsamer. Dies gilt aber nur für große Sprünge. Bei den normalen kleinen Regelvorgängen zum Ausgleich von Störeinflüssen wirkt der D-Anteil wie beabsichtigt.

[[File:pdregler.gif]]

'''Software PD-Regler:'''
y = Kp * e + Kd * (e – ealt)/Ta
ealt = e

Mit der neuesten Regelabweichung '''e''' und der vorhergehenden '''ealt''' wird der D-Anteil berechnet. Die Differenziation erfolgt damit angenähert durch Bildung des Differenzquotienten (e - ealt)/Ta.

----

===PID-Regler===
Der PID Regler ist der universellste der klassischen Regler und vereinigt die guten Eigenschaften der anderen Regler. Zur Beschreibung der Eigenschaften des P-, I- und D-Anteils siehe die anderen Reglertypen. Der PID-geregelte Kreis ist genau und sehr schnell. In den meisten Anwendungen kommt deshalb der PID-Regler zum Einsatz.

[[File:pidregler.gif]]

'''Software PID-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum + Kd * (e – ealt)/Ta
ealt = e

'''Alternative PID-Reglerstruktur:'''

Es gibt 2 Darstellungsmöglichkeiten, die inhaltlich identisch sind. In der analogen Regeltechnik ist noch die Darstellung mit der Nachstellzeit '''Tn''' und der Vorhaltezeit '''Tv''' üblich. Die Umrechnung zwischen den beiden Strukturen ist mit den angegebenen Formeln möglich.

[[Bild:PIDstruktur.gif]]

==Vergleich der Reglertypen==
In der folgenden Abbildung ist der Vergleich von P-, I-, PI-, PD- und PID-Regler in einem Regelkreis mit PT2-Glied als Regelstrecke dargestellt. Es ist deutlich zu sehen, dass die Regler ohne I-Anteil (P und PD) eine bleibende Regelabweichung aufweisen. Erst die Regler mit I-Anteil können auf den Endwert von 1 ausregeln. Beim reinen I-Regler geht das so langsam, dass es gar nicht mehr auf dem Diagramm zu sehen ist. Der Hauptzweck eines I-Anteils ist also die Vermeidung bleibender Regelabweichungen. Daher ist ein
I-Anteil normalerweise nicht nötig, wenn die Strecke schon einen I-Anteil besitzt.
Ausnahme: Es wird ein doppelter I-Anteil zur Vermeidung von Schleppfehlern benötigt.

Die schnellsten Regler sind die mit einem D-Anteil (PD und PID). Der D-Anteil kommt deshalb hauptsächlich zum Einsatz, wenn schnelle Dynamik gefragt ist oder die Strecke selbst schon instabil ist. Voraussetzung für die Schnelligkeit ist allerdings, dass keine Begrenzung im Stellglied oder Aktuator auftritt. In der Praxis ist eine Begrenzung meistens nicht zu vermeiden, deshalb gilt die Sprungantwort in der Praxis nur für kleine Sprünge.

Die Regler ohne D-Anteil, aber mit P-Anteil (P und PI) sind mittelschnell. Für einfache Regelaufgaben reicht auch oft schon ein reiner P-Regler aus, wenn die bleibende Regelabweichung vernachlässigt werden kann oder weil die Strecke schon einen I-Anteil besitzt.

[[File:reglervergleich.gif]]

Aus diesem Vergleich wird klar, warum der PID-Regler so beliebt ist, er vereinigt die Vorzüge aller anderen Regler.

==Digitaler Regler==
Durch die Einführung leistungsfähiger und preiswerter Mikroprozessoren hat sich der digitale Regler mehr und mehr durchgesetzt. Im Gegensatz zum analogen Regler werden die Signale nicht mehr analog mit Operationsverstärker verarbeitet, sondern mit einem Mikroprozessor errechnet. Bevor das Signal vom Mikroprozessor bearbeitet werden kann, muss zunächst das Eingangssignal (Istwert) mit einem Analog-Digital-Umsetzer (ADU) digitalisiert werden, d.h. in einen Zahlenwert umgewandelt werden. Das vom digitalen Regler errechnete Ausgangssignal (Stellgröße) wird wiederum zur Ansteuerung des Stellglieds mit einem Digital-Analog-Umsetzer (DAU) in ein analoges Signal gewandelt. Funktionell unterscheiden sich analoger und digitaler Regler jedoch nicht wesentlich, es müssen nur die Schnittstellen angepasst werden.

[[File:digreg.gif|right|framed|Digitaler Regler (Prinzip)]]

Da die Wandlungen und das Regelprogramm eine gewisse Zeit beanspruchen, vergeht pro Durchlauf die sogenannte Takt- oder Abtastzeit. Diese Zeit wirkt sich im Regelkreis wie ein Totzeitglied mit der halben Abtastzeit als Totzeit aus. Das verursacht eine zusätzliche Phasenverschiebung, was sich ungünstig auf die Stabilität des Regelkreises auswirken kann. Ist die Abtastzeit sehr viel kleiner als die dominierende Zeitkonstante der Strecke, dann spricht man von quasi-kontinuierlichem Verhalten, da sich der digitale Regler ähnlich wie ein analoger Regler verhält. Der digitale Regler kann dann wie ein analoger dimensioniert werden. Ist die Abtastzeit größer, kann sie nicht mehr vernachlässigt werden, dann muss sie auch beim Reglerentwurf berücksichtigt werden.

'''Vorteile digitaler Regler:'''
* Die Verarbeitung erfolgt driftfrei.
* Es lassen sich nichtlineare Kennlinien, intelligentes Verhalten oder adaptive Regelung leichter realisieren.
* Der Regler kann bei Bedarf per Software neu konfiguriert und parametriert werden

'''Digitale Realisierung am Beispiel des PID-Algorithmus'''

Ausgehend von der Differentialgleichung für kontinuierliche Systeme wird die Differenzengleichung für zeitdiskrete Systeme erstellt. Daraus folgt dann der Stellungsalgorithmus in allgemeiner Form.

Ta = Abtastzeit; k = Nummer der Abtastung

Kp = Proportionalbeiwert; Ki = Integrierbeiwert; Kd = Differenzierbeiwert



'''Differentialgleichung für den kontinuierlichen PID-Regler:'''
:<math>
y(t) \;=\; Kp \!\cdot\! e(t)
+ Ki \int_0^t e(\tau) \, d\tau
+ Kd \, \frac{de(t)}{dt}
</math>

'''Differenzengleichung für den zeitdiskreten PID-Regler:'''
:<math>
y_k \;=\; Kp \!\cdot\! e_k
+ Ki \!\cdot\! Ta \sum_{i=0}^k e_i
+ \frac{Kd}{Ta}\, ( e_k - e_{k-1} )
</math>

'''PID Stellungs-Algorithmus:
:''' <math>
y_k \;=\; y_{k-1}
+ q_0 \!\cdot\! e_k
+ q_1 \!\cdot\! e_{k-1}
+ q_2 \!\cdot\! e_{k-2}
</math>

Mit den Parametern:
:<math>
q_0 \,=\, Kp + Ki \!\cdot\! Ta + \frac{Kd}{Ta}
\, , \quad
q_1 \,=\, -Kp - 2 \, \frac{Kd}{Ta}
\, , \quad
q_2 \,=\, \frac{Kd}{Ta}
</math>

'''Umsetzung in Code nach der Differenzengleichung:'''

Im Code wurden einige Variablen umbenannt, da die Indexschreibweise nicht möglich ist.

y entspricht y<sub>k</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, esum ist die Summenbildung

In der Praxis wird man die Ausdrücke Ki*Ta und Kd/Ta vorab berechnen und mit Ersatzvariablen in die Reglergleichung einsetzen. Der Verständlichkeit halber wurde es hier im Code belassen. Des weiteren kann eine Begrenzung von esum notwendig werden, um einen Variablenüberlauf oder Windup-Effekt zu vermeiden.

Der nachfolgende Code wird im Rhythmus der Abtastzeit Ta immer wieder aufgerufen.
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
y = Kp*e + Ki*Ta*esum + Kd/Ta*(e – ealt); //Reglergleichung
ealt = e;
----

'''Alternative Umsetzung in Code nach dem Stellungsalgorithmus:'''<br/>
y entspricht y<sub>k</sub>, yalt entspricht y<sub>k-1</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, ealt2 entspricht e<sub>k-2</sub>
e = w - x; //Vergleich
y = yalt + q0*e + q1*ealt + q2*ealt2; //Reglergleichung
ealt2 = ealt;
ealt = e;
yalt = y;

==Dimensionierung des Reglers==
Die Auswahl des Reglertyps ist heutzutage bei den digitalen Reglern nicht mehr so kritisch, da der Mehraufwand in Software für einen PID-Regler gegenüber einfacheren Typen kaum zu Buche schlägt. Im Prinzip ist man deshalb mit einem PID-Regler fast immer auf der richtigen Seite, mit einer Ausnahme, bei einer Strecke mit reiner Totzeit. Die folgende Tabelle gibt eine Hilfestellung zur Auswahl des Reglers.

{| border=1 cellpadding=4
|+ '''Geeignete Reglertypen für die unterschiedlichen Regelstrecken'''
|rowspan=2 |'''Strecke'''
|colspan=4 |<div align="center">'''Regler'''</div>
|-
|<div align="center">'''P'''</div>
|<div align="center">'''PD'''</div>
|<div align="center">'''PI'''</div>
|<div align="center">'''PID'''</div>
|-
|reine Totzeit
| 
| 
|<div align="center">geeignet</div>
| 
|-
|1.Ordnung mit kleiner Totzeit
| 
| 
|gut geeignet
|gut geeignet
|-
|2.Ordnung mit kleiner Totzeit
| 
| 
| 
|gut geeignet
|-
|höhere Ordnung
| 
| 
| 
|gut geeignet
|-
|I-Glied und Verzögerung
|geeignet
|gut geeignet
|<div align="center">geeignet</div>
|gut geeignet
|}

Nachdem man einen geeigneten Reglertyp ausgewählt hat, stellt sich noch die Frage, wie man die Reglerparameter Kp, Ki, und Kd optimiert. Im Laufe der Zeit wurden viele Methoden zur Dimensionierung der Reglerparameter entwickelt, aber es können hier nicht alle aufgelistet werden. Diese Aufzählung beschränkt sich auf die einfacheren und gängigen Methoden der Parametrierung.

===Dimensionierung durch Probieren (Empirisches Einstellen)===

====Methode 1====
Diese Methode ist geeignet um einfache Systeme zu dimensionieren, insbesondere wenn man bereits Erfahrung mit ähnlichen Regelkreisen hat. Man fängt mit einer unkritischen Einstellung (Kp klein, Ki = 0, Kd = 0) an und erhöht langsam die Verstärkung Kp, bis die Dämpfung schlecht wird. Falls eine Schwingneigung auftritt, muss die Verstärkung wieder etwas zurück genommen werden. Dann nimmt man allmählich den Integralanteil hinzu, erhöht ihn in Schritten und probiert solange herum, bis das Ergebnis einigermaßen passt. Bei Bedarf kann noch ein D-Anteil (PID-Struktur) probiert werden. Wenn dabei die Regelung stabiler wird, kann noch mal Kp und Ki erhöht werden, bis man endgültig zufrieden ist.

====Methode 2====
Alle Anteile erstmal auf 0. Dann erhöht man Kp so lange bis das System deutlich schwingt. Danach wird der Kd so lange erhöht bis das System nicht mehr schwingt. Anschliessend kann noch ein kleiner Ki Anteil hinzugegeben werden.

Es dürfte klar sein, dass so eine Optimierung im Blindflug nicht immer das Optimum ergibt, aber es ist eine gängige praktische Methode zur Ermittlung der Reglerparameter. Besser sieht es aus, wenn in einer Simulation empirisch optimiert wird. Zusätzliche Informationen über die Stabilität erlauben hierbei eine gezieltere Optimierung. Zudem ist das Probieren im Simulator gefahrlos möglich, was in der Realität nicht immer der Fall ist. Geeignete Programme zur Simulation sind [[Regelungstechnik#Hilfsprogramme_zur_Analyse_und_Optimierung| hier]] vorgestellt. Allerdings muss für eine Simulation die Regelstrecke bekannt sein. Ist das nicht der Fall, so bleibt nur das einfache Probieren oder das Einstellen nach der Schwingungsmethode wie im folgenden beschrieben.

===Dimensionierung nach Einstellregeln===
Die Dimensionierung nach Rezept ist eine praktische Methode ohne viel Rechnerei und Hilfsmittel, eine Methode also für den Praktiker. Die bekanntesten Einstellregeln sind von Ziegler/Nichols und von Chien/Hrones/Reswick. Darüber hinaus gibt es noch eine Vielzahl anderer Einstelltabellen, auf die hier aber verzichtet wird, das würde den Rahmen dieses Artikels sprengen. An der Vielzahl kann man schon ersehen, dass es kein universell gültiges Rezept gibt und mit diesen Tabellen nicht unbedingt das Optimum erreicht wird, eine Nachoptimierung kann nötig sein.

Bei Ziegler/Nichols unterscheidet man noch zwischen der Schwingungsmethode und der Einstellung nach der Sprungantwort.

'''Einstellung nach der Schwingungsmethode:'''<br/>
Bei der Schwingungsmethode nach Ziegler/Nichols werden die Reglerparameter so verstellt, dass die Stabilitätsgrenze erreicht wird und der Regelkreis zu schwingen beginnt, d.h. die Regelgröße periodische Schwingungen ausführt. Aus der so gefundenen Einstellung können die Reglerparameter ermittelt werden. Dieses Verfahren ist nur auf Regelstrecken anwendbar, bei denen ein Schwingen keinen Schaden anrichtet und die überhaupt instabil gemacht werden können. Die Vorgehensweise ist folgende:
# Einstellung des Reglers als reinen P-Regler: Ki = 0 und Kd = 0
# Die Reglerverstärkung Kp wird solange vergrößert, bis sich der geschlossene Regelkreis an der Stabilitätsgrenze befindet und Dauerschwingungen ausführt.
# Der dabei eingestellte Wert Kp wird als Kp<sub>krit</sub> bezeichnet.
# Die Periodendauer der sich einstellenden Dauerschwingung T<sub>krit</sub> wird gemessen.
# Anhand der folgenden Tabelle werden dann die Reglerparameter bestimmt.

{| cellpadding=10
|
{| border=1 cellpadding=4
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|0.5*Kp<sub>krit</sub>
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.45*Kp<sub>krit</sub>
|<div align="center">0.85*T<sub>krit</sub></div>
| 
|-
|<div align="center">'''PID'''</div>
|0.6*Kp<sub>krit</sub>
|0.5*T<sub>krit</sub>
|0.12*T<sub>krit</sub>
|}
|
{| border=0 cellpadding=4
|'''Ki = Kp/Tn'''
|-
|'''Kd = Kp*Tv'''
|}
|}

Der Vorteil dieses Verfahrens liegt darin, dass die Untersuchung während des Betriebes und ohne Öffnen des Regelkreises durchgeführt werden kann. Der Nachteil an dem Verfahren ist, dass es nur auf Strecken angewendet werden kann, die auch zum Schwingen gebracht werden können.

'''Einstellung nach der Sprungantwort:'''<br/>
Diese Methode der Parameterbestimmung beruht auf der Aufnahme der Sprungantwort der Regelstrecke. Es eignet sich auch für Strecken, die nicht zum Schwingen gebracht werden können. Der Regelkreis muss allerdings geöffnet werden.
Vorgehensweise: Es wird die Sprungantwort aufgenommen und durch Einzeichnen der Wendetangente die Verzugszeit Tu und die Ausgleichszeit Tg ermittelt.

[[Bild:Tu_Tg.gif]]

Mit den so festgestellten Werten werden die Parameter für den einzusetzenden Regler gemäß nachstehenden Tabellen ermittelt.

{| cellpadding=10
|
{| border=1 cellpadding=4
|+ Einstellregeln nach Ziegler/Nichols:
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|1/Ks*Tg/Tu
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.9/Ks*Tg/Tu
|3.3*Tu
| 
|-
|<div align="center">'''PID'''</div>
|1.2/Ks*Tg/Tu
|2*Tu
|0.5*Tu
|}
|
|
{| border=1 cellpadding=4
|+ Einstellregeln nach Chien/Hrones/Reswick
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|0.3/Ks*Tg/Tu
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.35/Ks*Tg/Tu
|1.2*Tg
| 
|-
|<div align="center">'''PID'''</div>
|0.6/Ks*Tg/Tu
|<div align="center">Tg</div>
|0.5*Tu
|}
|}

{| cellpadding=10
|
{| border=1 cellpadding=4
|'''Ki = Kp/Tn'''
|-
|'''Kd = Kp*Tv'''
|}
|
{| cellpadding=4 width=420
|Die Parameter Tn und Tv sind aus der analogen Regelungstechnik und sind dort sehr geläufig. Die Umrechnung in die Parameter Ki und Kd erfolgt mit nebenstehenden Formeln. Siehe auch [[Regelungstechnik#PID-Regler| PID-Regler]]
|}
|}

===Dimensionierung mit dem Bodediagramm===
Ein Bode-Diagramm ist die grafische Darstellung des Frequenzganges. Es werden der Betrag der Übertragungsfunktion (Amplitudengang) und der Verlauf des Phasenwinkels (Phasengang) als Funktion der Frequenz aufgetragen. Die Frequenzachse und die Amplitudenachse werden logarithmisch dargestellt. Die logarithmische Darstellung hat den Vorteil, dass eine Multiplikation auf eine einfache Addition zurückgeführt wird. Somit wird eine Hintereinanderschaltung von Systemen im Blockschaltbild zu einer einfachen Addition im Bodediagramm.

Das Zeitverhalten des rückgekoppelten Regelkreises hängt entscheidend vom Verlauf
des Frequenzganges der offenen Regelschleife in der Umgebung des Durchtretens durch
die 0dB-Achse ab. In der Regelungstechnik wird daher der offene Regelkreis im Bode-Diagramm aufgetragen. Das erlaubt einen schnellen Überblick über Stabilität und möglichen Reserven zur Optimierung. Ein Kriterium für die Stabilität der Schleife ist der Phasenrand und der Amplitudenrand. Der Phasenrand ist der Abstand (Phasenreserve) zur -180°-Linie bei der Durchtrittsfrequenz. Die Durchtrittsfrequenz ist diejenige Frequenz, bei der der Amplitudengang durch die 0dB-Linie geht. Siehe auch folgendes Bode-Diagramm.

[[Bild:Phasenrand.gif]]

{| {{Blauetabelle}}
|'''Regel:''' Eine geschlossene Regelschleife arbeitet genau dann stabil, wenn der Phasenrand positiv ist.
|}
Wird diese Bedingung verletzt, so wird in diesem Frequenzbereich die im Rückführzweig der Regelung eingebrachte Gegenkopplung zu einer Mitkopplung und das System kann schwingen.

'''Beim Reglerentwurf sind folgende Punkte zu beachten:'''
* Der Phasenrand muss positiv sein. Der geschlossene Regelkreis kann sonst instabil sein.
* Je größer der Phasenrand ist, desto größer ist die Stabilitätsreserve des Regelkreises und desto höher ist die Dämpfung des Regelkreises. Üblich sind Werte von 40°...70° für gutes Führungsverhalten und 20°...50° für gutes Störverhalten.
* Die Durchtrittsfrequenz ist ein Maß für die Schnelligkeit des Regelkreises, je höher, desto schneller ist die Reaktion auf Änderungen der Führungsgröße oder Störungen.

Hier ein Beispiel zur Dimensionierung mit dem Bode-Diagramm.

[[Bild:Bode1.gif]]

Die Strecke ist rot dargestellt und besteht in dem Beispiel aus einem nicht schwingfähigem PT2-Glied. Man sucht sich den Punkt, wo die Strecke für sich alleine noch ausreichend Phasenreserve hat, z.B. 70°. In dem Beispiel also die Frequenz, bei der die Strecke -110° Phasendrehung aufweist. Das ist etwa bei 15Hz. Da hat die Strecke ungefähr eine Dämpfung von 25dB. Wenn man nun diese Dämpfung durch eine Verstärkung von 25dB kompensiert, dann wird dieser Punkt zur Durchtrittsfrequenz. D.h. man wählt den P-Anteil des Reglers Kp=18, denn 25dB entspricht ungefähr dem Faktor 18. Um die Regelabweichung zu minimieren, wird noch ein I-Anteil hinzugefügt. Üblicherweise wählt man für die Grenzfrequenz des PI-Reglers die Grenzfrequenz des dominierenden Streckenteils, in dem Beispiel ca. 1.4Hz. Damit ergibt sich ein I-Anteil von 170. Im Bode-Diagramm ist der PI-Regler als schwarze Kurve eingezeichnet. Die Addition der Strecke und des Reglers im Bode-Diagramm führt dann zum Frequenzgang des offenen Regelkreises (blaue Kurve). Die resultierende Durchtrittsfrequenz ist wie gewählt bei etwa 15Hz. Der Phasenrand hat sich durch den I-Anteil im Regler auf ca. 60° reduziert, ist aber noch ausreichend. Das Einschwingen des geschlossenen Regelkreises für diese Dimensionierung sieht dann folgendermaßen aus:

[[Bild:Sprungantwort3.gif]]

Bei Bedarf könnte noch ein D-Anteil (PID-Regler) hinzugenommen werden, das würde die Phase anheben und man könnte dadurch die Durchtrittsfrequenz weiter nach oben schieben. In der Praxis wird dies allerdings wegen der wahrscheinlichen Begrenzung des Stellglieds kein schnelleres Einschwingen mehr bringen.

Begrenzungen oder Nichtlinearitäten werden bei der Dimensionierung mit dem Bode-Diagramm nicht berücksichtigt. Das ist ein Nachteil dieser Methode. Eventuell muss deshalb noch einmal im Zeitbereich nachoptimiert werden.

===Dimensionierung mit der Ortskurve===
Eine Alternative zur Dimensionierung mit dem Bodediagramm stellt die Methode über die Ortskurve des offenen Regelkreises dar.

Bei diesem Verfahren ist schnell auf einem Blick ersichtlich ob der Regelkreis stabil ist.

Liegt der Punkt -1 auf der Realteilachse links von der Ortskurve in Richtung steigendem Omega so ist der Regelkreis stabil.
Der Abstand zu der kritischen Kreisfrequenz Omega Krit von der Imaginärteilachse ist die Verstärkung Vr mit diesem Wert lässt sich der Amplitudenrand ermitteln.
Dazu wird folgende Formel verwendet: Ar = 20 lg (1/Vr) in dB

Die Durchtrittskreisfrequenz Omega D ist an dem Punkt, wo der Betrag aus Realteil und Imaginärteil 1 ergibt. Wenn man weiß, wo die Durchtrittskreisfrequenz ist, dann kann man den Phasenrand bestimmen.
Dies ist der Winkel zwischen der -180° Linie zu Omega D.

[[Bild:Ortskurve.jpg]]

==Hilfsprogramme zur Analyse und Optimierung==
Die Analyse und Optimierung von Regelkreisen wird wesentlich erleichtert durch die Zuhilfenahme von Programmen. Es erspart einem eine komplizierte Rechnerei von Hand oder umfangreiche Testläufe. Stellvertretend für all die verfügbaren Programme werden hier zwei Freeware-Programme vorgestellt, die dafür gut geeignet sind. Die Beschreibung hier ersetzt aber keine Tutorials, es wird nur die Anwendung für die Regelungstechnik beschrieben.

===Scilab/Scicos===
Scilab ist ein wissenschaftlich-technisches Softwarepaket für numerische Berechnungen. Scicos ist eine Erweiterung dazu, die eine blockorientierte und modellbasierte Simulation und Analyse von dynamischen Systemen bietet. Dieses Softwarepaket kann von der [http://www.scilab.org/ Scilab Homepage] herunter geladen werden.

====Scilab====
Mit Scilab ist es sehr einfach ein Bode-Diagramm zu zeichnen, es bedarf nur 3 Zeilen Code.
s=poly(0,'s');
G=syslin('c',0.72/(0.11*s+1));
bode(G)
Die 1.Zeile '''s=poly(0,'s');''' legt die Variable s als Polynomvariable fest. Dies braucht in einer Sitzung nur einmal gemacht zu werden. Die 2.Zeile '''G=syslin('c',0.72/(0.11*s+1));''' definiert ein lineares System mit der Übertragungsfunktion 0.72/(0.11s+1). Die 3.Zeile '''bode(G)''' zeichnet das Bode-Diagramm des zuvor mit syslin definierten Systems G. Zu beachten ist, dass Scilab auf der x-Achse im Bode-Diagramm die Frequenz in Hertz und nicht wie üblich die Kreisfrequenz darstellt. Anstelle des Bode-Diagramms kann auch die Sprungantwort gezeichnet werden. Dies geschieht mit folgenden Befehlen:
xbasc();
t=[0:0.001:2];
y=csim('step',t,G);
plot2d(t,y)
'''xbasc()''' löscht den letzten Plot mit dem Bode-Diagramm und mit '''t=[0:0.001:2]''' wird ein Vektor t mit den angegebenen Zeiten im Intervall von 1ms definiert. Die Zeile '''y=csim('step',t,G)''' berechnet die Sprungantwort des zuvor mit syslin definierten Systems G und speichert sie in y ab. Das Ergebnis wird dann mit '''plot2d(t,y)''' dargestellt. Bei Bedarf können noch Gitternetzlinien mit dem Befehl '''xgrid()''' hinzugefügt werden.

Ergänzend hier noch ein Scilab-Skript, welches recht hilfreich bei der Dimensionierung mit dem Bode-Diagramm ist. Den nachfolgenden Code einfach in das SciPad-Fenster (Editor von Scilab) kopieren und starten. Es werden 2 Grafikfenster angezeigt, eines mit dem Bode-Diagramm und ein zweites mit der Sprungantwort. Man kann im Skript die Streckencharakteristik anpassen und verschiedene Reglerparameter ausprobieren.

<pre>
Ks=0.72; // Verstärkung der Strecke
T1=0.11; // Zeitkonstante 1
T2=0.005; // Zeitkonstante 2
Kp=18; // Proportionalbeiwert
Ki=170; // Integralbeiwert
Kd=0; // Differenzialbeiwert

s=poly(0,'s'); // definiert s als Polynomvariable
P=(T1*s+1)*(T2*s+1); // Streckencharakteristik
Gs=syslin('c',Ks,P) // Übertragungsfunktion der Strecke

RZ=poly([Ki Kp Kd],'s','coeff') // Zählerpolynom des Reglers
RN=poly([0 1],'s','coeff') // Nennerpolynom des Reglers
Gr=syslin('c',RZ,RN) // Übertragungsfunktion des Reglers

G=Gr*Gs // Übertragungsfunktion gesamt
xset("window",0);
xbasc(0);
bode([Gr;G;Gs],0.1,100,['Regler';'gesamt';'Strecke'])

Gcl=G/(G+1) // geschlossene Regelschleife
t=0:0.001:0.2;
y=csim('step',t,Gcl); // berechnet Sprungantwort
xset("window",1);
xbasc(1);
plot2d(t,y,2);
xgrid();
xtitle("Sprungantwort","sec");
</pre>

====Scicos====
Eine weitere Möglichkeit zur Simulation im Zeitbereich bietet Scicos. Die Modellierung geschieht mit einem grafischen Editor, in dem Blöcke mit vordefinierten oder selbstgemachten Funktionen miteinander verbunden werden. Ein einfaches Modell eines Regelkreises mit PID-Regler sieht folgendermaßen aus:

[[Bild:Scicos_anaReg.gif]]

Der PID-Regler ist mit seinen 3 Zweigen (P, I und D) dargestellt. In den Verstärkerblöcken kann durch Ändern der Reglerparameter (KP, KI und KD) der Regler optimiert werden. Die Strecke ist in diesem Beispiel nur ein einzelner Block, in dem die Übertragungsfunktion eingegeben wird. Man kann die Strecke auch detaillierter mit einzelnen Funktionsblöcken darstellen. Ein Beispiel eines komplexen Blockschaltbilds für einen balancierenden Bot ist unter diesem [http://www.roboternetz.de/phpBB2/download.php?id=5082 Link] zu finden.

Der Vorteil der Simulation mit Scicos ist die Möglichkeit Nichtlinearitäten zu berücksichtigen und die Kombination von kontinuierlichen und diskreten Funktionen. Das heißt, man kann einen digitalen Regler mit seinen diskreten Schritten und eine analoge Strecke, als kontinuierliche Funktion eingegeben, zusammen simulieren. Scicos bietet sogar einen 'Scifunc'-Block, mit dem Rechenschritte des digitalen Reglers nachgebildet werden können. Damit wird sowohl das dynamische Verhalten, verursacht durch die Abtastzeit Ta, als auch die etwas unterschiedliche Dynamik durch die digitale Ausführung eines I- und D-Anteils richtig simuliert. Ein Beispiel für den Einsatz des Scifunc-Blocks ist in folgendem Blockschaltbild zu sehen.

[[Bild:Scicos_digReg.png]]

Beispiel: [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlregelung]] mit digitalem Regler

Die globalen Variablen für die Reglerparameter und die Abtastzeit werden unter dem Menüpunkt „Edit - Context“ abgelegt.
Kp=18;
Ki=60;
Ta=0.01;
In den Taktgeber für den digitalen Regler wird als Clock-Periode die Abtastzeit Ta eingetragen. In das Dialogfenster zum Scifunc-Block wird folgender Code zur Simulation des digitalen PI-Reglers eingetragen:
<pre>
z=z+Ki*Ta*u1
if z>5 then
z=5;
end
y1=Kp*u1+z
if y1>5 then
y1=5;
end
</pre>
z entspricht der Variable esum vom Beispiel des [[Regelungstechnik#Realisierung_mit_digitalem_Regler| digitalen Drehzahlreglers]]; u1 ist die Eingangsvariable und y1 die Ausgangsvariable des Scifunc-Blocks.
In den Block für die Strecke wird die Übertragungsfunktion eingetragen. Als Zähler die Verstärkung Ks, also 0.72. Im Nenner das Polynom (1+0.11*s) für die Charakteristik der Strecke. Mit ‚Simulate – Run’ wird die Simulation gestartet. Als Ergebnis sollte das Einschwingen der Stellgröße (schwarz) und der Regelgröße (grün), wie in folgender Abbildung erscheinen.

[[Bild:Sprungantwort_DZR.png]]

Man kann nun mit den Reglerparametern und verschiedenen Abtastzeiten spielen, um zu sehen wie sich die Änderungen auswirken. Zum Beispiel wird bei einer Verdopplung der Abtastzeit der Regelkreis bereits instabil.

Diese Beispiele sind nur ein kurzer Auszug von den Möglichkeiten mit Scilab/Scicos für den Einsatz in der Regelungstechnik. Darüber hinaus ist es auch sehr gut geeignet bei anderen Optimierungsverfahren wie z.B. beim WOK-Verfahren (Wurzelortskurven) oder zur Analyse und Optimierung von modernen Reglern wie z.B. Zustandsregler und Kalmanfilter.

===LTspice/SwitcherCad III===
Dieses Programm ist ein SPICE-Derivat von der Firma Linear Technology und ist unter den 2 Namen LTspice und SwitcherCad III bekannt. Der Einfachheit halber wird für die weitere Beschreibung hier nur der Name LTspice verwendet. Das Programm ist Freeware und kann unter diesem Link herunter geladen werden. http://ltspice.linear.com/software/LTspiceIV.exe

LTspice ist ein Simulationsprogramm zur Analyse von elektronischen Schaltungen. Mit LTspice kann sowohl im Zeitbereich als auch im Frequenzbereich analysiert werden und bietet sich dadurch mit den entsprechenden Modellen auch für den Einsatz in der Regelungstechnik an. Wer sich bereits mit SPICE-Programmen auskennt, für den sollte es auch in der Regelungstechnik die 1.Wahl sein.

Der Vorteil von LTspice ist die Möglichkeit einer sehr detaillierten Analyse, vorausgesetzt die Modelle sind auch so detailliert nachgebildet. Insbesondere für analoge Regler, wo die elektrische Schaltung direkt umgesetzt werden kann, empfiehlt sich der Einsatz von LTspice. Der Nachteil ist, LTspice ist nicht auf regeltechnische Belange ausgelegt worden und spezifische Symbole für die Regelungstechnik müssen selbst erstellt werden. Einige selbst erstellte Symbole für dynamische Grundelemente in LTspice sind hier abgebildet.

[[Bild:LTSpiceSymb.png]]

Die 3 Symbole können [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=285 hier] heruntergeladen werden. Weitere Symbole können anhand dieser Beispiele sehr leicht selbst erstellt werden. Ein P-Glied kann durch eine spannungsgesteuerte Spannungsquelle (E-Source) oder Operationsverstärker mit einstellbarer Verstärkung dargestellt werden.

'''Analyse im Zeitbereich'''

Das Beispiel des [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlreglers]] mit analogem Regler wird hier mit LTspice simuliert. Das Schaltbild des Regelkreises zeigt nachfolgende Abbildung.

[[Bild:LTspice_TRAN.png]]

Der Vergleicher (U1) und der analoge PI-Regler (U2) sind so dargestellt, wie es auch in Wirklichkeit ausgeführt werden kann. Da der PI-Regler in der Schaltung bereits invertiert, wurden die Eingänge am Vergleicher vertauscht, damit die Polarität wieder stimmt. Der Rest des Regelkreises wurde stark vereinfacht, kann aber nach Bedarf auch ausführlicher dargestellt werden. Das PT1-Glied U3 simuliert die Strecke des Regelkreises und der Verstärker U4 dient nur zur Umrechnung auf die Drehzahl. Zur Simulation im Zeitbereich wird auf den Führungswert w mit der Spannungsquelle V1 ein Sprung gegeben. In der Reglerschaltung wurde bewusst ein Operationsverstärker mit Versorgungsspannung gewählt, damit auch der Einfluss einer Begrenzung mit simuliert wird. Die Zeitbereichsanalyse wird durch den LTspicebefehl .TRAN erreicht. Die Sprungantwort (Tachospannung) bei diesem Regelkreis sieht dann folgendermaßen aus.

[[Bild:Tacho2.png]]

Durch Ändern der Bauelemente R5, R6 und C1 kann man den Regler optimieren. Eine Umrechnung auf die Reglerparameter Kp und Ki ist mit folgenden Formeln möglich, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5

Ki = 1/(R5*C1)

Mit einem Mausklick auf den entsprechenden Knoten in der Schaltung können noch weitere Signale, wie z.B. die Stellgröße y angezeigt werden. Durch Verändern der Versorgungsspannung V3, V4 kann man sich auch die Auswirkung der Begrenzung ansehen.

'''Analyse im Frequenzbereich'''

Für die Darstellung des Bode-Diagramms der offenen Regelschleife in LTspice muss ein Trick angewendet werden, denn durch das Auftrennen der Regelschleife würde der Arbeitspunkt verloren gehen und dadurch die offene Schleife ohne Gegenkopplung an den Anschlag fahren.

Mit einer zusätzlichen Spannungsquelle in der Schleife kann man dieses Problem umgehen. Die Schleife bleibt für den Erhalt des Arbeitspunktes weiterhin geschlossen und man kann trotzdem die Verstärkung der offenen Schleife durch das Verhältnis der Spannung vor und hinter der Spannungsquelle bestimmen. Das erweiterte Blockschaltbild sieht folgendermaßen aus.

[[Bild:LTspice_AC.png]]

V2 ist die zusätzliche Spannungsquelle für die AC-Analyse. Die Spannungsquelle V1 wird von Pulsform auf Gleichspannung umgestellt. Sie wird so gewählt, dass sich der gewünschte Arbeitspunkt einstellt. Durch den LTspicebefehl .AC wird die Analyse im Frequenzbereich veranlasst. Um das Bode-Diagramm des offenen Regelkreises darzustellen, wird als Kurve nicht ein einzelner Knoten ausgewählt, sondern das Verhältnis der Spannung vom Ende zum Anfang des Regelkreises, in unserem Beispiel also V(tacho)/V(x). Zur Anzeige kommt dann das Bode-Diagramm (grüne Kurve) der offenen Schleife, wie in der folgenden Abbildung zu sehen. Für den Amplitudengang (durchgezogene Linien) gilt die linke Skala in dB, für den Phasengang (gestrichelte Linien) die rechte Skala in Grad.

[[Bild:LTspice_Bode.png]]

Zusätzlich ist noch das Bode-Diagramm der Strecke (rote Kurve) zu sehen. Dies ist durch einfaches Hinzufügen einer weiteren Kurve mit dem Ausdruck V(tacho)/V(y) durchgeführt worden.

Im Gegensatz zur üblichen Darstellung des Bode-Diagramms eines offenen Regelkreises, beinhaltet das mit LTspice erstellte Bode-Diagramm auch die -180 Grad Phasendrehung der Gegenkopplung. Der Phasenrand ist deshalb nicht auf -180 Grad sondern auf 0 Grad zu beziehen. In unserem Beispiel ist der Phasenrand etwa 90 Grad, also ein sehr stabiler Regelkreis. Zu beachten ist, dass die Frequenzachse des Bode-Diagramms wie auch schon bei Scilab in der Einheit Hertz anstatt wie üblich in der Kreisfrequenzeinheit rad/s dargestellt ist.

==Modellierung eines Motors/Antriebs==
[[Bild:ESB_Motor.png|thumb|320px|Ersatzschaltbild DC-Motor]]
Der Motor ist ein oft verwendeter Aktuator in der Robotik. Deshalb wird hier am Beispiel des Gleichstrommotors mit Permanentmagnet (Nebenschlussmotor) die Modellbildung gezeigt. Zur Modellierung gibt es mehrere Möglichkeiten. Je nachdem wie detailliert die Simulation sein soll, kann man sich ein Modell, von sehr einfach bis sehr detailliert, auswählen. Zwei Zeitkonstanten bestimmen die Dynamik eines Gleichstrommotors. Eine davon ist die mechanische Zeitkonstante, die ist meistens die dominierende Zeitkonstante und wird durch das Trägheitsmoment J des Rotors verursacht. Die zweite Zeitkonstante ist die elektrische Zeitkonstante, sie wird durch die Induktivität L bestimmt. Bei einfachen Regelungen kann in den meisten Fällen die elektrische Zeitkonstante vernachlässigt werden, damit reduziert sich das Modell auf ein einzelnes PT1-Glied.

'''Definition: Motor und Antrieb'''

Als '''Motor''' wird hier der Motor alleine verstanden. Die Ausgangsgröße ist die Winkelgeschwindigkeit w (Drehzahl).

Als '''Antrieb''' wird hier der komplette Antrieb eines Fahrzeugs verstanden, also Motor inklusive Getriebe und Masse des Fahrzeugs. Für die Dynamik ist nicht nur das Trägheitsmoment des Motors sondern auch die Masse des Fahrzeugs verantwortlich. Die Ausgangsgröße der Einheit „Antrieb“ ist die Geschwindigkeit v.

Die hier vorgestellten Modelle gelten sowohl für einen Motor als auch für einen kompletten Antrieb, wenn man die Elastizität und das Spiel des Getriebes vernachlässigt.

===Einfaches Modell mit PT1-Glied===
Die einfachste Art einen Motor oder Antrieb zu simulieren, ist mit einem PT1-Glied als Modell. Das Simulationsprogramm [[Regelungstechnik#Scicos|Scicos]] bietet dazu einen Block zur Eingabe der Übertragungsfunktion (num(s)=Zähler, den(s)=Nenner der Übertragungsfunktion).
{| border=0 cellpadding=10
|Übertragungsfunktion:

<math>G(s)=\frac{K}{1+Ts}</math>

|Beispiel:
num(s) = K = 0.72
den(s) = 1 + Ts = 1 + 0.11s
|[[Bild:Scicos_TF.png]]
|}

Wird nicht nur das Ausgangssignal, also die Geschwindigkeit oder Drehzahl in der Simulation benötigt, sondern auch die Beschleunigung, dann kann nachfolgendes Modell verwendet werden. Dieses Modell ist der Differentialgleichung eines PT1-Glieds nachempfunden und liefert das gleiche Ergebnis wie vorheriges Modell, bietet aber noch den Zugriff auf das Beschleunigungssignal.
{| border=0 cellpadding=10
|Differentialgleichung:

<math>v'=\frac{K}{T}U-\frac{1}{T}v</math>

|
v = Geschwindigkeit
v’= Beschleunigung (Ableitung von v)
K = Übertragungsmaß
T = Zeitkonstante
U = Eingangsgröße (z.B. Spannung)
|[[Bild:Antrieb_PT1.png|thumb|Einfaches Modell eines Antriebs]]
|}

Die beiden Parameter K und T müssen ausgemessen werden, wenn sie nicht bekannt sind. Die Zeitkonstante T kann in einem Anlaufversuch ermittelt werden. Dazu wird auf den Motor ein Spannungssprung gegeben und die Sprungantwort am Ausgang nachgemessen. Bei einem Antrieb erspart diese Methode die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente (Motor, Getriebe, Fahrzeug). Bei der Ermittlung des Übertragungsmaß K ist zu beachten, dass sich möglicherweise der Motor durch starke Reibung erst ab einer bestimmten Spannung dreht. Hier ist die Steigung der Kennlinie mit delta v / delta U auszuwerten, wie im folgenden Bild zu sehen ist.

[[Bild:Antrieb_stat.png]]

Die einfachen Modelle gelten nur für den linearen Teil der Kennlinie. Soll auch die Nichtlinearität durch Reibung modelliert werden, dann sind detailliertere Modelle, wie im Folgenden beschrieben, zu verwenden. Die Auswirkung einer Haftreibung ist auch in dem Geschwindigkeitsdiagramm durch die Hysterese in der Kennlinie zu sehen. Beim Hochfahren der Ansteuerspannung bewegt sich das Fahrzeug erst ab ca. 1.25V, während beim Herunterfahren der Ansteuerspannung das Fahrzeug noch bis 0.75V rollt und erst unter 0.75V stehen bleibt.

===Detailliertes Modell===

[[Bild:Motor_Model.png|thumb|350px|Detailliertes Motormodell]]
Ein detailliertes Motormodell ist rechts in dem Bild zu sehen. Es hat auf der linken Seite den elektrischen Teil mit den Parametern R (Widerstand) und L (Induktivität) und auf der rechten Seite den mechanischen Teil mit den Blöcken Trägheitsmoment und Reibung. Der elektrische Teil liefert das Stromsignal i, welches mit der Motorkonstante Km in das Drehmoment M umgerechnet wird. Mit dem folgenden Summierglied kann über einen zusätzlichen Eingang auch ein extern angreifendes Lastmoment mit simuliert werden. Am Ausgang des mechanischen Teils steht die Winkelgeschwindigkeit w in der Einheit [rad/s] bzw. über den Umrechnungsfaktor 9.55 die Drehzahl in [Upm] zur Verfügung. Die Reibung wird in einem nichtlinearen Block mittels Lookup-Table simuliert. In der einschlägigen Literatur wird die Reibung meistens mit einem Dämpfungsfaktor (linear) simuliert, was einer viskosen Reibung entspricht. Das passt aber nicht so gut für Kleinmotoren, da überwiegt vor allem die trockene Reibung. Die trockene Reibung hat ein konstantes Bremsmoment wenn sich der Motor dreht (unabhängig von Drehzahl, Vorzeichen abhängig von Drehrichtung). So eine Funktion kann sehr einfach mit einer Lookup-Table realisiert werden. Die Lookup-Table kann auch dazu verwendet werden, Mischformen von trockener, viskoser und turbulenter Reibung und sogar noch Haftreibung in einem Block zu simulieren, wenn man will.

Bei einigen Herstellern, wie z.B. Faulhaber und Maxon, kann man die für das Modell nötigen Parameter im Datenblatt finden. Das Bremsmoment der Reibung berechnet sich aus dem Leerlaufstrom wie folgt: Bremsmoment = Motorkonstante * Leerlaufstrom

Falls die Daten nicht verfügbar sind, muss man sie selbst ausmessen. Eine Hilfestellung zur Bestimmung der Motorkonstante und des Trägheitsmoments gibt es hier:
*http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=96750&highlight=#96750
*http://www.roboternetz.de/phpBB2/viewtopic.php?t=12793

[[Bild:Antrieb_Modell.png|thumb|350px|Modell eines Antriebs]]

Das detaillierte Motormodell kann auch für einen Antrieb verwendet werden, wenn man eine starre Kopplung zwischen Motor und Antriebsrad voraussetzt, also Elastizität und Spiel des Getriebes vernachlässigt. Anstelle der rotatorischen Kenngrößen (Drehmoment M, Trägheitsmoment J, Winkelgeschwindigkeit w) werden die translatorischen Kenngrößen (Kraft F, Masse m, Geschwindigkeit v) eingesetzt. Das Drehmoment wird mittels Getriebeübersetzung ü und Radius r des Antriebsrades in die entsprechende Vortriebskraft umgerechnet. Daraus ergibt sich die Kraftkonstante Kf, die für das Antriebsmodell verwendet wird.

Die Umrechnung ist: Kf = Km * ü/r

Bei der Trägheitsmasse m muss neben der Masse des Fahrzeugs auch das Trägheitsmoment des Motors mit berücksichtigt werden. Die Umrechnung von Trägheitsmoment in eine äquivalente Masse = J * (ü/r)²

Der Reibungsblock in diesem Modellbeispiel enthält eine Mischform aus Haftreibung, trockener und viskoser Reibung, wie sie typisch für einen Kleinbot mit 2 Antriebsrädern und einem Gleitpin ist.

==Beispiel: Drehzahlregelung==
Es wird ein Gleichstrommotor in der Drehzahl geregelt. Als Sensor ist ein Tachogenerator vorhanden, der direkt auf der Motorwelle sitzt. Das System ist in einem kleinen Modellfahrzeug eingebaut und wird zur Geschwindigkeitsregelung eingesetzt, da die Drehzahl proportional zur Geschwindigkeit ist.

Das Funktionsschaltbild sieht folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl1.gif

Als Störgröße können unterschiedliche Reibwerte oder Steigung und Gefälle rückwirkend über das Getriebe die Drehzahl beeinflussen. Das Getriebe und die Last sind zwar außerhalb der Regelschleife, beeinflussen aber durch die feste Kopplung des Getriebes die Dynamik des Regelkreises. Durch die starre Kopplung kann das Trägheitsmoment des Motors und die Masse des Fahrzeugs zusammengefasst werden. Das Gleiche gilt auch für die Reibwerte. Damit vereinfacht sich die Modellierung und das Blockschaltbild reduziert sich auf folgende Schaltung:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl2.gif

Zur Ermittlung des dynamischen Verhaltens der Regelstrecke wird die Sprungantwort gemessen. Dazu wird auf den Eingang der Regelstrecke (Stellglied) ein Spannungssprung gegeben und die Antwort am Ausgang des Tachogenerators nachgemessen. Diese Methode erspart die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente der Regelstrecke (Motor, Getriebe, Fahrzeug). Die Messung ergab folgende Sprungantwort der Regelstrecke:

http://www.roboternetz.de/wiki/uploads/Main/tacho.gif

Wie zu erwarten, ist die Sprungantwort annähernd ein Verzögerungsglied 1.Ordnung. Die abgelesene Zeitkonstante ist 0.11s. Die Verstärkung der Regelstrecke ist Ks = 0.72. Das Übertragungsmaß des Tachogenerators ist 1V pro 2480Upm. Damit kann auf die Drehzahl rückgerechnet werden.

Da die Regelstrecke nur aus einem PT1-Glied besteht, könnte eine analoge Regelung fast beliebig schnell gemacht werden. Wegen der Begrenzung bringt aber das Ausreizen der Optimierung für das Führungsverhalten nicht viel, nur für das Störverhalten wäre eine schnellere Regelung sinnvoll. Um aber einen Vergleich zwischen analogem und digitalem Regler anstellen zu können wird eine Parametrierung gewählt, die auch für den digitalen Regler mit seiner Totzeit noch stabil ist. Es wird deshalb auch auf einen D-Anteil im Regler verzichtet und nur ein PI-Regler realisiert. Das vereinfachte Blockschaltbild mit den dynamischen Elementen sieht damit folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl3.gif

Zur Veranschaulichung wurde ein analoger als auch ein digitaler Regler realisiert. Die Parametrierung des analogen Reglers wurde mit dem Programm [[Regelungstechnik#LTspice.2FSwitcherCad_III| LTspice]] durchgeführt. Es bot sich an, da die analoge Reglerschaltung exakt simuliert werden konnte. Für die Optimierung des digitalen Reglers wurde dann [[Regelungstechnik#Scicos| Scicos]] verwendet.

===Realisierung mit analogem Regler===
Die elektrische Schaltung für einen analogen PI-Regler ist in der nächsten Abbildung zu sehen. Der erste Operationsverstärker vergleicht den Sollwert w mit dem Istwert x. Der zweite Operationsverstärker bildet den PI-Regler. Die Werte R5, R6 und C1 sind für die Charakteristik des PI-Reglers zuständig. Mit R6 kann der P-Anteil und mit C1 der I-Anteil eingestellt werden. Die Optimierung der Werte wurde empirisch in einer Simulation mit LTspice durchgeführt. Da die Schaltung des PI-Reglers invertiert, wurden zum Ausgleich am Vergleicher die Eingänge an U1 vertauscht, so dass sich über die gesamte Schaltung wieder die richtige Polarität ergibt.

[[Bild:Analogregler.png]]

Zum Umrechnen auf Kp und Ki können diese Formeln verwendet werden, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5 = 18

Ki = 1/(R5*C1) = 147

===Realisierung mit digitalem Regler===
Im digitalen Regelkreis wird der Istwert '''x''' vom Tachogenerator mit einem A/D-Wandler digitalisiert. Der Sollwert '''w''' wird dem µC als digitaler Wert übergeben. Die Stellgröße '''y''' entspricht dem PWM-Wert für den Motortreiber. Um zum analogen Regler vergleichbar zu sein, wurde sowohl für den A/D-Wandler als auch für den PWM-Steller eine 8-Bit-Breite vorgesehen. Damit ist die Verstärkung in beiden Fällen gleich und analoger und digitaler Regler besser vergleichbar.

Eigentlich könnte man bei kleiner Abtastzeit direkt die Parametrierung des analogen Reglers für die digitale Realisierung übernehmen. Aber es gibt doch kleine Unterschiede in der Dynamik zwischen analoger und digitaler Ausführung und um sicher zu gehen, dass die gewählte Abtastzeit einen nicht zu großen Einfluss hat, wird noch einmal mit [[Regelungstechnik#Scicos| Scicos]] nachoptimiert. Mit einer Abtastzeit Ta = 10ms und den Parametern des analogen Reglers ergibt sich ein Überschwingen, das nur sehr langsam auf den Endwert abklingt. Durch Verringern des I-Anteils auf 60 wird ein optimales Einschwingen für den digitalen Regler erreicht. Die Parameter sind:

Kp = 18

Ki = 60

Ta = 0.01

Zur Umsetzung in einen Code wurde die Programmiersprache C gewählt. Da der Code sehr einfach ist, sollte es auch kein Problem sein, den Code als Beispiel für andere Sprachen zu verwenden. Der Algorithmus wird im Takt der Abtastzeit, also alle 10ms aufgerufen. In der Reglergleichung kann zur Vereinfachung das Produkt Ki*Ta durch eine Ersatzvariable, die gleich das Ergebnis aus dem Produkt 60*0.01 = 0.6 hat, ersetzt werden. Zum besseren Verständnis wurde es hier beim Ki*Ta belassen. Um einen Windup-Effekt zu verhindern, wird die Summenbildung esum auf +-400 begrenzt. Der Wert wurde so gewählt, dass noch eine volle Aussteuerung durch den I-Anteil möglich ist. Zum Schluss wird die Stellgröße y auf die mögliche Aussteuerung des Stellglieds (0...255) begrenzt.

'''Programmbeispiel digitaler PI-Regler:'''

<pre>
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
if (esum < -400) {esum = -400;} //Begrenzung I-Anteil
if (esum > 400) {esum = 400;}
y = Kp*e + Ki*Ta*esum; //Reglergleichung
if (y < 0) {y = 0;} //Begrenzung Stellgröße
if (y > 255) {y = 255;}
PWM = y; //Übergabe Stellgröße
</pre>

== Beispiel: Lageregelung ==
Unter einer Lageregelung versteht man die Positionierung von Objekten. Als Beispiel soll hier ein kleiner Bot mit Radencoder eine bestimmte Weglänge fahren. Gegenüber der Drehzahl- oder Geschwindigkeitsregelung ist bei der Lageregelung noch ein zusätzlicher Integrator in der Strecke vorhanden. Die gesamte Strecke ist damit ein I-Glied mit Verzögerung. Laut Tabelle im Abschnitt „Dimensionierung des Reglers“ ist dafür ein PD-Regler gut geeignet. Der PD-Regler wird digital ausgeführt, zur Simulation und Parametrierung bietet sich deshalb Scicos an.

Da bei einer Lageregelung der Geschwindigkeitsbereich von Null aus geht, also über den nichtlinearen Bereich geht, sollte auch in der Simulation die Nichtlinearität berücksichtigt sein. Für das Beispiel wird deshalb das Modell eines Antriebs mit Haft- und Gleitreibung genommen, wie es unter "Modellierung eines Antriebs – detailliertes Modell" bereits vorgestellt wurde. Im Scicos-Modell ist der Antrieb der Übersichtlichkeit wegen als Superblock ausgeführt. Das Blockschaltbild des Antriebs im Detail ist [http://www.roboternetz.de/wissen/images/7/73/Antrieb_Modell.png hier] zu sehen. Die Daten sind:

R = 16 Ohm; L = 6 mH; m = 0.31 kg; Kf = 6.6 N/A

Als Sensor kommt ein Inkrementalgeber zum Einsatz, allerdings muss der richtungssensibel sein, sonst ist keine Lageregelung möglich. Der Sensor wird in Scicos mit der Rundungsformel (round(u1*500)) simuliert. Das ergibt bei einer Auflösung von 2mm ganzzahlige Schritte, wie es auch die Hardware (Inkrementalgeber mit nachfolgendem Zähler) in Wirklichkeit macht.

[[Bild:Lageregelung.png]]

Nach dem Regler folgt ein Block mit der Verstärkung (5/255), der den PWM-Wert auf die Ansteuerspannung für den Motor umsetzt. Der Bruch 5/255 entspricht der Ansteuerspannung von 5V bei PWM=255. Der PD-Regler kann damit in Scicos exakt so simuliert werden, wie er schlussendlich auch als C-Code umgesetzt wird. Dazu wird der Code des PD-Reglers als Funktion in den Scifunc-Block eingegeben. Der Code ist etwas unterschiedlich zum C-Code des realen Bots, da die Syntax in Scicos doch geringfügig anders ist und die Eingangs- und Ausgangsvariablen nur bestimmte Bezeichnungen haben dürfen. Im nachfolgenden Codefenster sind beide Varianten im Vergleich zu sehen.
{|
| '''Scifunc-Code:'''
<pre>

y1=Kp*u1+Kd/Ta*(u1-z);
z=u1;
if y1>255 then
y1=255;
end
if y1<-255 then
y1=-255;
end
</pre>
| '''C-Code für µC:'''
<pre>
e = w - x;
y = Kp*e + Kd/Ta*(e-ealt);
ealt = e;
if (y > 255) {
y = 255;
}
if (y < -255) {
y = -255;
}
</pre>
| '''Kommentar:'''
<pre>
Vergleich
PD-Reglergleichung
alten Wert speichern

pos. Begrenzung

neg. Begrenzung

</pre>
|}

In der praktischen Umsetzung des C-Codes wird man den Bruch Kd/Ta durch eine Ersatzvariable oder Konstante ersetzen. Dabei ergibt sich (wie in diesem Beispiel 2/0.01 = 200) meistens ein ganzzahliger Wert, was sich positiv auf die Rechenzeit auswirkt.

Für die Abtastzeit Ta wurde 10ms gewählt. Das ist einerseits nicht zu schnell für einen µC und andererseits nicht zu lang, um die Regelung unnötig zu verlangsamen. Die Parametrierung von Kp und Kd erfolgte empirisch durch Probieren in der Simulation. Begonnen wurde mit einem reinen P-Regler und kleinem P-Anteil (Kp=1, Kd=0). In groben Schritten wurde Kp solange erhöht, bis sich deutlich Überschwinger zeigten. Dann wurde ein D-Anteil hinzugefügt und Kd so variiert, dass der Überschwinger verschwindet. Mit ein bisschen Feintuning ergaben sich so die Werte Kp=61 und Kd=2. Das Simulationsergebnis für Ansteuerspannung, Geschwindigkeit und Weg sieht damit folgendermaßen aus:

[[Bild:Lage_antwort.png]]

==Autoren==
* [[Benutzer:Waste|Waste]]

==Siehe auch==
* [[SwitcherCAD-Tutorial]]

== External links ==
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=11818 Post: Line follower with PID controller]
*[http://www.scicos.org/ Scicos Homepage]
* [http://www.scicoslab.org/ ScicosLab Homepage]
* [http://www.scilab.org/ Scilab Homepage]
* [http://ltspice.linear.com/software/swcadiii.exe LTspice / SwitcherCAD III Download]
* [http://www.kahlert.com/web set_download.php demo version of WinFACT 7]
* [http://www.physi.uni-heidelberg.de/fp/anleitg/E01.pdf instructions for electronic placement, the last part is based PID controller]
* [http://www.simapp.com/ SimApp website] with trial
* [http://www.expertcontrol.com/ ExpertControl Homepage, Automatische Reglerauslegung mit ecICP] ecICP-Trial über Support-Seite verfügbar
* [http://www.me.th-mittelhessen.de/personen/professoren/orlowski/simulation-regelungstechnik/ TH-Mittelhessen Prof. Peter F. Orlowski, Simulationsprogramm SIMLER-PC]

[[Category: Microcontroller]]
[[Category: Software]]
[[Category: Elektronik]]

Datei:Reglervergleich.gif

2014-09-13T08:17:50Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/vergleich.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/vergleich.gif

Regelungstechnik

2014-09-13T08:15:25Z

SprinterSB: /* Der Regler */ wikify: iregler.gif, pregler.gif, piregler.gif, pdregler.gif, pidregler.gif

'''Regelungen''' sind ein Bestandteil unseres Lebens und das nicht nur seit Erfindung der Dampfmaschine.

Allein schon der aufrechte Gang funktioniert nur mit Regelung. Dabei wirken die Sinne als Sensoren, das Gehirn als Regler und die Muskeln als Aktuatoren. Weitere Regelungen in unserem Körper sind z.B. die Konstanthaltung der Körpertemperatur, der Blutdruck, die Anpassung der Pupille auf Helligkeitsänderungen usw.

Im technischen Zeitalter ist der erste geschichtlich bedeutende Regler der Fliehkraftregler von James Watt, der für die Drehzahlregelung seiner Dampfmaschine eingesetzt wurde. Seitdem ist die Regelungstechnik aus keinem Technikbereich mehr wegzudenken. Die Regelungstechnik begegnet uns im täglichen Leben auf Schritt und Tritt: Der Temperaturregler der Zentralheizung, der Temperaturregler des Kühlschranks, der Regler für die Belichtungsautomatik im Fotoapparat, das ABS-System im Auto und die Netzspannungs- und Frequenzregelung des europäischen Versorgungsnetzes sind nur einige wenige Beispiele aus diesem Bereich.

''Autor Waste''

==Einleitung==

Der Begriff ''Regelung'' ist zu unterscheiden von dem im allgemeinen Sprachgebrauch oft synonym gebrauchten Begriff der ''Steuerung''. Das Steuern ist ein rein vorwärts gerichteter Prozess ohne Rückkopplung. Die Ausgangsgröße wird dabei nicht überwacht und kann sich durch Störungen von außen verändern. Ein Beispiel ist die Steuerung eines Motors mit einer einstellbaren Spannung. Durch Laständerungen wird sich die Drehzahl des Motors ändern. Soll nun die Drehzahl konstant gehalten werden, bedarf es einer Rückkopplung um über die Spannung die Drehzahl anzupassen. Diese Rückkopplung ist das Kennzeichen einer Regelung.

Das Regeln ist ein Vorgang, bei dem die Ausgangsgröße, im Beispiel die Drehzahl, fortlaufend überwacht wird und bei Abweichung über die Stellgröße, im Beispiel die Spannung, korrigiert wird. Der sich dabei ergebende Wirkungsablauf findet in einem geschlossenen Kreis, dem Regelkreis, statt.

==Der Regelkreis==

[[Bild:Regelkreis1.png|right|thumb|300px|Ein Regelkreis (Prinzip)]]

Das Prinzip einer Regelung ist das fortlaufende: '''Messen – Vergleichen – Stellen'''

;Messen: Die Regelgröße wird direkt oder mittels Sensoren gemessen.
;Vergleichen: Der Wert der Regelgröße wird mit dem Sollwert verglichen. Die Differenz ist die ''Regelabweichung''.
;Stellen: Aus der Regelabweichung wird unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke die ''Stellgröße'' bestimmt.

{{Absatz}}

[[Bild:Regelkreis2.png|thumb|350px|Wirkunsweise einer Regelung]]

Ein Regelkreis dient dazu, eine vorgegebene physikalische Größe, die ''Regelgröße'', auf einen gewünschten Wert (Sollwert) zu bringen und dort zu halten, unabhängig von eventuell auftretenden Störungen.
Um die Regelungsaufgabe zu erfüllen, muss der Augenblickswert der Regelgröße – der Istwert – gemessen und mit dem Sollwert verglichen werden. Bei auftretenden Abweichungen muss in geeigneter Art und Weise nachgestellt werden.

Um nun diese Aufgabe technisch zu lösen, gibt es die Regelungstechnik. Sie baut im wesentlichen auf die mathematische Beschreibung und Modellbildung des Systems Regelkreis. Zur Modellierung, Beschreibung und Simulation werden Blockschaltbilder mit diskreten Signalgliedern verwendet.

{{Absatz}}

[[Bild:Regelkreis3.png|thumb|350px|Beispiel einer Geschwindigkeitsregelung]]

Ein typisches Beispiel für einen Regelkreis – eine Geschwindigkeitsregelung – wird im nebenstehenden Bild gezeigt. Die Sollgeschwindigkeit ist 80 km/h. Durch eine äußere Störung, in dem Fall eine Steigung, verlangsamt sich das Fahrzeug auf 70 km/h. Die Abweichung wird durch das Tachometer erfasst. Als Korrekturmaßnahme wird mehr Gas gegeben, um wieder auf die Sollgeschwindigkeit von 80 km/h zu kommen.

{{Absatz}}

=== Begriffe ===

[[Bild:Regelkreis4.png|right]]

Ein Regelkreis besteht entsprechend des vereinfachten Blockschaltbildes, wie es oft in der Regelungstechnik verwendet wird, aus den Hauptteilen ''Regler'' und ''Regelstrecke'':

;Regler: Ist der Teil des Regelkreises, der unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke aus der Regelabweichung die Korrekturmaßnahmen zum Ausregeln ergreift.

;Regelstrecke: Ist der Teil des Regelkreises, der vom Regler ausgeregelt werden soll.

;Führungsgröße (Sollwert) w: Vorgegebener Wert, auf dem die Regelgröße durch die Regelung gehalten werden soll. Sie ist eine von der Regelung nicht beeinflusste Größe und wird von außen zugeführt.

;Regelgröße (Istwert) x: Ist die Ausgangsgröße der Regelstrecke, die zum Zweck des Regelns erfasst und zum Vergleich rückgeführt wird. In vielen Fällen ist in der Rückführung noch eine Messeinrichtung (Sensor) gezeichnet, die den Istwert erfasst, hier der Einfachheit halber weggelassen.

;Regelabweichung e: Differenz zwischen Führungsgröße und Regelgröße '''e = w – x''', bildet die eigentliche Eingangsgröße des Reglers.

;Stellgröße y: Ausgangsgröße der Regeleinrichtung und zugleich Eingangsgröße der Strecke. Sie überträgt die steuernde Wirkung des Reglers auf die Strecke.

;Störgröße z: Eine von außen wirkende Größe, die eine Änderung des Istwertes der Regelgröße bewirkt und einen Regelvorgang auslöst.

==Die Regelstrecke==
Die Regelstrecke stellt den zu regelnden Teil bzw. den zu regelnden Prozess dar und umfasst normalerweise eine Reihe von einzelnen Gliedern. Die Glieder werden entsprechend ihrem Zeitverhalten charakterisiert. Um das Zeitverhalten herauszufinden, legt man an den Eingang ein Testsignal an und zeichnet die Antwort auf. Im einfachsten Fall wird der Eingang mit einer sprunghaften Änderung beaufschlagt. Die Antwort auf die sprunghafte Änderung der Eingangsgröße wird Sprungantwort genannt und gibt Aufschluss über die Art der Regelstrecke und kann eventuell bereits genutzt werden, um die Parameter der Regelstrecke zu bestimmen.

Für den Aufbau eines gut funktionierenden Regelkreises und die Auslegung von Reglern ist es eine Voraussetzung zu wissen, wie die Regelstrecke reagiert. Ohne ein genaues Wissen um das dynamische Verhalten der Regelstrecke ist es nicht möglich geeignete Regler auszuwählen und diese zu parametrieren.

Die wichtigsten dynamischen Grundelemente zur Charakterisierung der Regelstrecke sind nachfolgend aufgelistet. Jedes Element wird mit einem Block dargestellt und darin durch ein Symbol oder der stilisierten Sprungantwort gekennzeichnet.

----

===Proportionalglied (P-Glied)===
[[File:pglied.gif]]

Die einfachste Art einer Regelstrecke.
;Beispiele: Hebel, Getriebe, Verstärker, Spannungsteiler, Sensoren bei denen das Zeitverhalten vernachlässigt werden kann

----

===Integrator (I-Glied)===
[[File:iglied.gif]]

Strecke ohne Ausgleich, ist häufig in Regelstrecken vorhanden.
;Beispiele: Beschleunigung → Geschwindigkeit → Weg, Strom → Kondensatorspannung

----

===Verzögerungsglied 0.Ordnung (Totzeitglied)===
[[File:ttglied.gif]]

Entsteht durch Laufzeiten von Material oder Signalen. Je größer die Verzögerungszeit einer Regelstrecke ist, um so schwieriger ist sie zu regeln.
;Beispiele: Förderband, Rechenzeit, A/D-Wandler

Nicht zu verwechseln mit der Totzeit, die durch das asynchrone Auftreten eines Ereignisses auf einen Zyklus entsteht. Vom Verzögerungsglied 0.Ordnung unterscheidet sich diese dadurch, daß sie mit einer gleichverteilten Wahrscheinlichkeit zwischen "gar nicht" und dem gesamten Umfang auftritt. Diese Totzeit ist mechanisch mit einem Spiel vergleichbar das "gar nicht" bis zum vollen Umfang zu einem Fehler beiträgt.
;Beispiele: Erkennen eines Signals an einem Mikroprozessor

----

===Verzögerungsglied 1.Ordnung (PT1-Glied)===
[[File:pt1glied.gif]]

Viele einfache Regelstrecken haben ein solches Verhalten bzw. können näherungsweise damit beschrieben werden. Ist ein P-Glied mit nicht vernachlässigbarem Zeitverhalten.
;Beispiele: Gleichstrommotor (Spannung → Drehzahl), näherungsweise; Widerstand-Kondensator-Schaltung (RC-Glied)

----

===Verzögerungsglied 2.Ordnung (PT2-Glied)===
Man unterscheidet schwingungsfähige und nicht schwingungsfähige PT2-Glieder. Zur Charakterisierung gibt es die Parameter Dämpfung D und Eckfrequenz w<sub>0</sub> oder die Zeitkonstanten T<sub>1</sub> und T<sub>2</sub>. Für Dämpfung D<1 ist es schwingungsfähig.

'''Schwingfähiges PT2-Glied:'''<br/>
[[File:pt2aglied.gif]]
;Beispiele: Mechanischer Schwinger (Feder-Masse-System), elektrischer Schwingkreis (RLC-Kreis)

'''Nicht schwingfähiges PT2-Glied:'''<br/>
[[File:pt2bglied.gif]]
;Beispiele: Zwei hintereinander geschaltete PT1-Glieder, Gleichstrommotor (Spannung → Drehzahl) mit berücksichtigter Induktivität

==Der Regler==
Der Regler hat die Aufgabe, die Regelgröße zu messen, sie mit dem Sollwert zu vergleichen und bei Abweichungen die Stellgröße so zu verändern, dass Soll- und Istwert der Regelgröße wieder übereinstimmen bzw. die Differenz minimal wird.

Die Wahl eines bestimmten Reglertyps richtet sich nach dem geforderten Zeitverhalten und der geforderten Regelgenauigkeit der Regelstrecke. Nachfolgend finden Sie eine Zusammenfassung der wichtigsten klassischen Reglertypen:

===P-Regler===
Der proportionalwirkende Regler multipliziert die Regelabweichung mit seinem Verstärkungsfaktor '''Kp''' und gibt das Ergebnis unverzögert weiter. Er unterscheidet sich prinzipiell nicht vom dynamischen Element P-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der P-geregelte Kreis ist einfach und mittelschnell im Vergleich zu anderen Regelungen. Das Problem ist die bleibende Regelabweichung!

[[File:pregler.gif]]

'''Software P-Regler:'''
y = Kp * e

----

===I-Regler===
Der integralwirkende Regler summiert die Regelabweichung über der Zeit auf und multipliziert die Summe (d.h. das Integral) mit dem Faktor '''Ki'''. Je länger eine Regelabweichung ansteht, desto größer wird die Stellgröße des I-Reglers. Er unterscheidet sich prinzipiell nicht vom dynamischen Element I-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der I-geregelte Kreis ist langsam im Vergleich zu anderen Regelungen. Er hat aber den Vorteil, dass die Abweichung vollständig eliminiert wird.

[[File:iregler.gif]]

'''Software I-Regler:'''
esum = esum + e
y = Ki * Ta * esum

'''esum''' ist die Summe aller bisherigen Abweichungen '''e'''. Der Parameter des Software I-Reglers ist abhängig von der Rechenschrittweite '''Ta''' (Abtastzeit). Je öfter gerechnet wird, desto öfter wird auch hinzugezählt (aufintegriert). Eine kleine Abtastzeit erfordert also einen kleineren Faktor, dies wird durch die Multiplikation mit '''Ta''' verwirklicht.

----

===PI-Regler===
Der PI-Regler ist die Kombination aus P- und I-Regler und kombiniert den Vorteil des P-Reglers, nämlich schnelle Reaktion, mit dem Vorteil des I-Reglers, der exakten Ausregelung. Der PI-geregelte Kreis ist also genau und mittelschnell.

[[File:piregler.gif]]

'''Software PI-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum

----

===PD-Regler===
Der proportional-differential wirkende Regler kombiniert den P-Regler mit einem D-Anteil.
Der D-Anteil bewertet die Änderung einer Regelabweichung (er differenziert) und berechnet so deren Änderungsgeschwindigkeit. Diese wird mit dem Faktor '''Kd''' multipliziert und zum P-Anteil hinzuaddiert. Der PD-Regler reagiert damit schon auf Ankündigungen von Veränderungen, das bewirkt sozusagen ein Vorhalten beim Regeln.

Der PD-geregelte Kreis ist sehr schnell im Vergleich zu anderen Regelungen, und manche Regelkreise (solche mit zweifacher Integration) sind ohne D-Anteil überhaupt nicht stabilisierbar. Das Problem der proportionalen Regler, die bleibende Regelabweichung, ist beim PD-Regler allerdings weiterhin vorhanden!

Ein Nachteil aller Regler mit D-Anteil kann die Unruhe im Kreis sein. Ist das Sensorsignal verrauscht, so wird dieses Rauschen durch die Differenziation weiter verstärkt und wieder in den Kreis hineingegeben. Dadurch wird der Aktuator stärker belastet. Macht der Regler insbesondere sehr hohe Ausschläge als Folge von schnellen Änderungen des Sollwertes, dann kann es sein, dass das Stellglied oder der Aktuator diese nicht umsetzen kann - die Wirkung des D-Anteils würde dann durch die Begrenzung verpuffen, und das Einschwingverhalten wäre nicht wie berechnet, sondern meist langsamer. Dies gilt aber nur für große Sprünge. Bei den normalen kleinen Regelvorgängen zum Ausgleich von Störeinflüssen wirkt der D-Anteil wie beabsichtigt.

[[File:pdregler.gif]]

'''Software PD-Regler:'''
y = Kp * e + Kd * (e – ealt)/Ta
ealt = e

Mit der neuesten Regelabweichung '''e''' und der vorhergehenden '''ealt''' wird der D-Anteil berechnet. Die Differenziation erfolgt damit angenähert durch Bildung des Differenzquotienten (e - ealt)/Ta.

----

===PID-Regler===
Der PID Regler ist der universellste der klassischen Regler und vereinigt die guten Eigenschaften der anderen Regler. Zur Beschreibung der Eigenschaften des P-, I- und D-Anteils siehe die anderen Reglertypen. Der PID-geregelte Kreis ist genau und sehr schnell. In den meisten Anwendungen kommt deshalb der PID-Regler zum Einsatz.

[[File:pidregler.gif]]

'''Software PID-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum + Kd * (e – ealt)/Ta
ealt = e

'''Alternative PID-Reglerstruktur:'''

Es gibt 2 Darstellungsmöglichkeiten, die inhaltlich identisch sind. In der analogen Regeltechnik ist noch die Darstellung mit der Nachstellzeit '''Tn''' und der Vorhaltezeit '''Tv''' üblich. Die Umrechnung zwischen den beiden Strukturen ist mit den angegebenen Formeln möglich.

[[Bild:PIDstruktur.gif]]

==Vergleich der Reglertypen==
In der folgenden Abbildung ist der Vergleich von P-, I-, PI-, PD- und PID-Regler in einem Regelkreis mit PT2-Glied als Regelstrecke dargestellt. Es ist deutlich zu sehen, dass die Regler ohne I-Anteil (P und PD) eine bleibende Regelabweichung aufweisen. Erst die Regler mit I-Anteil können auf den Endwert von 1 ausregeln. Beim reinen I-Regler geht das so langsam, dass es gar nicht mehr auf dem Diagramm zu sehen ist. Der Hauptzweck eines I-Anteils ist also die Vermeidung bleibender Regelabweichungen. Daher ist ein
I-Anteil normalerweise nicht nötig, wenn die Strecke schon einen I-Anteil besitzt.
Ausnahme: Es wird ein doppelter I-Anteil zur Vermeidung von Schleppfehlern benötigt.

Die schnellsten Regler sind die mit einem D-Anteil (PD und PID). Der D-Anteil kommt deshalb hauptsächlich zum Einsatz, wenn schnelle Dynamik gefragt ist oder die Strecke selbst schon instabil ist. Voraussetzung für die Schnelligkeit ist allerdings, dass keine Begrenzung im Stellglied oder Aktuator auftritt. In der Praxis ist eine Begrenzung meistens nicht zu vermeiden, deshalb gilt die Sprungantwort in der Praxis nur für kleine Sprünge.

Die Regler ohne D-Anteil, aber mit P-Anteil (P und PI) sind mittelschnell. Für einfache Regelaufgaben reicht auch oft schon ein reiner P-Regler aus, wenn die bleibende Regelabweichung vernachlässigt werden kann oder weil die Strecke schon einen I-Anteil besitzt.

http://www.roboternetz.de/wiki/uploads/Main/vergleich.gif

Aus diesem Vergleich wird klar, warum der PID-Regler so beliebt ist, er vereinigt die Vorzüge aller anderen Regler.

==Digitaler Regler==
Durch die Einführung leistungsfähiger und preiswerter Mikroprozessoren hat sich der digitale Regler mehr und mehr durchgesetzt. Im Gegensatz zum analogen Regler werden die Signale nicht mehr analog mit Operationsverstärker verarbeitet, sondern mit einem Mikroprozessor errechnet. Bevor das Signal vom Mikroprozessor bearbeitet werden kann, muss zunächst das Eingangssignal (Istwert) mit einem Analog-Digital-Umsetzer (ADU) digitalisiert werden, d.h. in einen Zahlenwert umgewandelt werden. Das vom digitalen Regler errechnete Ausgangssignal (Stellgröße) wird wiederum zur Ansteuerung des Stellglieds mit einem Digital-Analog-Umsetzer (DAU) in ein analoges Signal gewandelt. Funktionell unterscheiden sich analoger und digitaler Regler jedoch nicht wesentlich, es müssen nur die Schnittstellen angepasst werden.

[[File:digreg.gif|right|framed|Digitaler Regler (Prinzip)]]

Da die Wandlungen und das Regelprogramm eine gewisse Zeit beanspruchen, vergeht pro Durchlauf die sogenannte Takt- oder Abtastzeit. Diese Zeit wirkt sich im Regelkreis wie ein Totzeitglied mit der halben Abtastzeit als Totzeit aus. Das verursacht eine zusätzliche Phasenverschiebung, was sich ungünstig auf die Stabilität des Regelkreises auswirken kann. Ist die Abtastzeit sehr viel kleiner als die dominierende Zeitkonstante der Strecke, dann spricht man von quasi-kontinuierlichem Verhalten, da sich der digitale Regler ähnlich wie ein analoger Regler verhält. Der digitale Regler kann dann wie ein analoger dimensioniert werden. Ist die Abtastzeit größer, kann sie nicht mehr vernachlässigt werden, dann muss sie auch beim Reglerentwurf berücksichtigt werden.

'''Vorteile digitaler Regler:'''
* Die Verarbeitung erfolgt driftfrei.
* Es lassen sich nichtlineare Kennlinien, intelligentes Verhalten oder adaptive Regelung leichter realisieren.
* Der Regler kann bei Bedarf per Software neu konfiguriert und parametriert werden

'''Digitale Realisierung am Beispiel des PID-Algorithmus'''

Ausgehend von der Differentialgleichung für kontinuierliche Systeme wird die Differenzengleichung für zeitdiskrete Systeme erstellt. Daraus folgt dann der Stellungsalgorithmus in allgemeiner Form.

Ta = Abtastzeit; k = Nummer der Abtastung

Kp = Proportionalbeiwert; Ki = Integrierbeiwert; Kd = Differenzierbeiwert



'''Differentialgleichung für den kontinuierlichen PID-Regler:'''
:<math>
y(t) \;=\; Kp \!\cdot\! e(t)
+ Ki \int_0^t e(\tau) \, d\tau
+ Kd \, \frac{de(t)}{dt}
</math>

'''Differenzengleichung für den zeitdiskreten PID-Regler:'''
:<math>
y_k \;=\; Kp \!\cdot\! e_k
+ Ki \!\cdot\! Ta \sum_{i=0}^k e_i
+ \frac{Kd}{Ta}\, ( e_k - e_{k-1} )
</math>

'''PID Stellungs-Algorithmus:
:''' <math>
y_k \;=\; y_{k-1}
+ q_0 \!\cdot\! e_k
+ q_1 \!\cdot\! e_{k-1}
+ q_2 \!\cdot\! e_{k-2}
</math>

Mit den Parametern:
:<math>
q_0 \,=\, Kp + Ki \!\cdot\! Ta + \frac{Kd}{Ta}
\, , \quad
q_1 \,=\, -Kp - 2 \, \frac{Kd}{Ta}
\, , \quad
q_2 \,=\, \frac{Kd}{Ta}
</math>

'''Umsetzung in Code nach der Differenzengleichung:'''

Im Code wurden einige Variablen umbenannt, da die Indexschreibweise nicht möglich ist.

y entspricht y<sub>k</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, esum ist die Summenbildung

In der Praxis wird man die Ausdrücke Ki*Ta und Kd/Ta vorab berechnen und mit Ersatzvariablen in die Reglergleichung einsetzen. Der Verständlichkeit halber wurde es hier im Code belassen. Des weiteren kann eine Begrenzung von esum notwendig werden, um einen Variablenüberlauf oder Windup-Effekt zu vermeiden.

Der nachfolgende Code wird im Rhythmus der Abtastzeit Ta immer wieder aufgerufen.
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
y = Kp*e + Ki*Ta*esum + Kd/Ta*(e – ealt); //Reglergleichung
ealt = e;
----

'''Alternative Umsetzung in Code nach dem Stellungsalgorithmus:'''<br/>
y entspricht y<sub>k</sub>, yalt entspricht y<sub>k-1</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, ealt2 entspricht e<sub>k-2</sub>
e = w - x; //Vergleich
y = yalt + q0*e + q1*ealt + q2*ealt2; //Reglergleichung
ealt2 = ealt;
ealt = e;
yalt = y;

==Dimensionierung des Reglers==
Die Auswahl des Reglertyps ist heutzutage bei den digitalen Reglern nicht mehr so kritisch, da der Mehraufwand in Software für einen PID-Regler gegenüber einfacheren Typen kaum zu Buche schlägt. Im Prinzip ist man deshalb mit einem PID-Regler fast immer auf der richtigen Seite, mit einer Ausnahme, bei einer Strecke mit reiner Totzeit. Die folgende Tabelle gibt eine Hilfestellung zur Auswahl des Reglers.

{| border=1 cellpadding=4
|+ '''Geeignete Reglertypen für die unterschiedlichen Regelstrecken'''
|rowspan=2 |'''Strecke'''
|colspan=4 |<div align="center">'''Regler'''</div>
|-
|<div align="center">'''P'''</div>
|<div align="center">'''PD'''</div>
|<div align="center">'''PI'''</div>
|<div align="center">'''PID'''</div>
|-
|reine Totzeit
| 
| 
|<div align="center">geeignet</div>
| 
|-
|1.Ordnung mit kleiner Totzeit
| 
| 
|gut geeignet
|gut geeignet
|-
|2.Ordnung mit kleiner Totzeit
| 
| 
| 
|gut geeignet
|-
|höhere Ordnung
| 
| 
| 
|gut geeignet
|-
|I-Glied und Verzögerung
|geeignet
|gut geeignet
|<div align="center">geeignet</div>
|gut geeignet
|}

Nachdem man einen geeigneten Reglertyp ausgewählt hat, stellt sich noch die Frage, wie man die Reglerparameter Kp, Ki, und Kd optimiert. Im Laufe der Zeit wurden viele Methoden zur Dimensionierung der Reglerparameter entwickelt, aber es können hier nicht alle aufgelistet werden. Diese Aufzählung beschränkt sich auf die einfacheren und gängigen Methoden der Parametrierung.

===Dimensionierung durch Probieren (Empirisches Einstellen)===

====Methode 1====
Diese Methode ist geeignet um einfache Systeme zu dimensionieren, insbesondere wenn man bereits Erfahrung mit ähnlichen Regelkreisen hat. Man fängt mit einer unkritischen Einstellung (Kp klein, Ki = 0, Kd = 0) an und erhöht langsam die Verstärkung Kp, bis die Dämpfung schlecht wird. Falls eine Schwingneigung auftritt, muss die Verstärkung wieder etwas zurück genommen werden. Dann nimmt man allmählich den Integralanteil hinzu, erhöht ihn in Schritten und probiert solange herum, bis das Ergebnis einigermaßen passt. Bei Bedarf kann noch ein D-Anteil (PID-Struktur) probiert werden. Wenn dabei die Regelung stabiler wird, kann noch mal Kp und Ki erhöht werden, bis man endgültig zufrieden ist.

====Methode 2====
Alle Anteile erstmal auf 0. Dann erhöht man Kp so lange bis das System deutlich schwingt. Danach wird der Kd so lange erhöht bis das System nicht mehr schwingt. Anschliessend kann noch ein kleiner Ki Anteil hinzugegeben werden.

Es dürfte klar sein, dass so eine Optimierung im Blindflug nicht immer das Optimum ergibt, aber es ist eine gängige praktische Methode zur Ermittlung der Reglerparameter. Besser sieht es aus, wenn in einer Simulation empirisch optimiert wird. Zusätzliche Informationen über die Stabilität erlauben hierbei eine gezieltere Optimierung. Zudem ist das Probieren im Simulator gefahrlos möglich, was in der Realität nicht immer der Fall ist. Geeignete Programme zur Simulation sind [[Regelungstechnik#Hilfsprogramme_zur_Analyse_und_Optimierung| hier]] vorgestellt. Allerdings muss für eine Simulation die Regelstrecke bekannt sein. Ist das nicht der Fall, so bleibt nur das einfache Probieren oder das Einstellen nach der Schwingungsmethode wie im folgenden beschrieben.

===Dimensionierung nach Einstellregeln===
Die Dimensionierung nach Rezept ist eine praktische Methode ohne viel Rechnerei und Hilfsmittel, eine Methode also für den Praktiker. Die bekanntesten Einstellregeln sind von Ziegler/Nichols und von Chien/Hrones/Reswick. Darüber hinaus gibt es noch eine Vielzahl anderer Einstelltabellen, auf die hier aber verzichtet wird, das würde den Rahmen dieses Artikels sprengen. An der Vielzahl kann man schon ersehen, dass es kein universell gültiges Rezept gibt und mit diesen Tabellen nicht unbedingt das Optimum erreicht wird, eine Nachoptimierung kann nötig sein.

Bei Ziegler/Nichols unterscheidet man noch zwischen der Schwingungsmethode und der Einstellung nach der Sprungantwort.

'''Einstellung nach der Schwingungsmethode:'''<br/>
Bei der Schwingungsmethode nach Ziegler/Nichols werden die Reglerparameter so verstellt, dass die Stabilitätsgrenze erreicht wird und der Regelkreis zu schwingen beginnt, d.h. die Regelgröße periodische Schwingungen ausführt. Aus der so gefundenen Einstellung können die Reglerparameter ermittelt werden. Dieses Verfahren ist nur auf Regelstrecken anwendbar, bei denen ein Schwingen keinen Schaden anrichtet und die überhaupt instabil gemacht werden können. Die Vorgehensweise ist folgende:
# Einstellung des Reglers als reinen P-Regler: Ki = 0 und Kd = 0
# Die Reglerverstärkung Kp wird solange vergrößert, bis sich der geschlossene Regelkreis an der Stabilitätsgrenze befindet und Dauerschwingungen ausführt.
# Der dabei eingestellte Wert Kp wird als Kp<sub>krit</sub> bezeichnet.
# Die Periodendauer der sich einstellenden Dauerschwingung T<sub>krit</sub> wird gemessen.
# Anhand der folgenden Tabelle werden dann die Reglerparameter bestimmt.

{| cellpadding=10
|
{| border=1 cellpadding=4
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|0.5*Kp<sub>krit</sub>
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.45*Kp<sub>krit</sub>
|<div align="center">0.85*T<sub>krit</sub></div>
| 
|-
|<div align="center">'''PID'''</div>
|0.6*Kp<sub>krit</sub>
|0.5*T<sub>krit</sub>
|0.12*T<sub>krit</sub>
|}
|
{| border=0 cellpadding=4
|'''Ki = Kp/Tn'''
|-
|'''Kd = Kp*Tv'''
|}
|}

Der Vorteil dieses Verfahrens liegt darin, dass die Untersuchung während des Betriebes und ohne Öffnen des Regelkreises durchgeführt werden kann. Der Nachteil an dem Verfahren ist, dass es nur auf Strecken angewendet werden kann, die auch zum Schwingen gebracht werden können.

'''Einstellung nach der Sprungantwort:'''<br/>
Diese Methode der Parameterbestimmung beruht auf der Aufnahme der Sprungantwort der Regelstrecke. Es eignet sich auch für Strecken, die nicht zum Schwingen gebracht werden können. Der Regelkreis muss allerdings geöffnet werden.
Vorgehensweise: Es wird die Sprungantwort aufgenommen und durch Einzeichnen der Wendetangente die Verzugszeit Tu und die Ausgleichszeit Tg ermittelt.

[[Bild:Tu_Tg.gif]]

Mit den so festgestellten Werten werden die Parameter für den einzusetzenden Regler gemäß nachstehenden Tabellen ermittelt.

{| cellpadding=10
|
{| border=1 cellpadding=4
|+ Einstellregeln nach Ziegler/Nichols:
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|1/Ks*Tg/Tu
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.9/Ks*Tg/Tu
|3.3*Tu
| 
|-
|<div align="center">'''PID'''</div>
|1.2/Ks*Tg/Tu
|2*Tu
|0.5*Tu
|}
|
|
{| border=1 cellpadding=4
|+ Einstellregeln nach Chien/Hrones/Reswick
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|0.3/Ks*Tg/Tu
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.35/Ks*Tg/Tu
|1.2*Tg
| 
|-
|<div align="center">'''PID'''</div>
|0.6/Ks*Tg/Tu
|<div align="center">Tg</div>
|0.5*Tu
|}
|}

{| cellpadding=10
|
{| border=1 cellpadding=4
|'''Ki = Kp/Tn'''
|-
|'''Kd = Kp*Tv'''
|}
|
{| cellpadding=4 width=420
|Die Parameter Tn und Tv sind aus der analogen Regelungstechnik und sind dort sehr geläufig. Die Umrechnung in die Parameter Ki und Kd erfolgt mit nebenstehenden Formeln. Siehe auch [[Regelungstechnik#PID-Regler| PID-Regler]]
|}
|}

===Dimensionierung mit dem Bodediagramm===
Ein Bode-Diagramm ist die grafische Darstellung des Frequenzganges. Es werden der Betrag der Übertragungsfunktion (Amplitudengang) und der Verlauf des Phasenwinkels (Phasengang) als Funktion der Frequenz aufgetragen. Die Frequenzachse und die Amplitudenachse werden logarithmisch dargestellt. Die logarithmische Darstellung hat den Vorteil, dass eine Multiplikation auf eine einfache Addition zurückgeführt wird. Somit wird eine Hintereinanderschaltung von Systemen im Blockschaltbild zu einer einfachen Addition im Bodediagramm.

Das Zeitverhalten des rückgekoppelten Regelkreises hängt entscheidend vom Verlauf
des Frequenzganges der offenen Regelschleife in der Umgebung des Durchtretens durch
die 0dB-Achse ab. In der Regelungstechnik wird daher der offene Regelkreis im Bode-Diagramm aufgetragen. Das erlaubt einen schnellen Überblick über Stabilität und möglichen Reserven zur Optimierung. Ein Kriterium für die Stabilität der Schleife ist der Phasenrand und der Amplitudenrand. Der Phasenrand ist der Abstand (Phasenreserve) zur -180°-Linie bei der Durchtrittsfrequenz. Die Durchtrittsfrequenz ist diejenige Frequenz, bei der der Amplitudengang durch die 0dB-Linie geht. Siehe auch folgendes Bode-Diagramm.

[[Bild:Phasenrand.gif]]

{| {{Blauetabelle}}
|'''Regel:''' Eine geschlossene Regelschleife arbeitet genau dann stabil, wenn der Phasenrand positiv ist.
|}
Wird diese Bedingung verletzt, so wird in diesem Frequenzbereich die im Rückführzweig der Regelung eingebrachte Gegenkopplung zu einer Mitkopplung und das System kann schwingen.

'''Beim Reglerentwurf sind folgende Punkte zu beachten:'''
* Der Phasenrand muss positiv sein. Der geschlossene Regelkreis kann sonst instabil sein.
* Je größer der Phasenrand ist, desto größer ist die Stabilitätsreserve des Regelkreises und desto höher ist die Dämpfung des Regelkreises. Üblich sind Werte von 40°...70° für gutes Führungsverhalten und 20°...50° für gutes Störverhalten.
* Die Durchtrittsfrequenz ist ein Maß für die Schnelligkeit des Regelkreises, je höher, desto schneller ist die Reaktion auf Änderungen der Führungsgröße oder Störungen.

Hier ein Beispiel zur Dimensionierung mit dem Bode-Diagramm.

[[Bild:Bode1.gif]]

Die Strecke ist rot dargestellt und besteht in dem Beispiel aus einem nicht schwingfähigem PT2-Glied. Man sucht sich den Punkt, wo die Strecke für sich alleine noch ausreichend Phasenreserve hat, z.B. 70°. In dem Beispiel also die Frequenz, bei der die Strecke -110° Phasendrehung aufweist. Das ist etwa bei 15Hz. Da hat die Strecke ungefähr eine Dämpfung von 25dB. Wenn man nun diese Dämpfung durch eine Verstärkung von 25dB kompensiert, dann wird dieser Punkt zur Durchtrittsfrequenz. D.h. man wählt den P-Anteil des Reglers Kp=18, denn 25dB entspricht ungefähr dem Faktor 18. Um die Regelabweichung zu minimieren, wird noch ein I-Anteil hinzugefügt. Üblicherweise wählt man für die Grenzfrequenz des PI-Reglers die Grenzfrequenz des dominierenden Streckenteils, in dem Beispiel ca. 1.4Hz. Damit ergibt sich ein I-Anteil von 170. Im Bode-Diagramm ist der PI-Regler als schwarze Kurve eingezeichnet. Die Addition der Strecke und des Reglers im Bode-Diagramm führt dann zum Frequenzgang des offenen Regelkreises (blaue Kurve). Die resultierende Durchtrittsfrequenz ist wie gewählt bei etwa 15Hz. Der Phasenrand hat sich durch den I-Anteil im Regler auf ca. 60° reduziert, ist aber noch ausreichend. Das Einschwingen des geschlossenen Regelkreises für diese Dimensionierung sieht dann folgendermaßen aus:

[[Bild:Sprungantwort3.gif]]

Bei Bedarf könnte noch ein D-Anteil (PID-Regler) hinzugenommen werden, das würde die Phase anheben und man könnte dadurch die Durchtrittsfrequenz weiter nach oben schieben. In der Praxis wird dies allerdings wegen der wahrscheinlichen Begrenzung des Stellglieds kein schnelleres Einschwingen mehr bringen.

Begrenzungen oder Nichtlinearitäten werden bei der Dimensionierung mit dem Bode-Diagramm nicht berücksichtigt. Das ist ein Nachteil dieser Methode. Eventuell muss deshalb noch einmal im Zeitbereich nachoptimiert werden.

===Dimensionierung mit der Ortskurve===
Eine Alternative zur Dimensionierung mit dem Bodediagramm stellt die Methode über die Ortskurve des offenen Regelkreises dar.

Bei diesem Verfahren ist schnell auf einem Blick ersichtlich ob der Regelkreis stabil ist.

Liegt der Punkt -1 auf der Realteilachse links von der Ortskurve in Richtung steigendem Omega so ist der Regelkreis stabil.
Der Abstand zu der kritischen Kreisfrequenz Omega Krit von der Imaginärteilachse ist die Verstärkung Vr mit diesem Wert lässt sich der Amplitudenrand ermitteln.
Dazu wird folgende Formel verwendet: Ar = 20 lg (1/Vr) in dB

Die Durchtrittskreisfrequenz Omega D ist an dem Punkt, wo der Betrag aus Realteil und Imaginärteil 1 ergibt. Wenn man weiß, wo die Durchtrittskreisfrequenz ist, dann kann man den Phasenrand bestimmen.
Dies ist der Winkel zwischen der -180° Linie zu Omega D.

[[Bild:Ortskurve.jpg]]

==Hilfsprogramme zur Analyse und Optimierung==
Die Analyse und Optimierung von Regelkreisen wird wesentlich erleichtert durch die Zuhilfenahme von Programmen. Es erspart einem eine komplizierte Rechnerei von Hand oder umfangreiche Testläufe. Stellvertretend für all die verfügbaren Programme werden hier zwei Freeware-Programme vorgestellt, die dafür gut geeignet sind. Die Beschreibung hier ersetzt aber keine Tutorials, es wird nur die Anwendung für die Regelungstechnik beschrieben.

===Scilab/Scicos===
Scilab ist ein wissenschaftlich-technisches Softwarepaket für numerische Berechnungen. Scicos ist eine Erweiterung dazu, die eine blockorientierte und modellbasierte Simulation und Analyse von dynamischen Systemen bietet. Dieses Softwarepaket kann von der [http://www.scilab.org/ Scilab Homepage] herunter geladen werden.

====Scilab====
Mit Scilab ist es sehr einfach ein Bode-Diagramm zu zeichnen, es bedarf nur 3 Zeilen Code.
s=poly(0,'s');
G=syslin('c',0.72/(0.11*s+1));
bode(G)
Die 1.Zeile '''s=poly(0,'s');''' legt die Variable s als Polynomvariable fest. Dies braucht in einer Sitzung nur einmal gemacht zu werden. Die 2.Zeile '''G=syslin('c',0.72/(0.11*s+1));''' definiert ein lineares System mit der Übertragungsfunktion 0.72/(0.11s+1). Die 3.Zeile '''bode(G)''' zeichnet das Bode-Diagramm des zuvor mit syslin definierten Systems G. Zu beachten ist, dass Scilab auf der x-Achse im Bode-Diagramm die Frequenz in Hertz und nicht wie üblich die Kreisfrequenz darstellt. Anstelle des Bode-Diagramms kann auch die Sprungantwort gezeichnet werden. Dies geschieht mit folgenden Befehlen:
xbasc();
t=[0:0.001:2];
y=csim('step',t,G);
plot2d(t,y)
'''xbasc()''' löscht den letzten Plot mit dem Bode-Diagramm und mit '''t=[0:0.001:2]''' wird ein Vektor t mit den angegebenen Zeiten im Intervall von 1ms definiert. Die Zeile '''y=csim('step',t,G)''' berechnet die Sprungantwort des zuvor mit syslin definierten Systems G und speichert sie in y ab. Das Ergebnis wird dann mit '''plot2d(t,y)''' dargestellt. Bei Bedarf können noch Gitternetzlinien mit dem Befehl '''xgrid()''' hinzugefügt werden.

Ergänzend hier noch ein Scilab-Skript, welches recht hilfreich bei der Dimensionierung mit dem Bode-Diagramm ist. Den nachfolgenden Code einfach in das SciPad-Fenster (Editor von Scilab) kopieren und starten. Es werden 2 Grafikfenster angezeigt, eines mit dem Bode-Diagramm und ein zweites mit der Sprungantwort. Man kann im Skript die Streckencharakteristik anpassen und verschiedene Reglerparameter ausprobieren.

<pre>
Ks=0.72; // Verstärkung der Strecke
T1=0.11; // Zeitkonstante 1
T2=0.005; // Zeitkonstante 2
Kp=18; // Proportionalbeiwert
Ki=170; // Integralbeiwert
Kd=0; // Differenzialbeiwert

s=poly(0,'s'); // definiert s als Polynomvariable
P=(T1*s+1)*(T2*s+1); // Streckencharakteristik
Gs=syslin('c',Ks,P) // Übertragungsfunktion der Strecke

RZ=poly([Ki Kp Kd],'s','coeff') // Zählerpolynom des Reglers
RN=poly([0 1],'s','coeff') // Nennerpolynom des Reglers
Gr=syslin('c',RZ,RN) // Übertragungsfunktion des Reglers

G=Gr*Gs // Übertragungsfunktion gesamt
xset("window",0);
xbasc(0);
bode([Gr;G;Gs],0.1,100,['Regler';'gesamt';'Strecke'])

Gcl=G/(G+1) // geschlossene Regelschleife
t=0:0.001:0.2;
y=csim('step',t,Gcl); // berechnet Sprungantwort
xset("window",1);
xbasc(1);
plot2d(t,y,2);
xgrid();
xtitle("Sprungantwort","sec");
</pre>

====Scicos====
Eine weitere Möglichkeit zur Simulation im Zeitbereich bietet Scicos. Die Modellierung geschieht mit einem grafischen Editor, in dem Blöcke mit vordefinierten oder selbstgemachten Funktionen miteinander verbunden werden. Ein einfaches Modell eines Regelkreises mit PID-Regler sieht folgendermaßen aus:

[[Bild:Scicos_anaReg.gif]]

Der PID-Regler ist mit seinen 3 Zweigen (P, I und D) dargestellt. In den Verstärkerblöcken kann durch Ändern der Reglerparameter (KP, KI und KD) der Regler optimiert werden. Die Strecke ist in diesem Beispiel nur ein einzelner Block, in dem die Übertragungsfunktion eingegeben wird. Man kann die Strecke auch detaillierter mit einzelnen Funktionsblöcken darstellen. Ein Beispiel eines komplexen Blockschaltbilds für einen balancierenden Bot ist unter diesem [http://www.roboternetz.de/phpBB2/download.php?id=5082 Link] zu finden.

Der Vorteil der Simulation mit Scicos ist die Möglichkeit Nichtlinearitäten zu berücksichtigen und die Kombination von kontinuierlichen und diskreten Funktionen. Das heißt, man kann einen digitalen Regler mit seinen diskreten Schritten und eine analoge Strecke, als kontinuierliche Funktion eingegeben, zusammen simulieren. Scicos bietet sogar einen 'Scifunc'-Block, mit dem Rechenschritte des digitalen Reglers nachgebildet werden können. Damit wird sowohl das dynamische Verhalten, verursacht durch die Abtastzeit Ta, als auch die etwas unterschiedliche Dynamik durch die digitale Ausführung eines I- und D-Anteils richtig simuliert. Ein Beispiel für den Einsatz des Scifunc-Blocks ist in folgendem Blockschaltbild zu sehen.

[[Bild:Scicos_digReg.png]]

Beispiel: [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlregelung]] mit digitalem Regler

Die globalen Variablen für die Reglerparameter und die Abtastzeit werden unter dem Menüpunkt „Edit - Context“ abgelegt.
Kp=18;
Ki=60;
Ta=0.01;
In den Taktgeber für den digitalen Regler wird als Clock-Periode die Abtastzeit Ta eingetragen. In das Dialogfenster zum Scifunc-Block wird folgender Code zur Simulation des digitalen PI-Reglers eingetragen:
<pre>
z=z+Ki*Ta*u1
if z>5 then
z=5;
end
y1=Kp*u1+z
if y1>5 then
y1=5;
end
</pre>
z entspricht der Variable esum vom Beispiel des [[Regelungstechnik#Realisierung_mit_digitalem_Regler| digitalen Drehzahlreglers]]; u1 ist die Eingangsvariable und y1 die Ausgangsvariable des Scifunc-Blocks.
In den Block für die Strecke wird die Übertragungsfunktion eingetragen. Als Zähler die Verstärkung Ks, also 0.72. Im Nenner das Polynom (1+0.11*s) für die Charakteristik der Strecke. Mit ‚Simulate – Run’ wird die Simulation gestartet. Als Ergebnis sollte das Einschwingen der Stellgröße (schwarz) und der Regelgröße (grün), wie in folgender Abbildung erscheinen.

[[Bild:Sprungantwort_DZR.png]]

Man kann nun mit den Reglerparametern und verschiedenen Abtastzeiten spielen, um zu sehen wie sich die Änderungen auswirken. Zum Beispiel wird bei einer Verdopplung der Abtastzeit der Regelkreis bereits instabil.

Diese Beispiele sind nur ein kurzer Auszug von den Möglichkeiten mit Scilab/Scicos für den Einsatz in der Regelungstechnik. Darüber hinaus ist es auch sehr gut geeignet bei anderen Optimierungsverfahren wie z.B. beim WOK-Verfahren (Wurzelortskurven) oder zur Analyse und Optimierung von modernen Reglern wie z.B. Zustandsregler und Kalmanfilter.

===LTspice/SwitcherCad III===
Dieses Programm ist ein SPICE-Derivat von der Firma Linear Technology und ist unter den 2 Namen LTspice und SwitcherCad III bekannt. Der Einfachheit halber wird für die weitere Beschreibung hier nur der Name LTspice verwendet. Das Programm ist Freeware und kann unter diesem Link herunter geladen werden. http://ltspice.linear.com/software/LTspiceIV.exe

LTspice ist ein Simulationsprogramm zur Analyse von elektronischen Schaltungen. Mit LTspice kann sowohl im Zeitbereich als auch im Frequenzbereich analysiert werden und bietet sich dadurch mit den entsprechenden Modellen auch für den Einsatz in der Regelungstechnik an. Wer sich bereits mit SPICE-Programmen auskennt, für den sollte es auch in der Regelungstechnik die 1.Wahl sein.

Der Vorteil von LTspice ist die Möglichkeit einer sehr detaillierten Analyse, vorausgesetzt die Modelle sind auch so detailliert nachgebildet. Insbesondere für analoge Regler, wo die elektrische Schaltung direkt umgesetzt werden kann, empfiehlt sich der Einsatz von LTspice. Der Nachteil ist, LTspice ist nicht auf regeltechnische Belange ausgelegt worden und spezifische Symbole für die Regelungstechnik müssen selbst erstellt werden. Einige selbst erstellte Symbole für dynamische Grundelemente in LTspice sind hier abgebildet.

[[Bild:LTSpiceSymb.png]]

Die 3 Symbole können [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=285 hier] heruntergeladen werden. Weitere Symbole können anhand dieser Beispiele sehr leicht selbst erstellt werden. Ein P-Glied kann durch eine spannungsgesteuerte Spannungsquelle (E-Source) oder Operationsverstärker mit einstellbarer Verstärkung dargestellt werden.

'''Analyse im Zeitbereich'''

Das Beispiel des [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlreglers]] mit analogem Regler wird hier mit LTspice simuliert. Das Schaltbild des Regelkreises zeigt nachfolgende Abbildung.

[[Bild:LTspice_TRAN.png]]

Der Vergleicher (U1) und der analoge PI-Regler (U2) sind so dargestellt, wie es auch in Wirklichkeit ausgeführt werden kann. Da der PI-Regler in der Schaltung bereits invertiert, wurden die Eingänge am Vergleicher vertauscht, damit die Polarität wieder stimmt. Der Rest des Regelkreises wurde stark vereinfacht, kann aber nach Bedarf auch ausführlicher dargestellt werden. Das PT1-Glied U3 simuliert die Strecke des Regelkreises und der Verstärker U4 dient nur zur Umrechnung auf die Drehzahl. Zur Simulation im Zeitbereich wird auf den Führungswert w mit der Spannungsquelle V1 ein Sprung gegeben. In der Reglerschaltung wurde bewusst ein Operationsverstärker mit Versorgungsspannung gewählt, damit auch der Einfluss einer Begrenzung mit simuliert wird. Die Zeitbereichsanalyse wird durch den LTspicebefehl .TRAN erreicht. Die Sprungantwort (Tachospannung) bei diesem Regelkreis sieht dann folgendermaßen aus.

[[Bild:Tacho2.png]]

Durch Ändern der Bauelemente R5, R6 und C1 kann man den Regler optimieren. Eine Umrechnung auf die Reglerparameter Kp und Ki ist mit folgenden Formeln möglich, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5

Ki = 1/(R5*C1)

Mit einem Mausklick auf den entsprechenden Knoten in der Schaltung können noch weitere Signale, wie z.B. die Stellgröße y angezeigt werden. Durch Verändern der Versorgungsspannung V3, V4 kann man sich auch die Auswirkung der Begrenzung ansehen.

'''Analyse im Frequenzbereich'''

Für die Darstellung des Bode-Diagramms der offenen Regelschleife in LTspice muss ein Trick angewendet werden, denn durch das Auftrennen der Regelschleife würde der Arbeitspunkt verloren gehen und dadurch die offene Schleife ohne Gegenkopplung an den Anschlag fahren.

Mit einer zusätzlichen Spannungsquelle in der Schleife kann man dieses Problem umgehen. Die Schleife bleibt für den Erhalt des Arbeitspunktes weiterhin geschlossen und man kann trotzdem die Verstärkung der offenen Schleife durch das Verhältnis der Spannung vor und hinter der Spannungsquelle bestimmen. Das erweiterte Blockschaltbild sieht folgendermaßen aus.

[[Bild:LTspice_AC.png]]

V2 ist die zusätzliche Spannungsquelle für die AC-Analyse. Die Spannungsquelle V1 wird von Pulsform auf Gleichspannung umgestellt. Sie wird so gewählt, dass sich der gewünschte Arbeitspunkt einstellt. Durch den LTspicebefehl .AC wird die Analyse im Frequenzbereich veranlasst. Um das Bode-Diagramm des offenen Regelkreises darzustellen, wird als Kurve nicht ein einzelner Knoten ausgewählt, sondern das Verhältnis der Spannung vom Ende zum Anfang des Regelkreises, in unserem Beispiel also V(tacho)/V(x). Zur Anzeige kommt dann das Bode-Diagramm (grüne Kurve) der offenen Schleife, wie in der folgenden Abbildung zu sehen. Für den Amplitudengang (durchgezogene Linien) gilt die linke Skala in dB, für den Phasengang (gestrichelte Linien) die rechte Skala in Grad.

[[Bild:LTspice_Bode.png]]

Zusätzlich ist noch das Bode-Diagramm der Strecke (rote Kurve) zu sehen. Dies ist durch einfaches Hinzufügen einer weiteren Kurve mit dem Ausdruck V(tacho)/V(y) durchgeführt worden.

Im Gegensatz zur üblichen Darstellung des Bode-Diagramms eines offenen Regelkreises, beinhaltet das mit LTspice erstellte Bode-Diagramm auch die -180 Grad Phasendrehung der Gegenkopplung. Der Phasenrand ist deshalb nicht auf -180 Grad sondern auf 0 Grad zu beziehen. In unserem Beispiel ist der Phasenrand etwa 90 Grad, also ein sehr stabiler Regelkreis. Zu beachten ist, dass die Frequenzachse des Bode-Diagramms wie auch schon bei Scilab in der Einheit Hertz anstatt wie üblich in der Kreisfrequenzeinheit rad/s dargestellt ist.

==Modellierung eines Motors/Antriebs==
[[Bild:ESB_Motor.png|thumb|320px|Ersatzschaltbild DC-Motor]]
Der Motor ist ein oft verwendeter Aktuator in der Robotik. Deshalb wird hier am Beispiel des Gleichstrommotors mit Permanentmagnet (Nebenschlussmotor) die Modellbildung gezeigt. Zur Modellierung gibt es mehrere Möglichkeiten. Je nachdem wie detailliert die Simulation sein soll, kann man sich ein Modell, von sehr einfach bis sehr detailliert, auswählen. Zwei Zeitkonstanten bestimmen die Dynamik eines Gleichstrommotors. Eine davon ist die mechanische Zeitkonstante, die ist meistens die dominierende Zeitkonstante und wird durch das Trägheitsmoment J des Rotors verursacht. Die zweite Zeitkonstante ist die elektrische Zeitkonstante, sie wird durch die Induktivität L bestimmt. Bei einfachen Regelungen kann in den meisten Fällen die elektrische Zeitkonstante vernachlässigt werden, damit reduziert sich das Modell auf ein einzelnes PT1-Glied.

'''Definition: Motor und Antrieb'''

Als '''Motor''' wird hier der Motor alleine verstanden. Die Ausgangsgröße ist die Winkelgeschwindigkeit w (Drehzahl).

Als '''Antrieb''' wird hier der komplette Antrieb eines Fahrzeugs verstanden, also Motor inklusive Getriebe und Masse des Fahrzeugs. Für die Dynamik ist nicht nur das Trägheitsmoment des Motors sondern auch die Masse des Fahrzeugs verantwortlich. Die Ausgangsgröße der Einheit „Antrieb“ ist die Geschwindigkeit v.

Die hier vorgestellten Modelle gelten sowohl für einen Motor als auch für einen kompletten Antrieb, wenn man die Elastizität und das Spiel des Getriebes vernachlässigt.

===Einfaches Modell mit PT1-Glied===
Die einfachste Art einen Motor oder Antrieb zu simulieren, ist mit einem PT1-Glied als Modell. Das Simulationsprogramm [[Regelungstechnik#Scicos|Scicos]] bietet dazu einen Block zur Eingabe der Übertragungsfunktion (num(s)=Zähler, den(s)=Nenner der Übertragungsfunktion).
{| border=0 cellpadding=10
|Übertragungsfunktion:

<math>G(s)=\frac{K}{1+Ts}</math>

|Beispiel:
num(s) = K = 0.72
den(s) = 1 + Ts = 1 + 0.11s
|[[Bild:Scicos_TF.png]]
|}

Wird nicht nur das Ausgangssignal, also die Geschwindigkeit oder Drehzahl in der Simulation benötigt, sondern auch die Beschleunigung, dann kann nachfolgendes Modell verwendet werden. Dieses Modell ist der Differentialgleichung eines PT1-Glieds nachempfunden und liefert das gleiche Ergebnis wie vorheriges Modell, bietet aber noch den Zugriff auf das Beschleunigungssignal.
{| border=0 cellpadding=10
|Differentialgleichung:

<math>v'=\frac{K}{T}U-\frac{1}{T}v</math>

|
v = Geschwindigkeit
v’= Beschleunigung (Ableitung von v)
K = Übertragungsmaß
T = Zeitkonstante
U = Eingangsgröße (z.B. Spannung)
|[[Bild:Antrieb_PT1.png|thumb|Einfaches Modell eines Antriebs]]
|}

Die beiden Parameter K und T müssen ausgemessen werden, wenn sie nicht bekannt sind. Die Zeitkonstante T kann in einem Anlaufversuch ermittelt werden. Dazu wird auf den Motor ein Spannungssprung gegeben und die Sprungantwort am Ausgang nachgemessen. Bei einem Antrieb erspart diese Methode die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente (Motor, Getriebe, Fahrzeug). Bei der Ermittlung des Übertragungsmaß K ist zu beachten, dass sich möglicherweise der Motor durch starke Reibung erst ab einer bestimmten Spannung dreht. Hier ist die Steigung der Kennlinie mit delta v / delta U auszuwerten, wie im folgenden Bild zu sehen ist.

[[Bild:Antrieb_stat.png]]

Die einfachen Modelle gelten nur für den linearen Teil der Kennlinie. Soll auch die Nichtlinearität durch Reibung modelliert werden, dann sind detailliertere Modelle, wie im Folgenden beschrieben, zu verwenden. Die Auswirkung einer Haftreibung ist auch in dem Geschwindigkeitsdiagramm durch die Hysterese in der Kennlinie zu sehen. Beim Hochfahren der Ansteuerspannung bewegt sich das Fahrzeug erst ab ca. 1.25V, während beim Herunterfahren der Ansteuerspannung das Fahrzeug noch bis 0.75V rollt und erst unter 0.75V stehen bleibt.

===Detailliertes Modell===

[[Bild:Motor_Model.png|thumb|350px|Detailliertes Motormodell]]
Ein detailliertes Motormodell ist rechts in dem Bild zu sehen. Es hat auf der linken Seite den elektrischen Teil mit den Parametern R (Widerstand) und L (Induktivität) und auf der rechten Seite den mechanischen Teil mit den Blöcken Trägheitsmoment und Reibung. Der elektrische Teil liefert das Stromsignal i, welches mit der Motorkonstante Km in das Drehmoment M umgerechnet wird. Mit dem folgenden Summierglied kann über einen zusätzlichen Eingang auch ein extern angreifendes Lastmoment mit simuliert werden. Am Ausgang des mechanischen Teils steht die Winkelgeschwindigkeit w in der Einheit [rad/s] bzw. über den Umrechnungsfaktor 9.55 die Drehzahl in [Upm] zur Verfügung. Die Reibung wird in einem nichtlinearen Block mittels Lookup-Table simuliert. In der einschlägigen Literatur wird die Reibung meistens mit einem Dämpfungsfaktor (linear) simuliert, was einer viskosen Reibung entspricht. Das passt aber nicht so gut für Kleinmotoren, da überwiegt vor allem die trockene Reibung. Die trockene Reibung hat ein konstantes Bremsmoment wenn sich der Motor dreht (unabhängig von Drehzahl, Vorzeichen abhängig von Drehrichtung). So eine Funktion kann sehr einfach mit einer Lookup-Table realisiert werden. Die Lookup-Table kann auch dazu verwendet werden, Mischformen von trockener, viskoser und turbulenter Reibung und sogar noch Haftreibung in einem Block zu simulieren, wenn man will.

Bei einigen Herstellern, wie z.B. Faulhaber und Maxon, kann man die für das Modell nötigen Parameter im Datenblatt finden. Das Bremsmoment der Reibung berechnet sich aus dem Leerlaufstrom wie folgt: Bremsmoment = Motorkonstante * Leerlaufstrom

Falls die Daten nicht verfügbar sind, muss man sie selbst ausmessen. Eine Hilfestellung zur Bestimmung der Motorkonstante und des Trägheitsmoments gibt es hier:
*http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=96750&highlight=#96750
*http://www.roboternetz.de/phpBB2/viewtopic.php?t=12793

[[Bild:Antrieb_Modell.png|thumb|350px|Modell eines Antriebs]]

Das detaillierte Motormodell kann auch für einen Antrieb verwendet werden, wenn man eine starre Kopplung zwischen Motor und Antriebsrad voraussetzt, also Elastizität und Spiel des Getriebes vernachlässigt. Anstelle der rotatorischen Kenngrößen (Drehmoment M, Trägheitsmoment J, Winkelgeschwindigkeit w) werden die translatorischen Kenngrößen (Kraft F, Masse m, Geschwindigkeit v) eingesetzt. Das Drehmoment wird mittels Getriebeübersetzung ü und Radius r des Antriebsrades in die entsprechende Vortriebskraft umgerechnet. Daraus ergibt sich die Kraftkonstante Kf, die für das Antriebsmodell verwendet wird.

Die Umrechnung ist: Kf = Km * ü/r

Bei der Trägheitsmasse m muss neben der Masse des Fahrzeugs auch das Trägheitsmoment des Motors mit berücksichtigt werden. Die Umrechnung von Trägheitsmoment in eine äquivalente Masse = J * (ü/r)²

Der Reibungsblock in diesem Modellbeispiel enthält eine Mischform aus Haftreibung, trockener und viskoser Reibung, wie sie typisch für einen Kleinbot mit 2 Antriebsrädern und einem Gleitpin ist.

==Beispiel: Drehzahlregelung==
Es wird ein Gleichstrommotor in der Drehzahl geregelt. Als Sensor ist ein Tachogenerator vorhanden, der direkt auf der Motorwelle sitzt. Das System ist in einem kleinen Modellfahrzeug eingebaut und wird zur Geschwindigkeitsregelung eingesetzt, da die Drehzahl proportional zur Geschwindigkeit ist.

Das Funktionsschaltbild sieht folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl1.gif

Als Störgröße können unterschiedliche Reibwerte oder Steigung und Gefälle rückwirkend über das Getriebe die Drehzahl beeinflussen. Das Getriebe und die Last sind zwar außerhalb der Regelschleife, beeinflussen aber durch die feste Kopplung des Getriebes die Dynamik des Regelkreises. Durch die starre Kopplung kann das Trägheitsmoment des Motors und die Masse des Fahrzeugs zusammengefasst werden. Das Gleiche gilt auch für die Reibwerte. Damit vereinfacht sich die Modellierung und das Blockschaltbild reduziert sich auf folgende Schaltung:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl2.gif

Zur Ermittlung des dynamischen Verhaltens der Regelstrecke wird die Sprungantwort gemessen. Dazu wird auf den Eingang der Regelstrecke (Stellglied) ein Spannungssprung gegeben und die Antwort am Ausgang des Tachogenerators nachgemessen. Diese Methode erspart die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente der Regelstrecke (Motor, Getriebe, Fahrzeug). Die Messung ergab folgende Sprungantwort der Regelstrecke:

http://www.roboternetz.de/wiki/uploads/Main/tacho.gif

Wie zu erwarten, ist die Sprungantwort annähernd ein Verzögerungsglied 1.Ordnung. Die abgelesene Zeitkonstante ist 0.11s. Die Verstärkung der Regelstrecke ist Ks = 0.72. Das Übertragungsmaß des Tachogenerators ist 1V pro 2480Upm. Damit kann auf die Drehzahl rückgerechnet werden.

Da die Regelstrecke nur aus einem PT1-Glied besteht, könnte eine analoge Regelung fast beliebig schnell gemacht werden. Wegen der Begrenzung bringt aber das Ausreizen der Optimierung für das Führungsverhalten nicht viel, nur für das Störverhalten wäre eine schnellere Regelung sinnvoll. Um aber einen Vergleich zwischen analogem und digitalem Regler anstellen zu können wird eine Parametrierung gewählt, die auch für den digitalen Regler mit seiner Totzeit noch stabil ist. Es wird deshalb auch auf einen D-Anteil im Regler verzichtet und nur ein PI-Regler realisiert. Das vereinfachte Blockschaltbild mit den dynamischen Elementen sieht damit folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl3.gif

Zur Veranschaulichung wurde ein analoger als auch ein digitaler Regler realisiert. Die Parametrierung des analogen Reglers wurde mit dem Programm [[Regelungstechnik#LTspice.2FSwitcherCad_III| LTspice]] durchgeführt. Es bot sich an, da die analoge Reglerschaltung exakt simuliert werden konnte. Für die Optimierung des digitalen Reglers wurde dann [[Regelungstechnik#Scicos| Scicos]] verwendet.

===Realisierung mit analogem Regler===
Die elektrische Schaltung für einen analogen PI-Regler ist in der nächsten Abbildung zu sehen. Der erste Operationsverstärker vergleicht den Sollwert w mit dem Istwert x. Der zweite Operationsverstärker bildet den PI-Regler. Die Werte R5, R6 und C1 sind für die Charakteristik des PI-Reglers zuständig. Mit R6 kann der P-Anteil und mit C1 der I-Anteil eingestellt werden. Die Optimierung der Werte wurde empirisch in einer Simulation mit LTspice durchgeführt. Da die Schaltung des PI-Reglers invertiert, wurden zum Ausgleich am Vergleicher die Eingänge an U1 vertauscht, so dass sich über die gesamte Schaltung wieder die richtige Polarität ergibt.

[[Bild:Analogregler.png]]

Zum Umrechnen auf Kp und Ki können diese Formeln verwendet werden, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5 = 18

Ki = 1/(R5*C1) = 147

===Realisierung mit digitalem Regler===
Im digitalen Regelkreis wird der Istwert '''x''' vom Tachogenerator mit einem A/D-Wandler digitalisiert. Der Sollwert '''w''' wird dem µC als digitaler Wert übergeben. Die Stellgröße '''y''' entspricht dem PWM-Wert für den Motortreiber. Um zum analogen Regler vergleichbar zu sein, wurde sowohl für den A/D-Wandler als auch für den PWM-Steller eine 8-Bit-Breite vorgesehen. Damit ist die Verstärkung in beiden Fällen gleich und analoger und digitaler Regler besser vergleichbar.

Eigentlich könnte man bei kleiner Abtastzeit direkt die Parametrierung des analogen Reglers für die digitale Realisierung übernehmen. Aber es gibt doch kleine Unterschiede in der Dynamik zwischen analoger und digitaler Ausführung und um sicher zu gehen, dass die gewählte Abtastzeit einen nicht zu großen Einfluss hat, wird noch einmal mit [[Regelungstechnik#Scicos| Scicos]] nachoptimiert. Mit einer Abtastzeit Ta = 10ms und den Parametern des analogen Reglers ergibt sich ein Überschwingen, das nur sehr langsam auf den Endwert abklingt. Durch Verringern des I-Anteils auf 60 wird ein optimales Einschwingen für den digitalen Regler erreicht. Die Parameter sind:

Kp = 18

Ki = 60

Ta = 0.01

Zur Umsetzung in einen Code wurde die Programmiersprache C gewählt. Da der Code sehr einfach ist, sollte es auch kein Problem sein, den Code als Beispiel für andere Sprachen zu verwenden. Der Algorithmus wird im Takt der Abtastzeit, also alle 10ms aufgerufen. In der Reglergleichung kann zur Vereinfachung das Produkt Ki*Ta durch eine Ersatzvariable, die gleich das Ergebnis aus dem Produkt 60*0.01 = 0.6 hat, ersetzt werden. Zum besseren Verständnis wurde es hier beim Ki*Ta belassen. Um einen Windup-Effekt zu verhindern, wird die Summenbildung esum auf +-400 begrenzt. Der Wert wurde so gewählt, dass noch eine volle Aussteuerung durch den I-Anteil möglich ist. Zum Schluss wird die Stellgröße y auf die mögliche Aussteuerung des Stellglieds (0...255) begrenzt.

'''Programmbeispiel digitaler PI-Regler:'''

<pre>
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
if (esum < -400) {esum = -400;} //Begrenzung I-Anteil
if (esum > 400) {esum = 400;}
y = Kp*e + Ki*Ta*esum; //Reglergleichung
if (y < 0) {y = 0;} //Begrenzung Stellgröße
if (y > 255) {y = 255;}
PWM = y; //Übergabe Stellgröße
</pre>

== Beispiel: Lageregelung ==
Unter einer Lageregelung versteht man die Positionierung von Objekten. Als Beispiel soll hier ein kleiner Bot mit Radencoder eine bestimmte Weglänge fahren. Gegenüber der Drehzahl- oder Geschwindigkeitsregelung ist bei der Lageregelung noch ein zusätzlicher Integrator in der Strecke vorhanden. Die gesamte Strecke ist damit ein I-Glied mit Verzögerung. Laut Tabelle im Abschnitt „Dimensionierung des Reglers“ ist dafür ein PD-Regler gut geeignet. Der PD-Regler wird digital ausgeführt, zur Simulation und Parametrierung bietet sich deshalb Scicos an.

Da bei einer Lageregelung der Geschwindigkeitsbereich von Null aus geht, also über den nichtlinearen Bereich geht, sollte auch in der Simulation die Nichtlinearität berücksichtigt sein. Für das Beispiel wird deshalb das Modell eines Antriebs mit Haft- und Gleitreibung genommen, wie es unter "Modellierung eines Antriebs – detailliertes Modell" bereits vorgestellt wurde. Im Scicos-Modell ist der Antrieb der Übersichtlichkeit wegen als Superblock ausgeführt. Das Blockschaltbild des Antriebs im Detail ist [http://www.roboternetz.de/wissen/images/7/73/Antrieb_Modell.png hier] zu sehen. Die Daten sind:

R = 16 Ohm; L = 6 mH; m = 0.31 kg; Kf = 6.6 N/A

Als Sensor kommt ein Inkrementalgeber zum Einsatz, allerdings muss der richtungssensibel sein, sonst ist keine Lageregelung möglich. Der Sensor wird in Scicos mit der Rundungsformel (round(u1*500)) simuliert. Das ergibt bei einer Auflösung von 2mm ganzzahlige Schritte, wie es auch die Hardware (Inkrementalgeber mit nachfolgendem Zähler) in Wirklichkeit macht.

[[Bild:Lageregelung.png]]

Nach dem Regler folgt ein Block mit der Verstärkung (5/255), der den PWM-Wert auf die Ansteuerspannung für den Motor umsetzt. Der Bruch 5/255 entspricht der Ansteuerspannung von 5V bei PWM=255. Der PD-Regler kann damit in Scicos exakt so simuliert werden, wie er schlussendlich auch als C-Code umgesetzt wird. Dazu wird der Code des PD-Reglers als Funktion in den Scifunc-Block eingegeben. Der Code ist etwas unterschiedlich zum C-Code des realen Bots, da die Syntax in Scicos doch geringfügig anders ist und die Eingangs- und Ausgangsvariablen nur bestimmte Bezeichnungen haben dürfen. Im nachfolgenden Codefenster sind beide Varianten im Vergleich zu sehen.
{|
| '''Scifunc-Code:'''
<pre>

y1=Kp*u1+Kd/Ta*(u1-z);
z=u1;
if y1>255 then
y1=255;
end
if y1<-255 then
y1=-255;
end
</pre>
| '''C-Code für µC:'''
<pre>
e = w - x;
y = Kp*e + Kd/Ta*(e-ealt);
ealt = e;
if (y > 255) {
y = 255;
}
if (y < -255) {
y = -255;
}
</pre>
| '''Kommentar:'''
<pre>
Vergleich
PD-Reglergleichung
alten Wert speichern

pos. Begrenzung

neg. Begrenzung

</pre>
|}

In der praktischen Umsetzung des C-Codes wird man den Bruch Kd/Ta durch eine Ersatzvariable oder Konstante ersetzen. Dabei ergibt sich (wie in diesem Beispiel 2/0.01 = 200) meistens ein ganzzahliger Wert, was sich positiv auf die Rechenzeit auswirkt.

Für die Abtastzeit Ta wurde 10ms gewählt. Das ist einerseits nicht zu schnell für einen µC und andererseits nicht zu lang, um die Regelung unnötig zu verlangsamen. Die Parametrierung von Kp und Kd erfolgte empirisch durch Probieren in der Simulation. Begonnen wurde mit einem reinen P-Regler und kleinem P-Anteil (Kp=1, Kd=0). In groben Schritten wurde Kp solange erhöht, bis sich deutlich Überschwinger zeigten. Dann wurde ein D-Anteil hinzugefügt und Kd so variiert, dass der Überschwinger verschwindet. Mit ein bisschen Feintuning ergaben sich so die Werte Kp=61 und Kd=2. Das Simulationsergebnis für Ansteuerspannung, Geschwindigkeit und Weg sieht damit folgendermaßen aus:

[[Bild:Lage_antwort.png]]

==Autoren==
* [[Benutzer:Waste|Waste]]

==Siehe auch==
* [[SwitcherCAD-Tutorial]]

== External links ==
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=11818 Post: Line follower with PID controller]
*[http://www.scicos.org/ Scicos Homepage]
* [http://www.scicoslab.org/ ScicosLab Homepage]
* [http://www.scilab.org/ Scilab Homepage]
* [http://ltspice.linear.com/software/swcadiii.exe LTspice / SwitcherCAD III Download]
* [http://www.kahlert.com/web set_download.php demo version of WinFACT 7]
* [http://www.physi.uni-heidelberg.de/fp/anleitg/E01.pdf instructions for electronic placement, the last part is based PID controller]
* [http://www.simapp.com/ SimApp website] with trial
* [http://www.expertcontrol.com/ ExpertControl Homepage, Automatische Reglerauslegung mit ecICP] ecICP-Trial über Support-Seite verfügbar
* [http://www.me.th-mittelhessen.de/personen/professoren/orlowski/simulation-regelungstechnik/ TH-Mittelhessen Prof. Peter F. Orlowski, Simulationsprogramm SIMLER-PC]

[[Category: Microcontroller]]
[[Category: Software]]
[[Category: Elektronik]]

Datei:Pidregler.gif

2014-09-13T08:14:13Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/pidregler.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/pidregler.gif

Datei:Pdregler.gif

2014-09-13T08:13:22Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/pdregler.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/pdregler.gif

Datei:Piregler.gif

2014-09-13T08:12:51Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/piregler.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/piregler.gif

Datei:Iregler.gif

2014-09-13T08:12:27Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/iregler.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/iregler.gif

Datei:Pregler.gif

2014-09-13T08:11:59Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/pregler.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/pregler.gif

Regelungstechnik

2014-09-13T08:02:59Z

SprinterSB: /* Die Regelstrecke */ wikify: pglied.gif, iglied.gif, ttglied.gif, pt1glied.gif, pt2aglied.gif, pt2bglied.gif

'''Regelungen''' sind ein Bestandteil unseres Lebens und das nicht nur seit Erfindung der Dampfmaschine.

Allein schon der aufrechte Gang funktioniert nur mit Regelung. Dabei wirken die Sinne als Sensoren, das Gehirn als Regler und die Muskeln als Aktuatoren. Weitere Regelungen in unserem Körper sind z.B. die Konstanthaltung der Körpertemperatur, der Blutdruck, die Anpassung der Pupille auf Helligkeitsänderungen usw.

Im technischen Zeitalter ist der erste geschichtlich bedeutende Regler der Fliehkraftregler von James Watt, der für die Drehzahlregelung seiner Dampfmaschine eingesetzt wurde. Seitdem ist die Regelungstechnik aus keinem Technikbereich mehr wegzudenken. Die Regelungstechnik begegnet uns im täglichen Leben auf Schritt und Tritt: Der Temperaturregler der Zentralheizung, der Temperaturregler des Kühlschranks, der Regler für die Belichtungsautomatik im Fotoapparat, das ABS-System im Auto und die Netzspannungs- und Frequenzregelung des europäischen Versorgungsnetzes sind nur einige wenige Beispiele aus diesem Bereich.

''Autor Waste''

==Einleitung==

Der Begriff ''Regelung'' ist zu unterscheiden von dem im allgemeinen Sprachgebrauch oft synonym gebrauchten Begriff der ''Steuerung''. Das Steuern ist ein rein vorwärts gerichteter Prozess ohne Rückkopplung. Die Ausgangsgröße wird dabei nicht überwacht und kann sich durch Störungen von außen verändern. Ein Beispiel ist die Steuerung eines Motors mit einer einstellbaren Spannung. Durch Laständerungen wird sich die Drehzahl des Motors ändern. Soll nun die Drehzahl konstant gehalten werden, bedarf es einer Rückkopplung um über die Spannung die Drehzahl anzupassen. Diese Rückkopplung ist das Kennzeichen einer Regelung.

Das Regeln ist ein Vorgang, bei dem die Ausgangsgröße, im Beispiel die Drehzahl, fortlaufend überwacht wird und bei Abweichung über die Stellgröße, im Beispiel die Spannung, korrigiert wird. Der sich dabei ergebende Wirkungsablauf findet in einem geschlossenen Kreis, dem Regelkreis, statt.

==Der Regelkreis==

[[Bild:Regelkreis1.png|right|thumb|300px|Ein Regelkreis (Prinzip)]]

Das Prinzip einer Regelung ist das fortlaufende: '''Messen – Vergleichen – Stellen'''

;Messen: Die Regelgröße wird direkt oder mittels Sensoren gemessen.
;Vergleichen: Der Wert der Regelgröße wird mit dem Sollwert verglichen. Die Differenz ist die ''Regelabweichung''.
;Stellen: Aus der Regelabweichung wird unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke die ''Stellgröße'' bestimmt.

{{Absatz}}

[[Bild:Regelkreis2.png|thumb|350px|Wirkunsweise einer Regelung]]

Ein Regelkreis dient dazu, eine vorgegebene physikalische Größe, die ''Regelgröße'', auf einen gewünschten Wert (Sollwert) zu bringen und dort zu halten, unabhängig von eventuell auftretenden Störungen.
Um die Regelungsaufgabe zu erfüllen, muss der Augenblickswert der Regelgröße – der Istwert – gemessen und mit dem Sollwert verglichen werden. Bei auftretenden Abweichungen muss in geeigneter Art und Weise nachgestellt werden.

Um nun diese Aufgabe technisch zu lösen, gibt es die Regelungstechnik. Sie baut im wesentlichen auf die mathematische Beschreibung und Modellbildung des Systems Regelkreis. Zur Modellierung, Beschreibung und Simulation werden Blockschaltbilder mit diskreten Signalgliedern verwendet.

{{Absatz}}

[[Bild:Regelkreis3.png|thumb|350px|Beispiel einer Geschwindigkeitsregelung]]

Ein typisches Beispiel für einen Regelkreis – eine Geschwindigkeitsregelung – wird im nebenstehenden Bild gezeigt. Die Sollgeschwindigkeit ist 80 km/h. Durch eine äußere Störung, in dem Fall eine Steigung, verlangsamt sich das Fahrzeug auf 70 km/h. Die Abweichung wird durch das Tachometer erfasst. Als Korrekturmaßnahme wird mehr Gas gegeben, um wieder auf die Sollgeschwindigkeit von 80 km/h zu kommen.

{{Absatz}}

=== Begriffe ===

[[Bild:Regelkreis4.png|right]]

Ein Regelkreis besteht entsprechend des vereinfachten Blockschaltbildes, wie es oft in der Regelungstechnik verwendet wird, aus den Hauptteilen ''Regler'' und ''Regelstrecke'':

;Regler: Ist der Teil des Regelkreises, der unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke aus der Regelabweichung die Korrekturmaßnahmen zum Ausregeln ergreift.

;Regelstrecke: Ist der Teil des Regelkreises, der vom Regler ausgeregelt werden soll.

;Führungsgröße (Sollwert) w: Vorgegebener Wert, auf dem die Regelgröße durch die Regelung gehalten werden soll. Sie ist eine von der Regelung nicht beeinflusste Größe und wird von außen zugeführt.

;Regelgröße (Istwert) x: Ist die Ausgangsgröße der Regelstrecke, die zum Zweck des Regelns erfasst und zum Vergleich rückgeführt wird. In vielen Fällen ist in der Rückführung noch eine Messeinrichtung (Sensor) gezeichnet, die den Istwert erfasst, hier der Einfachheit halber weggelassen.

;Regelabweichung e: Differenz zwischen Führungsgröße und Regelgröße '''e = w – x''', bildet die eigentliche Eingangsgröße des Reglers.

;Stellgröße y: Ausgangsgröße der Regeleinrichtung und zugleich Eingangsgröße der Strecke. Sie überträgt die steuernde Wirkung des Reglers auf die Strecke.

;Störgröße z: Eine von außen wirkende Größe, die eine Änderung des Istwertes der Regelgröße bewirkt und einen Regelvorgang auslöst.

==Die Regelstrecke==
Die Regelstrecke stellt den zu regelnden Teil bzw. den zu regelnden Prozess dar und umfasst normalerweise eine Reihe von einzelnen Gliedern. Die Glieder werden entsprechend ihrem Zeitverhalten charakterisiert. Um das Zeitverhalten herauszufinden, legt man an den Eingang ein Testsignal an und zeichnet die Antwort auf. Im einfachsten Fall wird der Eingang mit einer sprunghaften Änderung beaufschlagt. Die Antwort auf die sprunghafte Änderung der Eingangsgröße wird Sprungantwort genannt und gibt Aufschluss über die Art der Regelstrecke und kann eventuell bereits genutzt werden, um die Parameter der Regelstrecke zu bestimmen.

Für den Aufbau eines gut funktionierenden Regelkreises und die Auslegung von Reglern ist es eine Voraussetzung zu wissen, wie die Regelstrecke reagiert. Ohne ein genaues Wissen um das dynamische Verhalten der Regelstrecke ist es nicht möglich geeignete Regler auszuwählen und diese zu parametrieren.

Die wichtigsten dynamischen Grundelemente zur Charakterisierung der Regelstrecke sind nachfolgend aufgelistet. Jedes Element wird mit einem Block dargestellt und darin durch ein Symbol oder der stilisierten Sprungantwort gekennzeichnet.

----

===Proportionalglied (P-Glied)===
[[File:pglied.gif]]

Die einfachste Art einer Regelstrecke.
;Beispiele: Hebel, Getriebe, Verstärker, Spannungsteiler, Sensoren bei denen das Zeitverhalten vernachlässigt werden kann

----

===Integrator (I-Glied)===
[[File:iglied.gif]]

Strecke ohne Ausgleich, ist häufig in Regelstrecken vorhanden.
;Beispiele: Beschleunigung → Geschwindigkeit → Weg, Strom → Kondensatorspannung

----

===Verzögerungsglied 0.Ordnung (Totzeitglied)===
[[File:ttglied.gif]]

Entsteht durch Laufzeiten von Material oder Signalen. Je größer die Verzögerungszeit einer Regelstrecke ist, um so schwieriger ist sie zu regeln.
;Beispiele: Förderband, Rechenzeit, A/D-Wandler

Nicht zu verwechseln mit der Totzeit, die durch das asynchrone Auftreten eines Ereignisses auf einen Zyklus entsteht. Vom Verzögerungsglied 0.Ordnung unterscheidet sich diese dadurch, daß sie mit einer gleichverteilten Wahrscheinlichkeit zwischen "gar nicht" und dem gesamten Umfang auftritt. Diese Totzeit ist mechanisch mit einem Spiel vergleichbar das "gar nicht" bis zum vollen Umfang zu einem Fehler beiträgt.
;Beispiele: Erkennen eines Signals an einem Mikroprozessor

----

===Verzögerungsglied 1.Ordnung (PT1-Glied)===
[[File:pt1glied.gif]]

Viele einfache Regelstrecken haben ein solches Verhalten bzw. können näherungsweise damit beschrieben werden. Ist ein P-Glied mit nicht vernachlässigbarem Zeitverhalten.
;Beispiele: Gleichstrommotor (Spannung → Drehzahl), näherungsweise; Widerstand-Kondensator-Schaltung (RC-Glied)

----

===Verzögerungsglied 2.Ordnung (PT2-Glied)===
Man unterscheidet schwingungsfähige und nicht schwingungsfähige PT2-Glieder. Zur Charakterisierung gibt es die Parameter Dämpfung D und Eckfrequenz w<sub>0</sub> oder die Zeitkonstanten T<sub>1</sub> und T<sub>2</sub>. Für Dämpfung D<1 ist es schwingungsfähig.

'''Schwingfähiges PT2-Glied:'''<br/>
[[File:pt2aglied.gif]]
;Beispiele: Mechanischer Schwinger (Feder-Masse-System), elektrischer Schwingkreis (RLC-Kreis)

'''Nicht schwingfähiges PT2-Glied:'''<br/>
[[File:pt2bglied.gif]]
;Beispiele: Zwei hintereinander geschaltete PT1-Glieder, Gleichstrommotor (Spannung → Drehzahl) mit berücksichtigter Induktivität

==Der Regler==
Der Regler hat die Aufgabe, die Regelgröße zu messen, sie mit dem Sollwert zu vergleichen und bei Abweichungen die Stellgröße so zu verändern, dass Soll- und Istwert der Regelgröße wieder übereinstimmen bzw. die Differenz minimal wird.

Die Wahl eines bestimmten Reglertyps richtet sich nach dem geforderten Zeitverhalten und der geforderten Regelgenauigkeit der Regelstrecke. Nachfolgend finden Sie eine Zusammenfassung der wichtigsten klassischen Reglertypen:

===P-Regler===
Der proportionalwirkende Regler multipliziert die Regelabweichung mit seinem Verstärkungsfaktor '''Kp''' und gibt das Ergebnis unverzögert weiter. Er unterscheidet sich prinzipiell nicht vom dynamischen Element P-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der P-geregelte Kreis ist einfach und mittelschnell im Vergleich zu anderen Regelungen. Das Problem ist die bleibende Regelabweichung!

http://www.roboternetz.de/wiki/uploads/Main/pregler.gif

'''Software P-Regler:'''
y = Kp * e

----

===I-Regler===
Der integralwirkende Regler summiert die Regelabweichung über der Zeit auf und multipliziert die Summe (d.h. das Integral) mit dem Faktor '''Ki'''. Je länger eine Regelabweichung ansteht, desto größer wird die Stellgröße des I-Reglers. Er unterscheidet sich prinzipiell nicht vom dynamischen Element I-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der I-geregelte Kreis ist langsam im Vergleich zu anderen Regelungen. Er hat aber den Vorteil, dass die Abweichung vollständig eliminiert wird.

http://www.roboternetz.de/wiki/uploads/Main/iregler.gif

'''Software I-Regler:'''
esum = esum + e
y = Ki * Ta * esum

'''esum''' ist die Summe aller bisherigen Abweichungen '''e'''. Der Parameter des Software I-Reglers ist abhängig von der Rechenschrittweite '''Ta''' (Abtastzeit). Je öfter gerechnet wird, desto öfter wird auch hinzugezählt (aufintegriert). Eine kleine Abtastzeit erfordert also einen kleineren Faktor, dies wird durch die Multiplikation mit '''Ta''' verwirklicht.

----

===PI-Regler===
Der PI-Regler ist die Kombination aus P- und I-Regler und kombiniert den Vorteil des P-Reglers, nämlich schnelle Reaktion, mit dem Vorteil des I-Reglers, der exakten Ausregelung. Der PI-geregelte Kreis ist also genau und mittelschnell.

http://www.roboternetz.de/wiki/uploads/Main/piregler.gif

'''Software PI-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum

----

===PD-Regler===
Der proportional-differential wirkende Regler kombiniert den P-Regler mit einem D-Anteil.
Der D-Anteil bewertet die Änderung einer Regelabweichung (er differenziert) und berechnet so deren Änderungsgeschwindigkeit. Diese wird mit dem Faktor '''Kd''' multipliziert und zum P-Anteil hinzuaddiert. Der PD-Regler reagiert damit schon auf Ankündigungen von Veränderungen, das bewirkt sozusagen ein Vorhalten beim Regeln.

Der PD-geregelte Kreis ist sehr schnell im Vergleich zu anderen Regelungen, und manche Regelkreise (solche mit zweifacher Integration) sind ohne D-Anteil überhaupt nicht stabilisierbar. Das Problem der proportionalen Regler, die bleibende Regelabweichung, ist beim PD-Regler allerdings weiterhin vorhanden!

Ein Nachteil aller Regler mit D-Anteil kann die Unruhe im Kreis sein. Ist das Sensorsignal verrauscht, so wird dieses Rauschen durch die Differenziation weiter verstärkt und wieder in den Kreis hineingegeben. Dadurch wird der Aktuator stärker belastet. Macht der Regler insbesondere sehr hohe Ausschläge als Folge von schnellen Änderungen des Sollwertes, dann kann es sein, dass das Stellglied oder der Aktuator diese nicht umsetzen kann - die Wirkung des D-Anteils würde dann durch die Begrenzung verpuffen, und das Einschwingverhalten wäre nicht wie berechnet, sondern meist langsamer. Dies gilt aber nur für große Sprünge. Bei den normalen kleinen Regelvorgängen zum Ausgleich von Störeinflüssen wirkt der D-Anteil wie beabsichtigt.

http://www.roboternetz.de/wiki/uploads/Main/pdregler.gif

'''Software PD-Regler:'''
y = Kp * e + Kd * (e – ealt)/Ta
ealt = e

Mit der neuesten Regelabweichung '''e''' und der vorhergehenden '''ealt''' wird der D-Anteil berechnet. Die Differenziation erfolgt damit angenähert durch Bildung des Differenzquotienten (e - ealt)/Ta.

----

===PID-Regler===
Der PID Regler ist der universellste der klassischen Regler und vereinigt die guten Eigenschaften der anderen Regler. Zur Beschreibung der Eigenschaften des P-, I- und D-Anteils siehe die anderen Reglertypen. Der PID-geregelte Kreis ist genau und sehr schnell. In den meisten Anwendungen kommt deshalb der PID-Regler zum Einsatz.

http://www.roboternetz.de/wiki/uploads/Main/pidregler.gif

'''Software PID-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum + Kd * (e – ealt)/Ta
ealt = e

'''Alternative PID-Reglerstruktur:'''

Es gibt 2 Darstellungsmöglichkeiten, die inhaltlich identisch sind. In der analogen Regeltechnik ist noch die Darstellung mit der Nachstellzeit '''Tn''' und der Vorhaltezeit '''Tv''' üblich. Die Umrechnung zwischen den beiden Strukturen ist mit den angegebenen Formeln möglich.

[[Bild:PIDstruktur.gif]]

==Vergleich der Reglertypen==
In der folgenden Abbildung ist der Vergleich von P-, I-, PI-, PD- und PID-Regler in einem Regelkreis mit PT2-Glied als Regelstrecke dargestellt. Es ist deutlich zu sehen, dass die Regler ohne I-Anteil (P und PD) eine bleibende Regelabweichung aufweisen. Erst die Regler mit I-Anteil können auf den Endwert von 1 ausregeln. Beim reinen I-Regler geht das so langsam, dass es gar nicht mehr auf dem Diagramm zu sehen ist. Der Hauptzweck eines I-Anteils ist also die Vermeidung bleibender Regelabweichungen. Daher ist ein
I-Anteil normalerweise nicht nötig, wenn die Strecke schon einen I-Anteil besitzt.
Ausnahme: Es wird ein doppelter I-Anteil zur Vermeidung von Schleppfehlern benötigt.

Die schnellsten Regler sind die mit einem D-Anteil (PD und PID). Der D-Anteil kommt deshalb hauptsächlich zum Einsatz, wenn schnelle Dynamik gefragt ist oder die Strecke selbst schon instabil ist. Voraussetzung für die Schnelligkeit ist allerdings, dass keine Begrenzung im Stellglied oder Aktuator auftritt. In der Praxis ist eine Begrenzung meistens nicht zu vermeiden, deshalb gilt die Sprungantwort in der Praxis nur für kleine Sprünge.

Die Regler ohne D-Anteil, aber mit P-Anteil (P und PI) sind mittelschnell. Für einfache Regelaufgaben reicht auch oft schon ein reiner P-Regler aus, wenn die bleibende Regelabweichung vernachlässigt werden kann oder weil die Strecke schon einen I-Anteil besitzt.

http://www.roboternetz.de/wiki/uploads/Main/vergleich.gif

Aus diesem Vergleich wird klar, warum der PID-Regler so beliebt ist, er vereinigt die Vorzüge aller anderen Regler.

==Digitaler Regler==
Durch die Einführung leistungsfähiger und preiswerter Mikroprozessoren hat sich der digitale Regler mehr und mehr durchgesetzt. Im Gegensatz zum analogen Regler werden die Signale nicht mehr analog mit Operationsverstärker verarbeitet, sondern mit einem Mikroprozessor errechnet. Bevor das Signal vom Mikroprozessor bearbeitet werden kann, muss zunächst das Eingangssignal (Istwert) mit einem Analog-Digital-Umsetzer (ADU) digitalisiert werden, d.h. in einen Zahlenwert umgewandelt werden. Das vom digitalen Regler errechnete Ausgangssignal (Stellgröße) wird wiederum zur Ansteuerung des Stellglieds mit einem Digital-Analog-Umsetzer (DAU) in ein analoges Signal gewandelt. Funktionell unterscheiden sich analoger und digitaler Regler jedoch nicht wesentlich, es müssen nur die Schnittstellen angepasst werden.

[[File:digreg.gif|right|framed|Digitaler Regler (Prinzip)]]

Da die Wandlungen und das Regelprogramm eine gewisse Zeit beanspruchen, vergeht pro Durchlauf die sogenannte Takt- oder Abtastzeit. Diese Zeit wirkt sich im Regelkreis wie ein Totzeitglied mit der halben Abtastzeit als Totzeit aus. Das verursacht eine zusätzliche Phasenverschiebung, was sich ungünstig auf die Stabilität des Regelkreises auswirken kann. Ist die Abtastzeit sehr viel kleiner als die dominierende Zeitkonstante der Strecke, dann spricht man von quasi-kontinuierlichem Verhalten, da sich der digitale Regler ähnlich wie ein analoger Regler verhält. Der digitale Regler kann dann wie ein analoger dimensioniert werden. Ist die Abtastzeit größer, kann sie nicht mehr vernachlässigt werden, dann muss sie auch beim Reglerentwurf berücksichtigt werden.

'''Vorteile digitaler Regler:'''
* Die Verarbeitung erfolgt driftfrei.
* Es lassen sich nichtlineare Kennlinien, intelligentes Verhalten oder adaptive Regelung leichter realisieren.
* Der Regler kann bei Bedarf per Software neu konfiguriert und parametriert werden

'''Digitale Realisierung am Beispiel des PID-Algorithmus'''

Ausgehend von der Differentialgleichung für kontinuierliche Systeme wird die Differenzengleichung für zeitdiskrete Systeme erstellt. Daraus folgt dann der Stellungsalgorithmus in allgemeiner Form.

Ta = Abtastzeit; k = Nummer der Abtastung

Kp = Proportionalbeiwert; Ki = Integrierbeiwert; Kd = Differenzierbeiwert



'''Differentialgleichung für den kontinuierlichen PID-Regler:'''
:<math>
y(t) \;=\; Kp \!\cdot\! e(t)
+ Ki \int_0^t e(\tau) \, d\tau
+ Kd \, \frac{de(t)}{dt}
</math>

'''Differenzengleichung für den zeitdiskreten PID-Regler:'''
:<math>
y_k \;=\; Kp \!\cdot\! e_k
+ Ki \!\cdot\! Ta \sum_{i=0}^k e_i
+ \frac{Kd}{Ta}\, ( e_k - e_{k-1} )
</math>

'''PID Stellungs-Algorithmus:
:''' <math>
y_k \;=\; y_{k-1}
+ q_0 \!\cdot\! e_k
+ q_1 \!\cdot\! e_{k-1}
+ q_2 \!\cdot\! e_{k-2}
</math>

Mit den Parametern:
:<math>
q_0 \,=\, Kp + Ki \!\cdot\! Ta + \frac{Kd}{Ta}
\, , \quad
q_1 \,=\, -Kp - 2 \, \frac{Kd}{Ta}
\, , \quad
q_2 \,=\, \frac{Kd}{Ta}
</math>

'''Umsetzung in Code nach der Differenzengleichung:'''

Im Code wurden einige Variablen umbenannt, da die Indexschreibweise nicht möglich ist.

y entspricht y<sub>k</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, esum ist die Summenbildung

In der Praxis wird man die Ausdrücke Ki*Ta und Kd/Ta vorab berechnen und mit Ersatzvariablen in die Reglergleichung einsetzen. Der Verständlichkeit halber wurde es hier im Code belassen. Des weiteren kann eine Begrenzung von esum notwendig werden, um einen Variablenüberlauf oder Windup-Effekt zu vermeiden.

Der nachfolgende Code wird im Rhythmus der Abtastzeit Ta immer wieder aufgerufen.
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
y = Kp*e + Ki*Ta*esum + Kd/Ta*(e – ealt); //Reglergleichung
ealt = e;
----

'''Alternative Umsetzung in Code nach dem Stellungsalgorithmus:'''<br/>
y entspricht y<sub>k</sub>, yalt entspricht y<sub>k-1</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, ealt2 entspricht e<sub>k-2</sub>
e = w - x; //Vergleich
y = yalt + q0*e + q1*ealt + q2*ealt2; //Reglergleichung
ealt2 = ealt;
ealt = e;
yalt = y;

==Dimensionierung des Reglers==
Die Auswahl des Reglertyps ist heutzutage bei den digitalen Reglern nicht mehr so kritisch, da der Mehraufwand in Software für einen PID-Regler gegenüber einfacheren Typen kaum zu Buche schlägt. Im Prinzip ist man deshalb mit einem PID-Regler fast immer auf der richtigen Seite, mit einer Ausnahme, bei einer Strecke mit reiner Totzeit. Die folgende Tabelle gibt eine Hilfestellung zur Auswahl des Reglers.

{| border=1 cellpadding=4
|+ '''Geeignete Reglertypen für die unterschiedlichen Regelstrecken'''
|rowspan=2 |'''Strecke'''
|colspan=4 |<div align="center">'''Regler'''</div>
|-
|<div align="center">'''P'''</div>
|<div align="center">'''PD'''</div>
|<div align="center">'''PI'''</div>
|<div align="center">'''PID'''</div>
|-
|reine Totzeit
| 
| 
|<div align="center">geeignet</div>
| 
|-
|1.Ordnung mit kleiner Totzeit
| 
| 
|gut geeignet
|gut geeignet
|-
|2.Ordnung mit kleiner Totzeit
| 
| 
| 
|gut geeignet
|-
|höhere Ordnung
| 
| 
| 
|gut geeignet
|-
|I-Glied und Verzögerung
|geeignet
|gut geeignet
|<div align="center">geeignet</div>
|gut geeignet
|}

Nachdem man einen geeigneten Reglertyp ausgewählt hat, stellt sich noch die Frage, wie man die Reglerparameter Kp, Ki, und Kd optimiert. Im Laufe der Zeit wurden viele Methoden zur Dimensionierung der Reglerparameter entwickelt, aber es können hier nicht alle aufgelistet werden. Diese Aufzählung beschränkt sich auf die einfacheren und gängigen Methoden der Parametrierung.

===Dimensionierung durch Probieren (Empirisches Einstellen)===

====Methode 1====
Diese Methode ist geeignet um einfache Systeme zu dimensionieren, insbesondere wenn man bereits Erfahrung mit ähnlichen Regelkreisen hat. Man fängt mit einer unkritischen Einstellung (Kp klein, Ki = 0, Kd = 0) an und erhöht langsam die Verstärkung Kp, bis die Dämpfung schlecht wird. Falls eine Schwingneigung auftritt, muss die Verstärkung wieder etwas zurück genommen werden. Dann nimmt man allmählich den Integralanteil hinzu, erhöht ihn in Schritten und probiert solange herum, bis das Ergebnis einigermaßen passt. Bei Bedarf kann noch ein D-Anteil (PID-Struktur) probiert werden. Wenn dabei die Regelung stabiler wird, kann noch mal Kp und Ki erhöht werden, bis man endgültig zufrieden ist.

====Methode 2====
Alle Anteile erstmal auf 0. Dann erhöht man Kp so lange bis das System deutlich schwingt. Danach wird der Kd so lange erhöht bis das System nicht mehr schwingt. Anschliessend kann noch ein kleiner Ki Anteil hinzugegeben werden.

Es dürfte klar sein, dass so eine Optimierung im Blindflug nicht immer das Optimum ergibt, aber es ist eine gängige praktische Methode zur Ermittlung der Reglerparameter. Besser sieht es aus, wenn in einer Simulation empirisch optimiert wird. Zusätzliche Informationen über die Stabilität erlauben hierbei eine gezieltere Optimierung. Zudem ist das Probieren im Simulator gefahrlos möglich, was in der Realität nicht immer der Fall ist. Geeignete Programme zur Simulation sind [[Regelungstechnik#Hilfsprogramme_zur_Analyse_und_Optimierung| hier]] vorgestellt. Allerdings muss für eine Simulation die Regelstrecke bekannt sein. Ist das nicht der Fall, so bleibt nur das einfache Probieren oder das Einstellen nach der Schwingungsmethode wie im folgenden beschrieben.

===Dimensionierung nach Einstellregeln===
Die Dimensionierung nach Rezept ist eine praktische Methode ohne viel Rechnerei und Hilfsmittel, eine Methode also für den Praktiker. Die bekanntesten Einstellregeln sind von Ziegler/Nichols und von Chien/Hrones/Reswick. Darüber hinaus gibt es noch eine Vielzahl anderer Einstelltabellen, auf die hier aber verzichtet wird, das würde den Rahmen dieses Artikels sprengen. An der Vielzahl kann man schon ersehen, dass es kein universell gültiges Rezept gibt und mit diesen Tabellen nicht unbedingt das Optimum erreicht wird, eine Nachoptimierung kann nötig sein.

Bei Ziegler/Nichols unterscheidet man noch zwischen der Schwingungsmethode und der Einstellung nach der Sprungantwort.

'''Einstellung nach der Schwingungsmethode:'''<br/>
Bei der Schwingungsmethode nach Ziegler/Nichols werden die Reglerparameter so verstellt, dass die Stabilitätsgrenze erreicht wird und der Regelkreis zu schwingen beginnt, d.h. die Regelgröße periodische Schwingungen ausführt. Aus der so gefundenen Einstellung können die Reglerparameter ermittelt werden. Dieses Verfahren ist nur auf Regelstrecken anwendbar, bei denen ein Schwingen keinen Schaden anrichtet und die überhaupt instabil gemacht werden können. Die Vorgehensweise ist folgende:
# Einstellung des Reglers als reinen P-Regler: Ki = 0 und Kd = 0
# Die Reglerverstärkung Kp wird solange vergrößert, bis sich der geschlossene Regelkreis an der Stabilitätsgrenze befindet und Dauerschwingungen ausführt.
# Der dabei eingestellte Wert Kp wird als Kp<sub>krit</sub> bezeichnet.
# Die Periodendauer der sich einstellenden Dauerschwingung T<sub>krit</sub> wird gemessen.
# Anhand der folgenden Tabelle werden dann die Reglerparameter bestimmt.

{| cellpadding=10
|
{| border=1 cellpadding=4
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|0.5*Kp<sub>krit</sub>
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.45*Kp<sub>krit</sub>
|<div align="center">0.85*T<sub>krit</sub></div>
| 
|-
|<div align="center">'''PID'''</div>
|0.6*Kp<sub>krit</sub>
|0.5*T<sub>krit</sub>
|0.12*T<sub>krit</sub>
|}
|
{| border=0 cellpadding=4
|'''Ki = Kp/Tn'''
|-
|'''Kd = Kp*Tv'''
|}
|}

Der Vorteil dieses Verfahrens liegt darin, dass die Untersuchung während des Betriebes und ohne Öffnen des Regelkreises durchgeführt werden kann. Der Nachteil an dem Verfahren ist, dass es nur auf Strecken angewendet werden kann, die auch zum Schwingen gebracht werden können.

'''Einstellung nach der Sprungantwort:'''<br/>
Diese Methode der Parameterbestimmung beruht auf der Aufnahme der Sprungantwort der Regelstrecke. Es eignet sich auch für Strecken, die nicht zum Schwingen gebracht werden können. Der Regelkreis muss allerdings geöffnet werden.
Vorgehensweise: Es wird die Sprungantwort aufgenommen und durch Einzeichnen der Wendetangente die Verzugszeit Tu und die Ausgleichszeit Tg ermittelt.

[[Bild:Tu_Tg.gif]]

Mit den so festgestellten Werten werden die Parameter für den einzusetzenden Regler gemäß nachstehenden Tabellen ermittelt.

{| cellpadding=10
|
{| border=1 cellpadding=4
|+ Einstellregeln nach Ziegler/Nichols:
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|1/Ks*Tg/Tu
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.9/Ks*Tg/Tu
|3.3*Tu
| 
|-
|<div align="center">'''PID'''</div>
|1.2/Ks*Tg/Tu
|2*Tu
|0.5*Tu
|}
|
|
{| border=1 cellpadding=4
|+ Einstellregeln nach Chien/Hrones/Reswick
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|0.3/Ks*Tg/Tu
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.35/Ks*Tg/Tu
|1.2*Tg
| 
|-
|<div align="center">'''PID'''</div>
|0.6/Ks*Tg/Tu
|<div align="center">Tg</div>
|0.5*Tu
|}
|}

{| cellpadding=10
|
{| border=1 cellpadding=4
|'''Ki = Kp/Tn'''
|-
|'''Kd = Kp*Tv'''
|}
|
{| cellpadding=4 width=420
|Die Parameter Tn und Tv sind aus der analogen Regelungstechnik und sind dort sehr geläufig. Die Umrechnung in die Parameter Ki und Kd erfolgt mit nebenstehenden Formeln. Siehe auch [[Regelungstechnik#PID-Regler| PID-Regler]]
|}
|}

===Dimensionierung mit dem Bodediagramm===
Ein Bode-Diagramm ist die grafische Darstellung des Frequenzganges. Es werden der Betrag der Übertragungsfunktion (Amplitudengang) und der Verlauf des Phasenwinkels (Phasengang) als Funktion der Frequenz aufgetragen. Die Frequenzachse und die Amplitudenachse werden logarithmisch dargestellt. Die logarithmische Darstellung hat den Vorteil, dass eine Multiplikation auf eine einfache Addition zurückgeführt wird. Somit wird eine Hintereinanderschaltung von Systemen im Blockschaltbild zu einer einfachen Addition im Bodediagramm.

Das Zeitverhalten des rückgekoppelten Regelkreises hängt entscheidend vom Verlauf
des Frequenzganges der offenen Regelschleife in der Umgebung des Durchtretens durch
die 0dB-Achse ab. In der Regelungstechnik wird daher der offene Regelkreis im Bode-Diagramm aufgetragen. Das erlaubt einen schnellen Überblick über Stabilität und möglichen Reserven zur Optimierung. Ein Kriterium für die Stabilität der Schleife ist der Phasenrand und der Amplitudenrand. Der Phasenrand ist der Abstand (Phasenreserve) zur -180°-Linie bei der Durchtrittsfrequenz. Die Durchtrittsfrequenz ist diejenige Frequenz, bei der der Amplitudengang durch die 0dB-Linie geht. Siehe auch folgendes Bode-Diagramm.

[[Bild:Phasenrand.gif]]

{| {{Blauetabelle}}
|'''Regel:''' Eine geschlossene Regelschleife arbeitet genau dann stabil, wenn der Phasenrand positiv ist.
|}
Wird diese Bedingung verletzt, so wird in diesem Frequenzbereich die im Rückführzweig der Regelung eingebrachte Gegenkopplung zu einer Mitkopplung und das System kann schwingen.

'''Beim Reglerentwurf sind folgende Punkte zu beachten:'''
* Der Phasenrand muss positiv sein. Der geschlossene Regelkreis kann sonst instabil sein.
* Je größer der Phasenrand ist, desto größer ist die Stabilitätsreserve des Regelkreises und desto höher ist die Dämpfung des Regelkreises. Üblich sind Werte von 40°...70° für gutes Führungsverhalten und 20°...50° für gutes Störverhalten.
* Die Durchtrittsfrequenz ist ein Maß für die Schnelligkeit des Regelkreises, je höher, desto schneller ist die Reaktion auf Änderungen der Führungsgröße oder Störungen.

Hier ein Beispiel zur Dimensionierung mit dem Bode-Diagramm.

[[Bild:Bode1.gif]]

Die Strecke ist rot dargestellt und besteht in dem Beispiel aus einem nicht schwingfähigem PT2-Glied. Man sucht sich den Punkt, wo die Strecke für sich alleine noch ausreichend Phasenreserve hat, z.B. 70°. In dem Beispiel also die Frequenz, bei der die Strecke -110° Phasendrehung aufweist. Das ist etwa bei 15Hz. Da hat die Strecke ungefähr eine Dämpfung von 25dB. Wenn man nun diese Dämpfung durch eine Verstärkung von 25dB kompensiert, dann wird dieser Punkt zur Durchtrittsfrequenz. D.h. man wählt den P-Anteil des Reglers Kp=18, denn 25dB entspricht ungefähr dem Faktor 18. Um die Regelabweichung zu minimieren, wird noch ein I-Anteil hinzugefügt. Üblicherweise wählt man für die Grenzfrequenz des PI-Reglers die Grenzfrequenz des dominierenden Streckenteils, in dem Beispiel ca. 1.4Hz. Damit ergibt sich ein I-Anteil von 170. Im Bode-Diagramm ist der PI-Regler als schwarze Kurve eingezeichnet. Die Addition der Strecke und des Reglers im Bode-Diagramm führt dann zum Frequenzgang des offenen Regelkreises (blaue Kurve). Die resultierende Durchtrittsfrequenz ist wie gewählt bei etwa 15Hz. Der Phasenrand hat sich durch den I-Anteil im Regler auf ca. 60° reduziert, ist aber noch ausreichend. Das Einschwingen des geschlossenen Regelkreises für diese Dimensionierung sieht dann folgendermaßen aus:

[[Bild:Sprungantwort3.gif]]

Bei Bedarf könnte noch ein D-Anteil (PID-Regler) hinzugenommen werden, das würde die Phase anheben und man könnte dadurch die Durchtrittsfrequenz weiter nach oben schieben. In der Praxis wird dies allerdings wegen der wahrscheinlichen Begrenzung des Stellglieds kein schnelleres Einschwingen mehr bringen.

Begrenzungen oder Nichtlinearitäten werden bei der Dimensionierung mit dem Bode-Diagramm nicht berücksichtigt. Das ist ein Nachteil dieser Methode. Eventuell muss deshalb noch einmal im Zeitbereich nachoptimiert werden.

===Dimensionierung mit der Ortskurve===
Eine Alternative zur Dimensionierung mit dem Bodediagramm stellt die Methode über die Ortskurve des offenen Regelkreises dar.

Bei diesem Verfahren ist schnell auf einem Blick ersichtlich ob der Regelkreis stabil ist.

Liegt der Punkt -1 auf der Realteilachse links von der Ortskurve in Richtung steigendem Omega so ist der Regelkreis stabil.
Der Abstand zu der kritischen Kreisfrequenz Omega Krit von der Imaginärteilachse ist die Verstärkung Vr mit diesem Wert lässt sich der Amplitudenrand ermitteln.
Dazu wird folgende Formel verwendet: Ar = 20 lg (1/Vr) in dB

Die Durchtrittskreisfrequenz Omega D ist an dem Punkt, wo der Betrag aus Realteil und Imaginärteil 1 ergibt. Wenn man weiß, wo die Durchtrittskreisfrequenz ist, dann kann man den Phasenrand bestimmen.
Dies ist der Winkel zwischen der -180° Linie zu Omega D.

[[Bild:Ortskurve.jpg]]

==Hilfsprogramme zur Analyse und Optimierung==
Die Analyse und Optimierung von Regelkreisen wird wesentlich erleichtert durch die Zuhilfenahme von Programmen. Es erspart einem eine komplizierte Rechnerei von Hand oder umfangreiche Testläufe. Stellvertretend für all die verfügbaren Programme werden hier zwei Freeware-Programme vorgestellt, die dafür gut geeignet sind. Die Beschreibung hier ersetzt aber keine Tutorials, es wird nur die Anwendung für die Regelungstechnik beschrieben.

===Scilab/Scicos===
Scilab ist ein wissenschaftlich-technisches Softwarepaket für numerische Berechnungen. Scicos ist eine Erweiterung dazu, die eine blockorientierte und modellbasierte Simulation und Analyse von dynamischen Systemen bietet. Dieses Softwarepaket kann von der [http://www.scilab.org/ Scilab Homepage] herunter geladen werden.

====Scilab====
Mit Scilab ist es sehr einfach ein Bode-Diagramm zu zeichnen, es bedarf nur 3 Zeilen Code.
s=poly(0,'s');
G=syslin('c',0.72/(0.11*s+1));
bode(G)
Die 1.Zeile '''s=poly(0,'s');''' legt die Variable s als Polynomvariable fest. Dies braucht in einer Sitzung nur einmal gemacht zu werden. Die 2.Zeile '''G=syslin('c',0.72/(0.11*s+1));''' definiert ein lineares System mit der Übertragungsfunktion 0.72/(0.11s+1). Die 3.Zeile '''bode(G)''' zeichnet das Bode-Diagramm des zuvor mit syslin definierten Systems G. Zu beachten ist, dass Scilab auf der x-Achse im Bode-Diagramm die Frequenz in Hertz und nicht wie üblich die Kreisfrequenz darstellt. Anstelle des Bode-Diagramms kann auch die Sprungantwort gezeichnet werden. Dies geschieht mit folgenden Befehlen:
xbasc();
t=[0:0.001:2];
y=csim('step',t,G);
plot2d(t,y)
'''xbasc()''' löscht den letzten Plot mit dem Bode-Diagramm und mit '''t=[0:0.001:2]''' wird ein Vektor t mit den angegebenen Zeiten im Intervall von 1ms definiert. Die Zeile '''y=csim('step',t,G)''' berechnet die Sprungantwort des zuvor mit syslin definierten Systems G und speichert sie in y ab. Das Ergebnis wird dann mit '''plot2d(t,y)''' dargestellt. Bei Bedarf können noch Gitternetzlinien mit dem Befehl '''xgrid()''' hinzugefügt werden.

Ergänzend hier noch ein Scilab-Skript, welches recht hilfreich bei der Dimensionierung mit dem Bode-Diagramm ist. Den nachfolgenden Code einfach in das SciPad-Fenster (Editor von Scilab) kopieren und starten. Es werden 2 Grafikfenster angezeigt, eines mit dem Bode-Diagramm und ein zweites mit der Sprungantwort. Man kann im Skript die Streckencharakteristik anpassen und verschiedene Reglerparameter ausprobieren.

<pre>
Ks=0.72; // Verstärkung der Strecke
T1=0.11; // Zeitkonstante 1
T2=0.005; // Zeitkonstante 2
Kp=18; // Proportionalbeiwert
Ki=170; // Integralbeiwert
Kd=0; // Differenzialbeiwert

s=poly(0,'s'); // definiert s als Polynomvariable
P=(T1*s+1)*(T2*s+1); // Streckencharakteristik
Gs=syslin('c',Ks,P) // Übertragungsfunktion der Strecke

RZ=poly([Ki Kp Kd],'s','coeff') // Zählerpolynom des Reglers
RN=poly([0 1],'s','coeff') // Nennerpolynom des Reglers
Gr=syslin('c',RZ,RN) // Übertragungsfunktion des Reglers

G=Gr*Gs // Übertragungsfunktion gesamt
xset("window",0);
xbasc(0);
bode([Gr;G;Gs],0.1,100,['Regler';'gesamt';'Strecke'])

Gcl=G/(G+1) // geschlossene Regelschleife
t=0:0.001:0.2;
y=csim('step',t,Gcl); // berechnet Sprungantwort
xset("window",1);
xbasc(1);
plot2d(t,y,2);
xgrid();
xtitle("Sprungantwort","sec");
</pre>

====Scicos====
Eine weitere Möglichkeit zur Simulation im Zeitbereich bietet Scicos. Die Modellierung geschieht mit einem grafischen Editor, in dem Blöcke mit vordefinierten oder selbstgemachten Funktionen miteinander verbunden werden. Ein einfaches Modell eines Regelkreises mit PID-Regler sieht folgendermaßen aus:

[[Bild:Scicos_anaReg.gif]]

Der PID-Regler ist mit seinen 3 Zweigen (P, I und D) dargestellt. In den Verstärkerblöcken kann durch Ändern der Reglerparameter (KP, KI und KD) der Regler optimiert werden. Die Strecke ist in diesem Beispiel nur ein einzelner Block, in dem die Übertragungsfunktion eingegeben wird. Man kann die Strecke auch detaillierter mit einzelnen Funktionsblöcken darstellen. Ein Beispiel eines komplexen Blockschaltbilds für einen balancierenden Bot ist unter diesem [http://www.roboternetz.de/phpBB2/download.php?id=5082 Link] zu finden.

Der Vorteil der Simulation mit Scicos ist die Möglichkeit Nichtlinearitäten zu berücksichtigen und die Kombination von kontinuierlichen und diskreten Funktionen. Das heißt, man kann einen digitalen Regler mit seinen diskreten Schritten und eine analoge Strecke, als kontinuierliche Funktion eingegeben, zusammen simulieren. Scicos bietet sogar einen 'Scifunc'-Block, mit dem Rechenschritte des digitalen Reglers nachgebildet werden können. Damit wird sowohl das dynamische Verhalten, verursacht durch die Abtastzeit Ta, als auch die etwas unterschiedliche Dynamik durch die digitale Ausführung eines I- und D-Anteils richtig simuliert. Ein Beispiel für den Einsatz des Scifunc-Blocks ist in folgendem Blockschaltbild zu sehen.

[[Bild:Scicos_digReg.png]]

Beispiel: [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlregelung]] mit digitalem Regler

Die globalen Variablen für die Reglerparameter und die Abtastzeit werden unter dem Menüpunkt „Edit - Context“ abgelegt.
Kp=18;
Ki=60;
Ta=0.01;
In den Taktgeber für den digitalen Regler wird als Clock-Periode die Abtastzeit Ta eingetragen. In das Dialogfenster zum Scifunc-Block wird folgender Code zur Simulation des digitalen PI-Reglers eingetragen:
<pre>
z=z+Ki*Ta*u1
if z>5 then
z=5;
end
y1=Kp*u1+z
if y1>5 then
y1=5;
end
</pre>
z entspricht der Variable esum vom Beispiel des [[Regelungstechnik#Realisierung_mit_digitalem_Regler| digitalen Drehzahlreglers]]; u1 ist die Eingangsvariable und y1 die Ausgangsvariable des Scifunc-Blocks.
In den Block für die Strecke wird die Übertragungsfunktion eingetragen. Als Zähler die Verstärkung Ks, also 0.72. Im Nenner das Polynom (1+0.11*s) für die Charakteristik der Strecke. Mit ‚Simulate – Run’ wird die Simulation gestartet. Als Ergebnis sollte das Einschwingen der Stellgröße (schwarz) und der Regelgröße (grün), wie in folgender Abbildung erscheinen.

[[Bild:Sprungantwort_DZR.png]]

Man kann nun mit den Reglerparametern und verschiedenen Abtastzeiten spielen, um zu sehen wie sich die Änderungen auswirken. Zum Beispiel wird bei einer Verdopplung der Abtastzeit der Regelkreis bereits instabil.

Diese Beispiele sind nur ein kurzer Auszug von den Möglichkeiten mit Scilab/Scicos für den Einsatz in der Regelungstechnik. Darüber hinaus ist es auch sehr gut geeignet bei anderen Optimierungsverfahren wie z.B. beim WOK-Verfahren (Wurzelortskurven) oder zur Analyse und Optimierung von modernen Reglern wie z.B. Zustandsregler und Kalmanfilter.

===LTspice/SwitcherCad III===
Dieses Programm ist ein SPICE-Derivat von der Firma Linear Technology und ist unter den 2 Namen LTspice und SwitcherCad III bekannt. Der Einfachheit halber wird für die weitere Beschreibung hier nur der Name LTspice verwendet. Das Programm ist Freeware und kann unter diesem Link herunter geladen werden. http://ltspice.linear.com/software/LTspiceIV.exe

LTspice ist ein Simulationsprogramm zur Analyse von elektronischen Schaltungen. Mit LTspice kann sowohl im Zeitbereich als auch im Frequenzbereich analysiert werden und bietet sich dadurch mit den entsprechenden Modellen auch für den Einsatz in der Regelungstechnik an. Wer sich bereits mit SPICE-Programmen auskennt, für den sollte es auch in der Regelungstechnik die 1.Wahl sein.

Der Vorteil von LTspice ist die Möglichkeit einer sehr detaillierten Analyse, vorausgesetzt die Modelle sind auch so detailliert nachgebildet. Insbesondere für analoge Regler, wo die elektrische Schaltung direkt umgesetzt werden kann, empfiehlt sich der Einsatz von LTspice. Der Nachteil ist, LTspice ist nicht auf regeltechnische Belange ausgelegt worden und spezifische Symbole für die Regelungstechnik müssen selbst erstellt werden. Einige selbst erstellte Symbole für dynamische Grundelemente in LTspice sind hier abgebildet.

[[Bild:LTSpiceSymb.png]]

Die 3 Symbole können [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=285 hier] heruntergeladen werden. Weitere Symbole können anhand dieser Beispiele sehr leicht selbst erstellt werden. Ein P-Glied kann durch eine spannungsgesteuerte Spannungsquelle (E-Source) oder Operationsverstärker mit einstellbarer Verstärkung dargestellt werden.

'''Analyse im Zeitbereich'''

Das Beispiel des [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlreglers]] mit analogem Regler wird hier mit LTspice simuliert. Das Schaltbild des Regelkreises zeigt nachfolgende Abbildung.

[[Bild:LTspice_TRAN.png]]

Der Vergleicher (U1) und der analoge PI-Regler (U2) sind so dargestellt, wie es auch in Wirklichkeit ausgeführt werden kann. Da der PI-Regler in der Schaltung bereits invertiert, wurden die Eingänge am Vergleicher vertauscht, damit die Polarität wieder stimmt. Der Rest des Regelkreises wurde stark vereinfacht, kann aber nach Bedarf auch ausführlicher dargestellt werden. Das PT1-Glied U3 simuliert die Strecke des Regelkreises und der Verstärker U4 dient nur zur Umrechnung auf die Drehzahl. Zur Simulation im Zeitbereich wird auf den Führungswert w mit der Spannungsquelle V1 ein Sprung gegeben. In der Reglerschaltung wurde bewusst ein Operationsverstärker mit Versorgungsspannung gewählt, damit auch der Einfluss einer Begrenzung mit simuliert wird. Die Zeitbereichsanalyse wird durch den LTspicebefehl .TRAN erreicht. Die Sprungantwort (Tachospannung) bei diesem Regelkreis sieht dann folgendermaßen aus.

[[Bild:Tacho2.png]]

Durch Ändern der Bauelemente R5, R6 und C1 kann man den Regler optimieren. Eine Umrechnung auf die Reglerparameter Kp und Ki ist mit folgenden Formeln möglich, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5

Ki = 1/(R5*C1)

Mit einem Mausklick auf den entsprechenden Knoten in der Schaltung können noch weitere Signale, wie z.B. die Stellgröße y angezeigt werden. Durch Verändern der Versorgungsspannung V3, V4 kann man sich auch die Auswirkung der Begrenzung ansehen.

'''Analyse im Frequenzbereich'''

Für die Darstellung des Bode-Diagramms der offenen Regelschleife in LTspice muss ein Trick angewendet werden, denn durch das Auftrennen der Regelschleife würde der Arbeitspunkt verloren gehen und dadurch die offene Schleife ohne Gegenkopplung an den Anschlag fahren.

Mit einer zusätzlichen Spannungsquelle in der Schleife kann man dieses Problem umgehen. Die Schleife bleibt für den Erhalt des Arbeitspunktes weiterhin geschlossen und man kann trotzdem die Verstärkung der offenen Schleife durch das Verhältnis der Spannung vor und hinter der Spannungsquelle bestimmen. Das erweiterte Blockschaltbild sieht folgendermaßen aus.

[[Bild:LTspice_AC.png]]

V2 ist die zusätzliche Spannungsquelle für die AC-Analyse. Die Spannungsquelle V1 wird von Pulsform auf Gleichspannung umgestellt. Sie wird so gewählt, dass sich der gewünschte Arbeitspunkt einstellt. Durch den LTspicebefehl .AC wird die Analyse im Frequenzbereich veranlasst. Um das Bode-Diagramm des offenen Regelkreises darzustellen, wird als Kurve nicht ein einzelner Knoten ausgewählt, sondern das Verhältnis der Spannung vom Ende zum Anfang des Regelkreises, in unserem Beispiel also V(tacho)/V(x). Zur Anzeige kommt dann das Bode-Diagramm (grüne Kurve) der offenen Schleife, wie in der folgenden Abbildung zu sehen. Für den Amplitudengang (durchgezogene Linien) gilt die linke Skala in dB, für den Phasengang (gestrichelte Linien) die rechte Skala in Grad.

[[Bild:LTspice_Bode.png]]

Zusätzlich ist noch das Bode-Diagramm der Strecke (rote Kurve) zu sehen. Dies ist durch einfaches Hinzufügen einer weiteren Kurve mit dem Ausdruck V(tacho)/V(y) durchgeführt worden.

Im Gegensatz zur üblichen Darstellung des Bode-Diagramms eines offenen Regelkreises, beinhaltet das mit LTspice erstellte Bode-Diagramm auch die -180 Grad Phasendrehung der Gegenkopplung. Der Phasenrand ist deshalb nicht auf -180 Grad sondern auf 0 Grad zu beziehen. In unserem Beispiel ist der Phasenrand etwa 90 Grad, also ein sehr stabiler Regelkreis. Zu beachten ist, dass die Frequenzachse des Bode-Diagramms wie auch schon bei Scilab in der Einheit Hertz anstatt wie üblich in der Kreisfrequenzeinheit rad/s dargestellt ist.

==Modellierung eines Motors/Antriebs==
[[Bild:ESB_Motor.png|thumb|320px|Ersatzschaltbild DC-Motor]]
Der Motor ist ein oft verwendeter Aktuator in der Robotik. Deshalb wird hier am Beispiel des Gleichstrommotors mit Permanentmagnet (Nebenschlussmotor) die Modellbildung gezeigt. Zur Modellierung gibt es mehrere Möglichkeiten. Je nachdem wie detailliert die Simulation sein soll, kann man sich ein Modell, von sehr einfach bis sehr detailliert, auswählen. Zwei Zeitkonstanten bestimmen die Dynamik eines Gleichstrommotors. Eine davon ist die mechanische Zeitkonstante, die ist meistens die dominierende Zeitkonstante und wird durch das Trägheitsmoment J des Rotors verursacht. Die zweite Zeitkonstante ist die elektrische Zeitkonstante, sie wird durch die Induktivität L bestimmt. Bei einfachen Regelungen kann in den meisten Fällen die elektrische Zeitkonstante vernachlässigt werden, damit reduziert sich das Modell auf ein einzelnes PT1-Glied.

'''Definition: Motor und Antrieb'''

Als '''Motor''' wird hier der Motor alleine verstanden. Die Ausgangsgröße ist die Winkelgeschwindigkeit w (Drehzahl).

Als '''Antrieb''' wird hier der komplette Antrieb eines Fahrzeugs verstanden, also Motor inklusive Getriebe und Masse des Fahrzeugs. Für die Dynamik ist nicht nur das Trägheitsmoment des Motors sondern auch die Masse des Fahrzeugs verantwortlich. Die Ausgangsgröße der Einheit „Antrieb“ ist die Geschwindigkeit v.

Die hier vorgestellten Modelle gelten sowohl für einen Motor als auch für einen kompletten Antrieb, wenn man die Elastizität und das Spiel des Getriebes vernachlässigt.

===Einfaches Modell mit PT1-Glied===
Die einfachste Art einen Motor oder Antrieb zu simulieren, ist mit einem PT1-Glied als Modell. Das Simulationsprogramm [[Regelungstechnik#Scicos|Scicos]] bietet dazu einen Block zur Eingabe der Übertragungsfunktion (num(s)=Zähler, den(s)=Nenner der Übertragungsfunktion).
{| border=0 cellpadding=10
|Übertragungsfunktion:

<math>G(s)=\frac{K}{1+Ts}</math>

|Beispiel:
num(s) = K = 0.72
den(s) = 1 + Ts = 1 + 0.11s
|[[Bild:Scicos_TF.png]]
|}

Wird nicht nur das Ausgangssignal, also die Geschwindigkeit oder Drehzahl in der Simulation benötigt, sondern auch die Beschleunigung, dann kann nachfolgendes Modell verwendet werden. Dieses Modell ist der Differentialgleichung eines PT1-Glieds nachempfunden und liefert das gleiche Ergebnis wie vorheriges Modell, bietet aber noch den Zugriff auf das Beschleunigungssignal.
{| border=0 cellpadding=10
|Differentialgleichung:

<math>v'=\frac{K}{T}U-\frac{1}{T}v</math>

|
v = Geschwindigkeit
v’= Beschleunigung (Ableitung von v)
K = Übertragungsmaß
T = Zeitkonstante
U = Eingangsgröße (z.B. Spannung)
|[[Bild:Antrieb_PT1.png|thumb|Einfaches Modell eines Antriebs]]
|}

Die beiden Parameter K und T müssen ausgemessen werden, wenn sie nicht bekannt sind. Die Zeitkonstante T kann in einem Anlaufversuch ermittelt werden. Dazu wird auf den Motor ein Spannungssprung gegeben und die Sprungantwort am Ausgang nachgemessen. Bei einem Antrieb erspart diese Methode die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente (Motor, Getriebe, Fahrzeug). Bei der Ermittlung des Übertragungsmaß K ist zu beachten, dass sich möglicherweise der Motor durch starke Reibung erst ab einer bestimmten Spannung dreht. Hier ist die Steigung der Kennlinie mit delta v / delta U auszuwerten, wie im folgenden Bild zu sehen ist.

[[Bild:Antrieb_stat.png]]

Die einfachen Modelle gelten nur für den linearen Teil der Kennlinie. Soll auch die Nichtlinearität durch Reibung modelliert werden, dann sind detailliertere Modelle, wie im Folgenden beschrieben, zu verwenden. Die Auswirkung einer Haftreibung ist auch in dem Geschwindigkeitsdiagramm durch die Hysterese in der Kennlinie zu sehen. Beim Hochfahren der Ansteuerspannung bewegt sich das Fahrzeug erst ab ca. 1.25V, während beim Herunterfahren der Ansteuerspannung das Fahrzeug noch bis 0.75V rollt und erst unter 0.75V stehen bleibt.

===Detailliertes Modell===

[[Bild:Motor_Model.png|thumb|350px|Detailliertes Motormodell]]
Ein detailliertes Motormodell ist rechts in dem Bild zu sehen. Es hat auf der linken Seite den elektrischen Teil mit den Parametern R (Widerstand) und L (Induktivität) und auf der rechten Seite den mechanischen Teil mit den Blöcken Trägheitsmoment und Reibung. Der elektrische Teil liefert das Stromsignal i, welches mit der Motorkonstante Km in das Drehmoment M umgerechnet wird. Mit dem folgenden Summierglied kann über einen zusätzlichen Eingang auch ein extern angreifendes Lastmoment mit simuliert werden. Am Ausgang des mechanischen Teils steht die Winkelgeschwindigkeit w in der Einheit [rad/s] bzw. über den Umrechnungsfaktor 9.55 die Drehzahl in [Upm] zur Verfügung. Die Reibung wird in einem nichtlinearen Block mittels Lookup-Table simuliert. In der einschlägigen Literatur wird die Reibung meistens mit einem Dämpfungsfaktor (linear) simuliert, was einer viskosen Reibung entspricht. Das passt aber nicht so gut für Kleinmotoren, da überwiegt vor allem die trockene Reibung. Die trockene Reibung hat ein konstantes Bremsmoment wenn sich der Motor dreht (unabhängig von Drehzahl, Vorzeichen abhängig von Drehrichtung). So eine Funktion kann sehr einfach mit einer Lookup-Table realisiert werden. Die Lookup-Table kann auch dazu verwendet werden, Mischformen von trockener, viskoser und turbulenter Reibung und sogar noch Haftreibung in einem Block zu simulieren, wenn man will.

Bei einigen Herstellern, wie z.B. Faulhaber und Maxon, kann man die für das Modell nötigen Parameter im Datenblatt finden. Das Bremsmoment der Reibung berechnet sich aus dem Leerlaufstrom wie folgt: Bremsmoment = Motorkonstante * Leerlaufstrom

Falls die Daten nicht verfügbar sind, muss man sie selbst ausmessen. Eine Hilfestellung zur Bestimmung der Motorkonstante und des Trägheitsmoments gibt es hier:
*http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=96750&highlight=#96750
*http://www.roboternetz.de/phpBB2/viewtopic.php?t=12793

[[Bild:Antrieb_Modell.png|thumb|350px|Modell eines Antriebs]]

Das detaillierte Motormodell kann auch für einen Antrieb verwendet werden, wenn man eine starre Kopplung zwischen Motor und Antriebsrad voraussetzt, also Elastizität und Spiel des Getriebes vernachlässigt. Anstelle der rotatorischen Kenngrößen (Drehmoment M, Trägheitsmoment J, Winkelgeschwindigkeit w) werden die translatorischen Kenngrößen (Kraft F, Masse m, Geschwindigkeit v) eingesetzt. Das Drehmoment wird mittels Getriebeübersetzung ü und Radius r des Antriebsrades in die entsprechende Vortriebskraft umgerechnet. Daraus ergibt sich die Kraftkonstante Kf, die für das Antriebsmodell verwendet wird.

Die Umrechnung ist: Kf = Km * ü/r

Bei der Trägheitsmasse m muss neben der Masse des Fahrzeugs auch das Trägheitsmoment des Motors mit berücksichtigt werden. Die Umrechnung von Trägheitsmoment in eine äquivalente Masse = J * (ü/r)²

Der Reibungsblock in diesem Modellbeispiel enthält eine Mischform aus Haftreibung, trockener und viskoser Reibung, wie sie typisch für einen Kleinbot mit 2 Antriebsrädern und einem Gleitpin ist.

==Beispiel: Drehzahlregelung==
Es wird ein Gleichstrommotor in der Drehzahl geregelt. Als Sensor ist ein Tachogenerator vorhanden, der direkt auf der Motorwelle sitzt. Das System ist in einem kleinen Modellfahrzeug eingebaut und wird zur Geschwindigkeitsregelung eingesetzt, da die Drehzahl proportional zur Geschwindigkeit ist.

Das Funktionsschaltbild sieht folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl1.gif

Als Störgröße können unterschiedliche Reibwerte oder Steigung und Gefälle rückwirkend über das Getriebe die Drehzahl beeinflussen. Das Getriebe und die Last sind zwar außerhalb der Regelschleife, beeinflussen aber durch die feste Kopplung des Getriebes die Dynamik des Regelkreises. Durch die starre Kopplung kann das Trägheitsmoment des Motors und die Masse des Fahrzeugs zusammengefasst werden. Das Gleiche gilt auch für die Reibwerte. Damit vereinfacht sich die Modellierung und das Blockschaltbild reduziert sich auf folgende Schaltung:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl2.gif

Zur Ermittlung des dynamischen Verhaltens der Regelstrecke wird die Sprungantwort gemessen. Dazu wird auf den Eingang der Regelstrecke (Stellglied) ein Spannungssprung gegeben und die Antwort am Ausgang des Tachogenerators nachgemessen. Diese Methode erspart die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente der Regelstrecke (Motor, Getriebe, Fahrzeug). Die Messung ergab folgende Sprungantwort der Regelstrecke:

http://www.roboternetz.de/wiki/uploads/Main/tacho.gif

Wie zu erwarten, ist die Sprungantwort annähernd ein Verzögerungsglied 1.Ordnung. Die abgelesene Zeitkonstante ist 0.11s. Die Verstärkung der Regelstrecke ist Ks = 0.72. Das Übertragungsmaß des Tachogenerators ist 1V pro 2480Upm. Damit kann auf die Drehzahl rückgerechnet werden.

Da die Regelstrecke nur aus einem PT1-Glied besteht, könnte eine analoge Regelung fast beliebig schnell gemacht werden. Wegen der Begrenzung bringt aber das Ausreizen der Optimierung für das Führungsverhalten nicht viel, nur für das Störverhalten wäre eine schnellere Regelung sinnvoll. Um aber einen Vergleich zwischen analogem und digitalem Regler anstellen zu können wird eine Parametrierung gewählt, die auch für den digitalen Regler mit seiner Totzeit noch stabil ist. Es wird deshalb auch auf einen D-Anteil im Regler verzichtet und nur ein PI-Regler realisiert. Das vereinfachte Blockschaltbild mit den dynamischen Elementen sieht damit folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl3.gif

Zur Veranschaulichung wurde ein analoger als auch ein digitaler Regler realisiert. Die Parametrierung des analogen Reglers wurde mit dem Programm [[Regelungstechnik#LTspice.2FSwitcherCad_III| LTspice]] durchgeführt. Es bot sich an, da die analoge Reglerschaltung exakt simuliert werden konnte. Für die Optimierung des digitalen Reglers wurde dann [[Regelungstechnik#Scicos| Scicos]] verwendet.

===Realisierung mit analogem Regler===
Die elektrische Schaltung für einen analogen PI-Regler ist in der nächsten Abbildung zu sehen. Der erste Operationsverstärker vergleicht den Sollwert w mit dem Istwert x. Der zweite Operationsverstärker bildet den PI-Regler. Die Werte R5, R6 und C1 sind für die Charakteristik des PI-Reglers zuständig. Mit R6 kann der P-Anteil und mit C1 der I-Anteil eingestellt werden. Die Optimierung der Werte wurde empirisch in einer Simulation mit LTspice durchgeführt. Da die Schaltung des PI-Reglers invertiert, wurden zum Ausgleich am Vergleicher die Eingänge an U1 vertauscht, so dass sich über die gesamte Schaltung wieder die richtige Polarität ergibt.

[[Bild:Analogregler.png]]

Zum Umrechnen auf Kp und Ki können diese Formeln verwendet werden, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5 = 18

Ki = 1/(R5*C1) = 147

===Realisierung mit digitalem Regler===
Im digitalen Regelkreis wird der Istwert '''x''' vom Tachogenerator mit einem A/D-Wandler digitalisiert. Der Sollwert '''w''' wird dem µC als digitaler Wert übergeben. Die Stellgröße '''y''' entspricht dem PWM-Wert für den Motortreiber. Um zum analogen Regler vergleichbar zu sein, wurde sowohl für den A/D-Wandler als auch für den PWM-Steller eine 8-Bit-Breite vorgesehen. Damit ist die Verstärkung in beiden Fällen gleich und analoger und digitaler Regler besser vergleichbar.

Eigentlich könnte man bei kleiner Abtastzeit direkt die Parametrierung des analogen Reglers für die digitale Realisierung übernehmen. Aber es gibt doch kleine Unterschiede in der Dynamik zwischen analoger und digitaler Ausführung und um sicher zu gehen, dass die gewählte Abtastzeit einen nicht zu großen Einfluss hat, wird noch einmal mit [[Regelungstechnik#Scicos| Scicos]] nachoptimiert. Mit einer Abtastzeit Ta = 10ms und den Parametern des analogen Reglers ergibt sich ein Überschwingen, das nur sehr langsam auf den Endwert abklingt. Durch Verringern des I-Anteils auf 60 wird ein optimales Einschwingen für den digitalen Regler erreicht. Die Parameter sind:

Kp = 18

Ki = 60

Ta = 0.01

Zur Umsetzung in einen Code wurde die Programmiersprache C gewählt. Da der Code sehr einfach ist, sollte es auch kein Problem sein, den Code als Beispiel für andere Sprachen zu verwenden. Der Algorithmus wird im Takt der Abtastzeit, also alle 10ms aufgerufen. In der Reglergleichung kann zur Vereinfachung das Produkt Ki*Ta durch eine Ersatzvariable, die gleich das Ergebnis aus dem Produkt 60*0.01 = 0.6 hat, ersetzt werden. Zum besseren Verständnis wurde es hier beim Ki*Ta belassen. Um einen Windup-Effekt zu verhindern, wird die Summenbildung esum auf +-400 begrenzt. Der Wert wurde so gewählt, dass noch eine volle Aussteuerung durch den I-Anteil möglich ist. Zum Schluss wird die Stellgröße y auf die mögliche Aussteuerung des Stellglieds (0...255) begrenzt.

'''Programmbeispiel digitaler PI-Regler:'''

<pre>
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
if (esum < -400) {esum = -400;} //Begrenzung I-Anteil
if (esum > 400) {esum = 400;}
y = Kp*e + Ki*Ta*esum; //Reglergleichung
if (y < 0) {y = 0;} //Begrenzung Stellgröße
if (y > 255) {y = 255;}
PWM = y; //Übergabe Stellgröße
</pre>

== Beispiel: Lageregelung ==
Unter einer Lageregelung versteht man die Positionierung von Objekten. Als Beispiel soll hier ein kleiner Bot mit Radencoder eine bestimmte Weglänge fahren. Gegenüber der Drehzahl- oder Geschwindigkeitsregelung ist bei der Lageregelung noch ein zusätzlicher Integrator in der Strecke vorhanden. Die gesamte Strecke ist damit ein I-Glied mit Verzögerung. Laut Tabelle im Abschnitt „Dimensionierung des Reglers“ ist dafür ein PD-Regler gut geeignet. Der PD-Regler wird digital ausgeführt, zur Simulation und Parametrierung bietet sich deshalb Scicos an.

Da bei einer Lageregelung der Geschwindigkeitsbereich von Null aus geht, also über den nichtlinearen Bereich geht, sollte auch in der Simulation die Nichtlinearität berücksichtigt sein. Für das Beispiel wird deshalb das Modell eines Antriebs mit Haft- und Gleitreibung genommen, wie es unter "Modellierung eines Antriebs – detailliertes Modell" bereits vorgestellt wurde. Im Scicos-Modell ist der Antrieb der Übersichtlichkeit wegen als Superblock ausgeführt. Das Blockschaltbild des Antriebs im Detail ist [http://www.roboternetz.de/wissen/images/7/73/Antrieb_Modell.png hier] zu sehen. Die Daten sind:

R = 16 Ohm; L = 6 mH; m = 0.31 kg; Kf = 6.6 N/A

Als Sensor kommt ein Inkrementalgeber zum Einsatz, allerdings muss der richtungssensibel sein, sonst ist keine Lageregelung möglich. Der Sensor wird in Scicos mit der Rundungsformel (round(u1*500)) simuliert. Das ergibt bei einer Auflösung von 2mm ganzzahlige Schritte, wie es auch die Hardware (Inkrementalgeber mit nachfolgendem Zähler) in Wirklichkeit macht.

[[Bild:Lageregelung.png]]

Nach dem Regler folgt ein Block mit der Verstärkung (5/255), der den PWM-Wert auf die Ansteuerspannung für den Motor umsetzt. Der Bruch 5/255 entspricht der Ansteuerspannung von 5V bei PWM=255. Der PD-Regler kann damit in Scicos exakt so simuliert werden, wie er schlussendlich auch als C-Code umgesetzt wird. Dazu wird der Code des PD-Reglers als Funktion in den Scifunc-Block eingegeben. Der Code ist etwas unterschiedlich zum C-Code des realen Bots, da die Syntax in Scicos doch geringfügig anders ist und die Eingangs- und Ausgangsvariablen nur bestimmte Bezeichnungen haben dürfen. Im nachfolgenden Codefenster sind beide Varianten im Vergleich zu sehen.
{|
| '''Scifunc-Code:'''
<pre>

y1=Kp*u1+Kd/Ta*(u1-z);
z=u1;
if y1>255 then
y1=255;
end
if y1<-255 then
y1=-255;
end
</pre>
| '''C-Code für µC:'''
<pre>
e = w - x;
y = Kp*e + Kd/Ta*(e-ealt);
ealt = e;
if (y > 255) {
y = 255;
}
if (y < -255) {
y = -255;
}
</pre>
| '''Kommentar:'''
<pre>
Vergleich
PD-Reglergleichung
alten Wert speichern

pos. Begrenzung

neg. Begrenzung

</pre>
|}

In der praktischen Umsetzung des C-Codes wird man den Bruch Kd/Ta durch eine Ersatzvariable oder Konstante ersetzen. Dabei ergibt sich (wie in diesem Beispiel 2/0.01 = 200) meistens ein ganzzahliger Wert, was sich positiv auf die Rechenzeit auswirkt.

Für die Abtastzeit Ta wurde 10ms gewählt. Das ist einerseits nicht zu schnell für einen µC und andererseits nicht zu lang, um die Regelung unnötig zu verlangsamen. Die Parametrierung von Kp und Kd erfolgte empirisch durch Probieren in der Simulation. Begonnen wurde mit einem reinen P-Regler und kleinem P-Anteil (Kp=1, Kd=0). In groben Schritten wurde Kp solange erhöht, bis sich deutlich Überschwinger zeigten. Dann wurde ein D-Anteil hinzugefügt und Kd so variiert, dass der Überschwinger verschwindet. Mit ein bisschen Feintuning ergaben sich so die Werte Kp=61 und Kd=2. Das Simulationsergebnis für Ansteuerspannung, Geschwindigkeit und Weg sieht damit folgendermaßen aus:

[[Bild:Lage_antwort.png]]

==Autoren==
* [[Benutzer:Waste|Waste]]

==Siehe auch==
* [[SwitcherCAD-Tutorial]]

== External links ==
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=11818 Post: Line follower with PID controller]
*[http://www.scicos.org/ Scicos Homepage]
* [http://www.scicoslab.org/ ScicosLab Homepage]
* [http://www.scilab.org/ Scilab Homepage]
* [http://ltspice.linear.com/software/swcadiii.exe LTspice / SwitcherCAD III Download]
* [http://www.kahlert.com/web set_download.php demo version of WinFACT 7]
* [http://www.physi.uni-heidelberg.de/fp/anleitg/E01.pdf instructions for electronic placement, the last part is based PID controller]
* [http://www.simapp.com/ SimApp website] with trial
* [http://www.expertcontrol.com/ ExpertControl Homepage, Automatische Reglerauslegung mit ecICP] ecICP-Trial über Support-Seite verfügbar
* [http://www.me.th-mittelhessen.de/personen/professoren/orlowski/simulation-regelungstechnik/ TH-Mittelhessen Prof. Peter F. Orlowski, Simulationsprogramm SIMLER-PC]

[[Category: Microcontroller]]
[[Category: Software]]
[[Category: Elektronik]]

Datei:Pt2bglied.gif

2014-09-13T08:00:34Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/pt2bglied.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/pt2bglied.gif

Datei:Pt2aglied.gif

2014-09-13T08:00:09Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/pt2aglied.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/pt2aglied.gif

Datei:Pt1glied.gif

2014-09-13T07:59:30Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/pt1glied.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/pt1glied.gif

Datei:Ttglied.gif

2014-09-13T07:58:46Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/ttglied.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/ttglied.gif

Datei:Iglied.gif

2014-09-13T07:58:07Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/iglied.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/iglied.gif

Datei:Pglied.gif

2014-09-13T07:57:37Z

SprinterSB: reimport von http://www.roboternetz.de/wiki/uploads/Main/pglied.gif

reimport von http://www.roboternetz.de/wiki/uploads/Main/pglied.gif

Regelungstechnik

2014-09-13T07:50:05Z

SprinterSB: /* Digitaler Regler */ wikify digreg.gif

'''Regelungen''' sind ein Bestandteil unseres Lebens und das nicht nur seit Erfindung der Dampfmaschine.

Allein schon der aufrechte Gang funktioniert nur mit Regelung. Dabei wirken die Sinne als Sensoren, das Gehirn als Regler und die Muskeln als Aktuatoren. Weitere Regelungen in unserem Körper sind z.B. die Konstanthaltung der Körpertemperatur, der Blutdruck, die Anpassung der Pupille auf Helligkeitsänderungen usw.

Im technischen Zeitalter ist der erste geschichtlich bedeutende Regler der Fliehkraftregler von James Watt, der für die Drehzahlregelung seiner Dampfmaschine eingesetzt wurde. Seitdem ist die Regelungstechnik aus keinem Technikbereich mehr wegzudenken. Die Regelungstechnik begegnet uns im täglichen Leben auf Schritt und Tritt: Der Temperaturregler der Zentralheizung, der Temperaturregler des Kühlschranks, der Regler für die Belichtungsautomatik im Fotoapparat, das ABS-System im Auto und die Netzspannungs- und Frequenzregelung des europäischen Versorgungsnetzes sind nur einige wenige Beispiele aus diesem Bereich.

''Autor Waste''

==Einleitung==

Der Begriff ''Regelung'' ist zu unterscheiden von dem im allgemeinen Sprachgebrauch oft synonym gebrauchten Begriff der ''Steuerung''. Das Steuern ist ein rein vorwärts gerichteter Prozess ohne Rückkopplung. Die Ausgangsgröße wird dabei nicht überwacht und kann sich durch Störungen von außen verändern. Ein Beispiel ist die Steuerung eines Motors mit einer einstellbaren Spannung. Durch Laständerungen wird sich die Drehzahl des Motors ändern. Soll nun die Drehzahl konstant gehalten werden, bedarf es einer Rückkopplung um über die Spannung die Drehzahl anzupassen. Diese Rückkopplung ist das Kennzeichen einer Regelung.

Das Regeln ist ein Vorgang, bei dem die Ausgangsgröße, im Beispiel die Drehzahl, fortlaufend überwacht wird und bei Abweichung über die Stellgröße, im Beispiel die Spannung, korrigiert wird. Der sich dabei ergebende Wirkungsablauf findet in einem geschlossenen Kreis, dem Regelkreis, statt.

==Der Regelkreis==

[[Bild:Regelkreis1.png|right|thumb|300px|Ein Regelkreis (Prinzip)]]

Das Prinzip einer Regelung ist das fortlaufende: '''Messen – Vergleichen – Stellen'''

;Messen: Die Regelgröße wird direkt oder mittels Sensoren gemessen.
;Vergleichen: Der Wert der Regelgröße wird mit dem Sollwert verglichen. Die Differenz ist die ''Regelabweichung''.
;Stellen: Aus der Regelabweichung wird unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke die ''Stellgröße'' bestimmt.

{{Absatz}}

[[Bild:Regelkreis2.png|thumb|350px|Wirkunsweise einer Regelung]]

Ein Regelkreis dient dazu, eine vorgegebene physikalische Größe, die ''Regelgröße'', auf einen gewünschten Wert (Sollwert) zu bringen und dort zu halten, unabhängig von eventuell auftretenden Störungen.
Um die Regelungsaufgabe zu erfüllen, muss der Augenblickswert der Regelgröße – der Istwert – gemessen und mit dem Sollwert verglichen werden. Bei auftretenden Abweichungen muss in geeigneter Art und Weise nachgestellt werden.

Um nun diese Aufgabe technisch zu lösen, gibt es die Regelungstechnik. Sie baut im wesentlichen auf die mathematische Beschreibung und Modellbildung des Systems Regelkreis. Zur Modellierung, Beschreibung und Simulation werden Blockschaltbilder mit diskreten Signalgliedern verwendet.

{{Absatz}}

[[Bild:Regelkreis3.png|thumb|350px|Beispiel einer Geschwindigkeitsregelung]]

Ein typisches Beispiel für einen Regelkreis – eine Geschwindigkeitsregelung – wird im nebenstehenden Bild gezeigt. Die Sollgeschwindigkeit ist 80 km/h. Durch eine äußere Störung, in dem Fall eine Steigung, verlangsamt sich das Fahrzeug auf 70 km/h. Die Abweichung wird durch das Tachometer erfasst. Als Korrekturmaßnahme wird mehr Gas gegeben, um wieder auf die Sollgeschwindigkeit von 80 km/h zu kommen.

{{Absatz}}

=== Begriffe ===

[[Bild:Regelkreis4.png|right]]

Ein Regelkreis besteht entsprechend des vereinfachten Blockschaltbildes, wie es oft in der Regelungstechnik verwendet wird, aus den Hauptteilen ''Regler'' und ''Regelstrecke'':

;Regler: Ist der Teil des Regelkreises, der unter Berücksichtigung der dynamischen Eigenschaften der Regelstrecke aus der Regelabweichung die Korrekturmaßnahmen zum Ausregeln ergreift.

;Regelstrecke: Ist der Teil des Regelkreises, der vom Regler ausgeregelt werden soll.

;Führungsgröße (Sollwert) w: Vorgegebener Wert, auf dem die Regelgröße durch die Regelung gehalten werden soll. Sie ist eine von der Regelung nicht beeinflusste Größe und wird von außen zugeführt.

;Regelgröße (Istwert) x: Ist die Ausgangsgröße der Regelstrecke, die zum Zweck des Regelns erfasst und zum Vergleich rückgeführt wird. In vielen Fällen ist in der Rückführung noch eine Messeinrichtung (Sensor) gezeichnet, die den Istwert erfasst, hier der Einfachheit halber weggelassen.

;Regelabweichung e: Differenz zwischen Führungsgröße und Regelgröße '''e = w – x''', bildet die eigentliche Eingangsgröße des Reglers.

;Stellgröße y: Ausgangsgröße der Regeleinrichtung und zugleich Eingangsgröße der Strecke. Sie überträgt die steuernde Wirkung des Reglers auf die Strecke.

;Störgröße z: Eine von außen wirkende Größe, die eine Änderung des Istwertes der Regelgröße bewirkt und einen Regelvorgang auslöst.

==Die Regelstrecke==
Die Regelstrecke stellt den zu regelnden Teil bzw. den zu regelnden Prozess dar und umfasst normalerweise eine Reihe von einzelnen Gliedern. Die Glieder werden entsprechend ihrem Zeitverhalten charakterisiert. Um das Zeitverhalten herauszufinden, legt man an den Eingang ein Testsignal an und zeichnet die Antwort auf. Im einfachsten Fall wird der Eingang mit einer sprunghaften Änderung beaufschlagt. Die Antwort auf die sprunghafte Änderung der Eingangsgröße wird Sprungantwort genannt und gibt Aufschluss über die Art der Regelstrecke und kann eventuell bereits genutzt werden, um die Parameter der Regelstrecke zu bestimmen.

Für den Aufbau eines gut funktionierenden Regelkreises und die Auslegung von Reglern ist es eine Voraussetzung zu wissen, wie die Regelstrecke reagiert. Ohne ein genaues Wissen um das dynamische Verhalten der Regelstrecke ist es nicht möglich geeignete Regler auszuwählen und diese zu parametrieren.

Die wichtigsten dynamischen Grundelemente zur Charakterisierung der Regelstrecke sind nachfolgend aufgelistet. Jedes Element wird mit einem Block dargestellt und darin durch ein Symbol oder der stilisierten Sprungantwort gekennzeichnet.

----

===Proportionalglied (P-Glied)===
http://www.roboternetz.de/wiki/uploads/Main/pglied.gif

Die einfachste Art einer Regelstrecke.
;Beispiele: Hebel, Getriebe, Verstärker, Spannungsteiler, Sensoren bei denen das Zeitverhalten vernachlässigt werden kann

----

===Integrator (I-Glied)===
http://www.roboternetz.de/wiki/uploads/Main/iglied.gif

Strecke ohne Ausgleich, ist häufig in Regelstrecken vorhanden.
;Beispiele: Beschleunigung → Geschwindigkeit → Weg, Strom → Kondensatorspannung

----

===Verzögerungsglied 0.Ordnung (Totzeitglied)===
http://www.roboternetz.de/wiki/uploads/Main/ttglied.gif

Entsteht durch Laufzeiten von Material oder Signalen. Je größer die Verzögerungszeit einer Regelstrecke ist, um so schwieriger ist sie zu regeln.
;Beispiele: Förderband, Rechenzeit, A/D-Wandler

Nicht zu verwechseln mit der Totzeit, die durch das asynchrone Auftreten eines Ereignisses auf einen Zyklus entsteht. Vom Verzögerungsglied 0.Ordnung unterscheidet sich diese dadurch, daß sie mit einer gleichverteilten Wahrscheinlichkeit zwischen "gar nicht" und dem gesamten Umfang auftritt. Diese Totzeit ist mechanisch mit einem Spiel vergleichbar das "gar nicht" bis zum vollen Umfang zu einem Fehler beiträgt.
;Beispiele: Erkennen eines Signals an einem Mikroprozessor

----

===Verzögerungsglied 1.Ordnung (PT1-Glied)===
http://www.roboternetz.de/wiki/uploads/Main/pt1glied.gif

Viele einfache Regelstrecken haben ein solches Verhalten bzw. können näherungsweise damit beschrieben werden. Ist ein P-Glied mit nicht vernachlässigbarem Zeitverhalten.
;Beispiele: Gleichstrommotor (Spannung → Drehzahl), näherungsweise; Widerstand-Kondensator-Schaltung (RC-Glied)

----

===Verzögerungsglied 2.Ordnung (PT2-Glied)===
Man unterscheidet schwingungsfähige und nicht schwingungsfähige PT2-Glieder. Zur Charakterisierung gibt es die Parameter Dämpfung D und Eckfrequenz w<sub>0</sub> oder die Zeitkonstanten T<sub>1</sub> und T<sub>2</sub>. Für Dämpfung D<1 ist es schwingungsfähig.

'''Schwingfähiges PT2-Glied:'''<br/>
http://www.roboternetz.de/wiki/uploads/Main/pt2aglied.gif
;Beispiele: Mechanischer Schwinger (Feder-Masse-System), elektrischer Schwingkreis (RLC-Kreis)

'''Nicht schwingfähiges PT2-Glied:'''<br/>
http://www.roboternetz.de/wiki/uploads/Main/pt2bglied.gif
;Beispiele: Zwei hintereinander geschaltete PT1-Glieder, Gleichstrommotor (Spannung → Drehzahl) mit berücksichtigter Induktivität

==Der Regler==
Der Regler hat die Aufgabe, die Regelgröße zu messen, sie mit dem Sollwert zu vergleichen und bei Abweichungen die Stellgröße so zu verändern, dass Soll- und Istwert der Regelgröße wieder übereinstimmen bzw. die Differenz minimal wird.

Die Wahl eines bestimmten Reglertyps richtet sich nach dem geforderten Zeitverhalten und der geforderten Regelgenauigkeit der Regelstrecke. Nachfolgend finden Sie eine Zusammenfassung der wichtigsten klassischen Reglertypen:

===P-Regler===
Der proportionalwirkende Regler multipliziert die Regelabweichung mit seinem Verstärkungsfaktor '''Kp''' und gibt das Ergebnis unverzögert weiter. Er unterscheidet sich prinzipiell nicht vom dynamischen Element P-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der P-geregelte Kreis ist einfach und mittelschnell im Vergleich zu anderen Regelungen. Das Problem ist die bleibende Regelabweichung!

http://www.roboternetz.de/wiki/uploads/Main/pregler.gif

'''Software P-Regler:'''
y = Kp * e

----

===I-Regler===
Der integralwirkende Regler summiert die Regelabweichung über der Zeit auf und multipliziert die Summe (d.h. das Integral) mit dem Faktor '''Ki'''. Je länger eine Regelabweichung ansteht, desto größer wird die Stellgröße des I-Reglers. Er unterscheidet sich prinzipiell nicht vom dynamischen Element I-Glied, ist nur eben künstlich hergestellt für den Einsatz als Regler. Der I-geregelte Kreis ist langsam im Vergleich zu anderen Regelungen. Er hat aber den Vorteil, dass die Abweichung vollständig eliminiert wird.

http://www.roboternetz.de/wiki/uploads/Main/iregler.gif

'''Software I-Regler:'''
esum = esum + e
y = Ki * Ta * esum

'''esum''' ist die Summe aller bisherigen Abweichungen '''e'''. Der Parameter des Software I-Reglers ist abhängig von der Rechenschrittweite '''Ta''' (Abtastzeit). Je öfter gerechnet wird, desto öfter wird auch hinzugezählt (aufintegriert). Eine kleine Abtastzeit erfordert also einen kleineren Faktor, dies wird durch die Multiplikation mit '''Ta''' verwirklicht.

----

===PI-Regler===
Der PI-Regler ist die Kombination aus P- und I-Regler und kombiniert den Vorteil des P-Reglers, nämlich schnelle Reaktion, mit dem Vorteil des I-Reglers, der exakten Ausregelung. Der PI-geregelte Kreis ist also genau und mittelschnell.

http://www.roboternetz.de/wiki/uploads/Main/piregler.gif

'''Software PI-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum

----

===PD-Regler===
Der proportional-differential wirkende Regler kombiniert den P-Regler mit einem D-Anteil.
Der D-Anteil bewertet die Änderung einer Regelabweichung (er differenziert) und berechnet so deren Änderungsgeschwindigkeit. Diese wird mit dem Faktor '''Kd''' multipliziert und zum P-Anteil hinzuaddiert. Der PD-Regler reagiert damit schon auf Ankündigungen von Veränderungen, das bewirkt sozusagen ein Vorhalten beim Regeln.

Der PD-geregelte Kreis ist sehr schnell im Vergleich zu anderen Regelungen, und manche Regelkreise (solche mit zweifacher Integration) sind ohne D-Anteil überhaupt nicht stabilisierbar. Das Problem der proportionalen Regler, die bleibende Regelabweichung, ist beim PD-Regler allerdings weiterhin vorhanden!

Ein Nachteil aller Regler mit D-Anteil kann die Unruhe im Kreis sein. Ist das Sensorsignal verrauscht, so wird dieses Rauschen durch die Differenziation weiter verstärkt und wieder in den Kreis hineingegeben. Dadurch wird der Aktuator stärker belastet. Macht der Regler insbesondere sehr hohe Ausschläge als Folge von schnellen Änderungen des Sollwertes, dann kann es sein, dass das Stellglied oder der Aktuator diese nicht umsetzen kann - die Wirkung des D-Anteils würde dann durch die Begrenzung verpuffen, und das Einschwingverhalten wäre nicht wie berechnet, sondern meist langsamer. Dies gilt aber nur für große Sprünge. Bei den normalen kleinen Regelvorgängen zum Ausgleich von Störeinflüssen wirkt der D-Anteil wie beabsichtigt.

http://www.roboternetz.de/wiki/uploads/Main/pdregler.gif

'''Software PD-Regler:'''
y = Kp * e + Kd * (e – ealt)/Ta
ealt = e

Mit der neuesten Regelabweichung '''e''' und der vorhergehenden '''ealt''' wird der D-Anteil berechnet. Die Differenziation erfolgt damit angenähert durch Bildung des Differenzquotienten (e - ealt)/Ta.

----

===PID-Regler===
Der PID Regler ist der universellste der klassischen Regler und vereinigt die guten Eigenschaften der anderen Regler. Zur Beschreibung der Eigenschaften des P-, I- und D-Anteils siehe die anderen Reglertypen. Der PID-geregelte Kreis ist genau und sehr schnell. In den meisten Anwendungen kommt deshalb der PID-Regler zum Einsatz.

http://www.roboternetz.de/wiki/uploads/Main/pidregler.gif

'''Software PID-Regler:'''
esum = esum + e
y = Kp * e + Ki * Ta * esum + Kd * (e – ealt)/Ta
ealt = e

'''Alternative PID-Reglerstruktur:'''

Es gibt 2 Darstellungsmöglichkeiten, die inhaltlich identisch sind. In der analogen Regeltechnik ist noch die Darstellung mit der Nachstellzeit '''Tn''' und der Vorhaltezeit '''Tv''' üblich. Die Umrechnung zwischen den beiden Strukturen ist mit den angegebenen Formeln möglich.

[[Bild:PIDstruktur.gif]]

==Vergleich der Reglertypen==
In der folgenden Abbildung ist der Vergleich von P-, I-, PI-, PD- und PID-Regler in einem Regelkreis mit PT2-Glied als Regelstrecke dargestellt. Es ist deutlich zu sehen, dass die Regler ohne I-Anteil (P und PD) eine bleibende Regelabweichung aufweisen. Erst die Regler mit I-Anteil können auf den Endwert von 1 ausregeln. Beim reinen I-Regler geht das so langsam, dass es gar nicht mehr auf dem Diagramm zu sehen ist. Der Hauptzweck eines I-Anteils ist also die Vermeidung bleibender Regelabweichungen. Daher ist ein
I-Anteil normalerweise nicht nötig, wenn die Strecke schon einen I-Anteil besitzt.
Ausnahme: Es wird ein doppelter I-Anteil zur Vermeidung von Schleppfehlern benötigt.

Die schnellsten Regler sind die mit einem D-Anteil (PD und PID). Der D-Anteil kommt deshalb hauptsächlich zum Einsatz, wenn schnelle Dynamik gefragt ist oder die Strecke selbst schon instabil ist. Voraussetzung für die Schnelligkeit ist allerdings, dass keine Begrenzung im Stellglied oder Aktuator auftritt. In der Praxis ist eine Begrenzung meistens nicht zu vermeiden, deshalb gilt die Sprungantwort in der Praxis nur für kleine Sprünge.

Die Regler ohne D-Anteil, aber mit P-Anteil (P und PI) sind mittelschnell. Für einfache Regelaufgaben reicht auch oft schon ein reiner P-Regler aus, wenn die bleibende Regelabweichung vernachlässigt werden kann oder weil die Strecke schon einen I-Anteil besitzt.

http://www.roboternetz.de/wiki/uploads/Main/vergleich.gif

Aus diesem Vergleich wird klar, warum der PID-Regler so beliebt ist, er vereinigt die Vorzüge aller anderen Regler.

==Digitaler Regler==
Durch die Einführung leistungsfähiger und preiswerter Mikroprozessoren hat sich der digitale Regler mehr und mehr durchgesetzt. Im Gegensatz zum analogen Regler werden die Signale nicht mehr analog mit Operationsverstärker verarbeitet, sondern mit einem Mikroprozessor errechnet. Bevor das Signal vom Mikroprozessor bearbeitet werden kann, muss zunächst das Eingangssignal (Istwert) mit einem Analog-Digital-Umsetzer (ADU) digitalisiert werden, d.h. in einen Zahlenwert umgewandelt werden. Das vom digitalen Regler errechnete Ausgangssignal (Stellgröße) wird wiederum zur Ansteuerung des Stellglieds mit einem Digital-Analog-Umsetzer (DAU) in ein analoges Signal gewandelt. Funktionell unterscheiden sich analoger und digitaler Regler jedoch nicht wesentlich, es müssen nur die Schnittstellen angepasst werden.

[[File:digreg.gif|right|framed|Digitaler Regler (Prinzip)]]

Da die Wandlungen und das Regelprogramm eine gewisse Zeit beanspruchen, vergeht pro Durchlauf die sogenannte Takt- oder Abtastzeit. Diese Zeit wirkt sich im Regelkreis wie ein Totzeitglied mit der halben Abtastzeit als Totzeit aus. Das verursacht eine zusätzliche Phasenverschiebung, was sich ungünstig auf die Stabilität des Regelkreises auswirken kann. Ist die Abtastzeit sehr viel kleiner als die dominierende Zeitkonstante der Strecke, dann spricht man von quasi-kontinuierlichem Verhalten, da sich der digitale Regler ähnlich wie ein analoger Regler verhält. Der digitale Regler kann dann wie ein analoger dimensioniert werden. Ist die Abtastzeit größer, kann sie nicht mehr vernachlässigt werden, dann muss sie auch beim Reglerentwurf berücksichtigt werden.

'''Vorteile digitaler Regler:'''
* Die Verarbeitung erfolgt driftfrei.
* Es lassen sich nichtlineare Kennlinien, intelligentes Verhalten oder adaptive Regelung leichter realisieren.
* Der Regler kann bei Bedarf per Software neu konfiguriert und parametriert werden

'''Digitale Realisierung am Beispiel des PID-Algorithmus'''

Ausgehend von der Differentialgleichung für kontinuierliche Systeme wird die Differenzengleichung für zeitdiskrete Systeme erstellt. Daraus folgt dann der Stellungsalgorithmus in allgemeiner Form.

Ta = Abtastzeit; k = Nummer der Abtastung

Kp = Proportionalbeiwert; Ki = Integrierbeiwert; Kd = Differenzierbeiwert



'''Differentialgleichung für den kontinuierlichen PID-Regler:'''
:<math>
y(t) \;=\; Kp \!\cdot\! e(t)
+ Ki \int_0^t e(\tau) \, d\tau
+ Kd \, \frac{de(t)}{dt}
</math>

'''Differenzengleichung für den zeitdiskreten PID-Regler:'''
:<math>
y_k \;=\; Kp \!\cdot\! e_k
+ Ki \!\cdot\! Ta \sum_{i=0}^k e_i
+ \frac{Kd}{Ta}\, ( e_k - e_{k-1} )
</math>

'''PID Stellungs-Algorithmus:
:''' <math>
y_k \;=\; y_{k-1}
+ q_0 \!\cdot\! e_k
+ q_1 \!\cdot\! e_{k-1}
+ q_2 \!\cdot\! e_{k-2}
</math>

Mit den Parametern:
:<math>
q_0 \,=\, Kp + Ki \!\cdot\! Ta + \frac{Kd}{Ta}
\, , \quad
q_1 \,=\, -Kp - 2 \, \frac{Kd}{Ta}
\, , \quad
q_2 \,=\, \frac{Kd}{Ta}
</math>

'''Umsetzung in Code nach der Differenzengleichung:'''

Im Code wurden einige Variablen umbenannt, da die Indexschreibweise nicht möglich ist.

y entspricht y<sub>k</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, esum ist die Summenbildung

In der Praxis wird man die Ausdrücke Ki*Ta und Kd/Ta vorab berechnen und mit Ersatzvariablen in die Reglergleichung einsetzen. Der Verständlichkeit halber wurde es hier im Code belassen. Des weiteren kann eine Begrenzung von esum notwendig werden, um einen Variablenüberlauf oder Windup-Effekt zu vermeiden.

Der nachfolgende Code wird im Rhythmus der Abtastzeit Ta immer wieder aufgerufen.
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
y = Kp*e + Ki*Ta*esum + Kd/Ta*(e – ealt); //Reglergleichung
ealt = e;
----

'''Alternative Umsetzung in Code nach dem Stellungsalgorithmus:'''<br/>
y entspricht y<sub>k</sub>, yalt entspricht y<sub>k-1</sub>, e entspricht e<sub>k</sub>, ealt entspricht e<sub>k-1</sub>, ealt2 entspricht e<sub>k-2</sub>
e = w - x; //Vergleich
y = yalt + q0*e + q1*ealt + q2*ealt2; //Reglergleichung
ealt2 = ealt;
ealt = e;
yalt = y;

==Dimensionierung des Reglers==
Die Auswahl des Reglertyps ist heutzutage bei den digitalen Reglern nicht mehr so kritisch, da der Mehraufwand in Software für einen PID-Regler gegenüber einfacheren Typen kaum zu Buche schlägt. Im Prinzip ist man deshalb mit einem PID-Regler fast immer auf der richtigen Seite, mit einer Ausnahme, bei einer Strecke mit reiner Totzeit. Die folgende Tabelle gibt eine Hilfestellung zur Auswahl des Reglers.

{| border=1 cellpadding=4
|+ '''Geeignete Reglertypen für die unterschiedlichen Regelstrecken'''
|rowspan=2 |'''Strecke'''
|colspan=4 |<div align="center">'''Regler'''</div>
|-
|<div align="center">'''P'''</div>
|<div align="center">'''PD'''</div>
|<div align="center">'''PI'''</div>
|<div align="center">'''PID'''</div>
|-
|reine Totzeit
| 
| 
|<div align="center">geeignet</div>
| 
|-
|1.Ordnung mit kleiner Totzeit
| 
| 
|gut geeignet
|gut geeignet
|-
|2.Ordnung mit kleiner Totzeit
| 
| 
| 
|gut geeignet
|-
|höhere Ordnung
| 
| 
| 
|gut geeignet
|-
|I-Glied und Verzögerung
|geeignet
|gut geeignet
|<div align="center">geeignet</div>
|gut geeignet
|}

Nachdem man einen geeigneten Reglertyp ausgewählt hat, stellt sich noch die Frage, wie man die Reglerparameter Kp, Ki, und Kd optimiert. Im Laufe der Zeit wurden viele Methoden zur Dimensionierung der Reglerparameter entwickelt, aber es können hier nicht alle aufgelistet werden. Diese Aufzählung beschränkt sich auf die einfacheren und gängigen Methoden der Parametrierung.

===Dimensionierung durch Probieren (Empirisches Einstellen)===

====Methode 1====
Diese Methode ist geeignet um einfache Systeme zu dimensionieren, insbesondere wenn man bereits Erfahrung mit ähnlichen Regelkreisen hat. Man fängt mit einer unkritischen Einstellung (Kp klein, Ki = 0, Kd = 0) an und erhöht langsam die Verstärkung Kp, bis die Dämpfung schlecht wird. Falls eine Schwingneigung auftritt, muss die Verstärkung wieder etwas zurück genommen werden. Dann nimmt man allmählich den Integralanteil hinzu, erhöht ihn in Schritten und probiert solange herum, bis das Ergebnis einigermaßen passt. Bei Bedarf kann noch ein D-Anteil (PID-Struktur) probiert werden. Wenn dabei die Regelung stabiler wird, kann noch mal Kp und Ki erhöht werden, bis man endgültig zufrieden ist.

====Methode 2====
Alle Anteile erstmal auf 0. Dann erhöht man Kp so lange bis das System deutlich schwingt. Danach wird der Kd so lange erhöht bis das System nicht mehr schwingt. Anschliessend kann noch ein kleiner Ki Anteil hinzugegeben werden.

Es dürfte klar sein, dass so eine Optimierung im Blindflug nicht immer das Optimum ergibt, aber es ist eine gängige praktische Methode zur Ermittlung der Reglerparameter. Besser sieht es aus, wenn in einer Simulation empirisch optimiert wird. Zusätzliche Informationen über die Stabilität erlauben hierbei eine gezieltere Optimierung. Zudem ist das Probieren im Simulator gefahrlos möglich, was in der Realität nicht immer der Fall ist. Geeignete Programme zur Simulation sind [[Regelungstechnik#Hilfsprogramme_zur_Analyse_und_Optimierung| hier]] vorgestellt. Allerdings muss für eine Simulation die Regelstrecke bekannt sein. Ist das nicht der Fall, so bleibt nur das einfache Probieren oder das Einstellen nach der Schwingungsmethode wie im folgenden beschrieben.

===Dimensionierung nach Einstellregeln===
Die Dimensionierung nach Rezept ist eine praktische Methode ohne viel Rechnerei und Hilfsmittel, eine Methode also für den Praktiker. Die bekanntesten Einstellregeln sind von Ziegler/Nichols und von Chien/Hrones/Reswick. Darüber hinaus gibt es noch eine Vielzahl anderer Einstelltabellen, auf die hier aber verzichtet wird, das würde den Rahmen dieses Artikels sprengen. An der Vielzahl kann man schon ersehen, dass es kein universell gültiges Rezept gibt und mit diesen Tabellen nicht unbedingt das Optimum erreicht wird, eine Nachoptimierung kann nötig sein.

Bei Ziegler/Nichols unterscheidet man noch zwischen der Schwingungsmethode und der Einstellung nach der Sprungantwort.

'''Einstellung nach der Schwingungsmethode:'''<br/>
Bei der Schwingungsmethode nach Ziegler/Nichols werden die Reglerparameter so verstellt, dass die Stabilitätsgrenze erreicht wird und der Regelkreis zu schwingen beginnt, d.h. die Regelgröße periodische Schwingungen ausführt. Aus der so gefundenen Einstellung können die Reglerparameter ermittelt werden. Dieses Verfahren ist nur auf Regelstrecken anwendbar, bei denen ein Schwingen keinen Schaden anrichtet und die überhaupt instabil gemacht werden können. Die Vorgehensweise ist folgende:
# Einstellung des Reglers als reinen P-Regler: Ki = 0 und Kd = 0
# Die Reglerverstärkung Kp wird solange vergrößert, bis sich der geschlossene Regelkreis an der Stabilitätsgrenze befindet und Dauerschwingungen ausführt.
# Der dabei eingestellte Wert Kp wird als Kp<sub>krit</sub> bezeichnet.
# Die Periodendauer der sich einstellenden Dauerschwingung T<sub>krit</sub> wird gemessen.
# Anhand der folgenden Tabelle werden dann die Reglerparameter bestimmt.

{| cellpadding=10
|
{| border=1 cellpadding=4
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|0.5*Kp<sub>krit</sub>
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.45*Kp<sub>krit</sub>
|<div align="center">0.85*T<sub>krit</sub></div>
| 
|-
|<div align="center">'''PID'''</div>
|0.6*Kp<sub>krit</sub>
|0.5*T<sub>krit</sub>
|0.12*T<sub>krit</sub>
|}
|
{| border=0 cellpadding=4
|'''Ki = Kp/Tn'''
|-
|'''Kd = Kp*Tv'''
|}
|}

Der Vorteil dieses Verfahrens liegt darin, dass die Untersuchung während des Betriebes und ohne Öffnen des Regelkreises durchgeführt werden kann. Der Nachteil an dem Verfahren ist, dass es nur auf Strecken angewendet werden kann, die auch zum Schwingen gebracht werden können.

'''Einstellung nach der Sprungantwort:'''<br/>
Diese Methode der Parameterbestimmung beruht auf der Aufnahme der Sprungantwort der Regelstrecke. Es eignet sich auch für Strecken, die nicht zum Schwingen gebracht werden können. Der Regelkreis muss allerdings geöffnet werden.
Vorgehensweise: Es wird die Sprungantwort aufgenommen und durch Einzeichnen der Wendetangente die Verzugszeit Tu und die Ausgleichszeit Tg ermittelt.

[[Bild:Tu_Tg.gif]]

Mit den so festgestellten Werten werden die Parameter für den einzusetzenden Regler gemäß nachstehenden Tabellen ermittelt.

{| cellpadding=10
|
{| border=1 cellpadding=4
|+ Einstellregeln nach Ziegler/Nichols:
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|1/Ks*Tg/Tu
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.9/Ks*Tg/Tu
|3.3*Tu
| 
|-
|<div align="center">'''PID'''</div>
|1.2/Ks*Tg/Tu
|2*Tu
|0.5*Tu
|}
|
|
{| border=1 cellpadding=4
|+ Einstellregeln nach Chien/Hrones/Reswick
|'''Regler'''
|<div align="center">'''Kp'''</div>
|<div align="center">'''Tn'''</div>
|<div align="center">'''Tv'''</div>
|-
|<div align="center">'''P'''</div>
|0.3/Ks*Tg/Tu
| 
| 
|-
|<div align="center">'''PI'''</div>
|0.35/Ks*Tg/Tu
|1.2*Tg
| 
|-
|<div align="center">'''PID'''</div>
|0.6/Ks*Tg/Tu
|<div align="center">Tg</div>
|0.5*Tu
|}
|}

{| cellpadding=10
|
{| border=1 cellpadding=4
|'''Ki = Kp/Tn'''
|-
|'''Kd = Kp*Tv'''
|}
|
{| cellpadding=4 width=420
|Die Parameter Tn und Tv sind aus der analogen Regelungstechnik und sind dort sehr geläufig. Die Umrechnung in die Parameter Ki und Kd erfolgt mit nebenstehenden Formeln. Siehe auch [[Regelungstechnik#PID-Regler| PID-Regler]]
|}
|}

===Dimensionierung mit dem Bodediagramm===
Ein Bode-Diagramm ist die grafische Darstellung des Frequenzganges. Es werden der Betrag der Übertragungsfunktion (Amplitudengang) und der Verlauf des Phasenwinkels (Phasengang) als Funktion der Frequenz aufgetragen. Die Frequenzachse und die Amplitudenachse werden logarithmisch dargestellt. Die logarithmische Darstellung hat den Vorteil, dass eine Multiplikation auf eine einfache Addition zurückgeführt wird. Somit wird eine Hintereinanderschaltung von Systemen im Blockschaltbild zu einer einfachen Addition im Bodediagramm.

Das Zeitverhalten des rückgekoppelten Regelkreises hängt entscheidend vom Verlauf
des Frequenzganges der offenen Regelschleife in der Umgebung des Durchtretens durch
die 0dB-Achse ab. In der Regelungstechnik wird daher der offene Regelkreis im Bode-Diagramm aufgetragen. Das erlaubt einen schnellen Überblick über Stabilität und möglichen Reserven zur Optimierung. Ein Kriterium für die Stabilität der Schleife ist der Phasenrand und der Amplitudenrand. Der Phasenrand ist der Abstand (Phasenreserve) zur -180°-Linie bei der Durchtrittsfrequenz. Die Durchtrittsfrequenz ist diejenige Frequenz, bei der der Amplitudengang durch die 0dB-Linie geht. Siehe auch folgendes Bode-Diagramm.

[[Bild:Phasenrand.gif]]

{| {{Blauetabelle}}
|'''Regel:''' Eine geschlossene Regelschleife arbeitet genau dann stabil, wenn der Phasenrand positiv ist.
|}
Wird diese Bedingung verletzt, so wird in diesem Frequenzbereich die im Rückführzweig der Regelung eingebrachte Gegenkopplung zu einer Mitkopplung und das System kann schwingen.

'''Beim Reglerentwurf sind folgende Punkte zu beachten:'''
* Der Phasenrand muss positiv sein. Der geschlossene Regelkreis kann sonst instabil sein.
* Je größer der Phasenrand ist, desto größer ist die Stabilitätsreserve des Regelkreises und desto höher ist die Dämpfung des Regelkreises. Üblich sind Werte von 40°...70° für gutes Führungsverhalten und 20°...50° für gutes Störverhalten.
* Die Durchtrittsfrequenz ist ein Maß für die Schnelligkeit des Regelkreises, je höher, desto schneller ist die Reaktion auf Änderungen der Führungsgröße oder Störungen.

Hier ein Beispiel zur Dimensionierung mit dem Bode-Diagramm.

[[Bild:Bode1.gif]]

Die Strecke ist rot dargestellt und besteht in dem Beispiel aus einem nicht schwingfähigem PT2-Glied. Man sucht sich den Punkt, wo die Strecke für sich alleine noch ausreichend Phasenreserve hat, z.B. 70°. In dem Beispiel also die Frequenz, bei der die Strecke -110° Phasendrehung aufweist. Das ist etwa bei 15Hz. Da hat die Strecke ungefähr eine Dämpfung von 25dB. Wenn man nun diese Dämpfung durch eine Verstärkung von 25dB kompensiert, dann wird dieser Punkt zur Durchtrittsfrequenz. D.h. man wählt den P-Anteil des Reglers Kp=18, denn 25dB entspricht ungefähr dem Faktor 18. Um die Regelabweichung zu minimieren, wird noch ein I-Anteil hinzugefügt. Üblicherweise wählt man für die Grenzfrequenz des PI-Reglers die Grenzfrequenz des dominierenden Streckenteils, in dem Beispiel ca. 1.4Hz. Damit ergibt sich ein I-Anteil von 170. Im Bode-Diagramm ist der PI-Regler als schwarze Kurve eingezeichnet. Die Addition der Strecke und des Reglers im Bode-Diagramm führt dann zum Frequenzgang des offenen Regelkreises (blaue Kurve). Die resultierende Durchtrittsfrequenz ist wie gewählt bei etwa 15Hz. Der Phasenrand hat sich durch den I-Anteil im Regler auf ca. 60° reduziert, ist aber noch ausreichend. Das Einschwingen des geschlossenen Regelkreises für diese Dimensionierung sieht dann folgendermaßen aus:

[[Bild:Sprungantwort3.gif]]

Bei Bedarf könnte noch ein D-Anteil (PID-Regler) hinzugenommen werden, das würde die Phase anheben und man könnte dadurch die Durchtrittsfrequenz weiter nach oben schieben. In der Praxis wird dies allerdings wegen der wahrscheinlichen Begrenzung des Stellglieds kein schnelleres Einschwingen mehr bringen.

Begrenzungen oder Nichtlinearitäten werden bei der Dimensionierung mit dem Bode-Diagramm nicht berücksichtigt. Das ist ein Nachteil dieser Methode. Eventuell muss deshalb noch einmal im Zeitbereich nachoptimiert werden.

===Dimensionierung mit der Ortskurve===
Eine Alternative zur Dimensionierung mit dem Bodediagramm stellt die Methode über die Ortskurve des offenen Regelkreises dar.

Bei diesem Verfahren ist schnell auf einem Blick ersichtlich ob der Regelkreis stabil ist.

Liegt der Punkt -1 auf der Realteilachse links von der Ortskurve in Richtung steigendem Omega so ist der Regelkreis stabil.
Der Abstand zu der kritischen Kreisfrequenz Omega Krit von der Imaginärteilachse ist die Verstärkung Vr mit diesem Wert lässt sich der Amplitudenrand ermitteln.
Dazu wird folgende Formel verwendet: Ar = 20 lg (1/Vr) in dB

Die Durchtrittskreisfrequenz Omega D ist an dem Punkt, wo der Betrag aus Realteil und Imaginärteil 1 ergibt. Wenn man weiß, wo die Durchtrittskreisfrequenz ist, dann kann man den Phasenrand bestimmen.
Dies ist der Winkel zwischen der -180° Linie zu Omega D.

[[Bild:Ortskurve.jpg]]

==Hilfsprogramme zur Analyse und Optimierung==
Die Analyse und Optimierung von Regelkreisen wird wesentlich erleichtert durch die Zuhilfenahme von Programmen. Es erspart einem eine komplizierte Rechnerei von Hand oder umfangreiche Testläufe. Stellvertretend für all die verfügbaren Programme werden hier zwei Freeware-Programme vorgestellt, die dafür gut geeignet sind. Die Beschreibung hier ersetzt aber keine Tutorials, es wird nur die Anwendung für die Regelungstechnik beschrieben.

===Scilab/Scicos===
Scilab ist ein wissenschaftlich-technisches Softwarepaket für numerische Berechnungen. Scicos ist eine Erweiterung dazu, die eine blockorientierte und modellbasierte Simulation und Analyse von dynamischen Systemen bietet. Dieses Softwarepaket kann von der [http://www.scilab.org/ Scilab Homepage] herunter geladen werden.

====Scilab====
Mit Scilab ist es sehr einfach ein Bode-Diagramm zu zeichnen, es bedarf nur 3 Zeilen Code.
s=poly(0,'s');
G=syslin('c',0.72/(0.11*s+1));
bode(G)
Die 1.Zeile '''s=poly(0,'s');''' legt die Variable s als Polynomvariable fest. Dies braucht in einer Sitzung nur einmal gemacht zu werden. Die 2.Zeile '''G=syslin('c',0.72/(0.11*s+1));''' definiert ein lineares System mit der Übertragungsfunktion 0.72/(0.11s+1). Die 3.Zeile '''bode(G)''' zeichnet das Bode-Diagramm des zuvor mit syslin definierten Systems G. Zu beachten ist, dass Scilab auf der x-Achse im Bode-Diagramm die Frequenz in Hertz und nicht wie üblich die Kreisfrequenz darstellt. Anstelle des Bode-Diagramms kann auch die Sprungantwort gezeichnet werden. Dies geschieht mit folgenden Befehlen:
xbasc();
t=[0:0.001:2];
y=csim('step',t,G);
plot2d(t,y)
'''xbasc()''' löscht den letzten Plot mit dem Bode-Diagramm und mit '''t=[0:0.001:2]''' wird ein Vektor t mit den angegebenen Zeiten im Intervall von 1ms definiert. Die Zeile '''y=csim('step',t,G)''' berechnet die Sprungantwort des zuvor mit syslin definierten Systems G und speichert sie in y ab. Das Ergebnis wird dann mit '''plot2d(t,y)''' dargestellt. Bei Bedarf können noch Gitternetzlinien mit dem Befehl '''xgrid()''' hinzugefügt werden.

Ergänzend hier noch ein Scilab-Skript, welches recht hilfreich bei der Dimensionierung mit dem Bode-Diagramm ist. Den nachfolgenden Code einfach in das SciPad-Fenster (Editor von Scilab) kopieren und starten. Es werden 2 Grafikfenster angezeigt, eines mit dem Bode-Diagramm und ein zweites mit der Sprungantwort. Man kann im Skript die Streckencharakteristik anpassen und verschiedene Reglerparameter ausprobieren.

<pre>
Ks=0.72; // Verstärkung der Strecke
T1=0.11; // Zeitkonstante 1
T2=0.005; // Zeitkonstante 2
Kp=18; // Proportionalbeiwert
Ki=170; // Integralbeiwert
Kd=0; // Differenzialbeiwert

s=poly(0,'s'); // definiert s als Polynomvariable
P=(T1*s+1)*(T2*s+1); // Streckencharakteristik
Gs=syslin('c',Ks,P) // Übertragungsfunktion der Strecke

RZ=poly([Ki Kp Kd],'s','coeff') // Zählerpolynom des Reglers
RN=poly([0 1],'s','coeff') // Nennerpolynom des Reglers
Gr=syslin('c',RZ,RN) // Übertragungsfunktion des Reglers

G=Gr*Gs // Übertragungsfunktion gesamt
xset("window",0);
xbasc(0);
bode([Gr;G;Gs],0.1,100,['Regler';'gesamt';'Strecke'])

Gcl=G/(G+1) // geschlossene Regelschleife
t=0:0.001:0.2;
y=csim('step',t,Gcl); // berechnet Sprungantwort
xset("window",1);
xbasc(1);
plot2d(t,y,2);
xgrid();
xtitle("Sprungantwort","sec");
</pre>

====Scicos====
Eine weitere Möglichkeit zur Simulation im Zeitbereich bietet Scicos. Die Modellierung geschieht mit einem grafischen Editor, in dem Blöcke mit vordefinierten oder selbstgemachten Funktionen miteinander verbunden werden. Ein einfaches Modell eines Regelkreises mit PID-Regler sieht folgendermaßen aus:

[[Bild:Scicos_anaReg.gif]]

Der PID-Regler ist mit seinen 3 Zweigen (P, I und D) dargestellt. In den Verstärkerblöcken kann durch Ändern der Reglerparameter (KP, KI und KD) der Regler optimiert werden. Die Strecke ist in diesem Beispiel nur ein einzelner Block, in dem die Übertragungsfunktion eingegeben wird. Man kann die Strecke auch detaillierter mit einzelnen Funktionsblöcken darstellen. Ein Beispiel eines komplexen Blockschaltbilds für einen balancierenden Bot ist unter diesem [http://www.roboternetz.de/phpBB2/download.php?id=5082 Link] zu finden.

Der Vorteil der Simulation mit Scicos ist die Möglichkeit Nichtlinearitäten zu berücksichtigen und die Kombination von kontinuierlichen und diskreten Funktionen. Das heißt, man kann einen digitalen Regler mit seinen diskreten Schritten und eine analoge Strecke, als kontinuierliche Funktion eingegeben, zusammen simulieren. Scicos bietet sogar einen 'Scifunc'-Block, mit dem Rechenschritte des digitalen Reglers nachgebildet werden können. Damit wird sowohl das dynamische Verhalten, verursacht durch die Abtastzeit Ta, als auch die etwas unterschiedliche Dynamik durch die digitale Ausführung eines I- und D-Anteils richtig simuliert. Ein Beispiel für den Einsatz des Scifunc-Blocks ist in folgendem Blockschaltbild zu sehen.

[[Bild:Scicos_digReg.png]]

Beispiel: [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlregelung]] mit digitalem Regler

Die globalen Variablen für die Reglerparameter und die Abtastzeit werden unter dem Menüpunkt „Edit - Context“ abgelegt.
Kp=18;
Ki=60;
Ta=0.01;
In den Taktgeber für den digitalen Regler wird als Clock-Periode die Abtastzeit Ta eingetragen. In das Dialogfenster zum Scifunc-Block wird folgender Code zur Simulation des digitalen PI-Reglers eingetragen:
<pre>
z=z+Ki*Ta*u1
if z>5 then
z=5;
end
y1=Kp*u1+z
if y1>5 then
y1=5;
end
</pre>
z entspricht der Variable esum vom Beispiel des [[Regelungstechnik#Realisierung_mit_digitalem_Regler| digitalen Drehzahlreglers]]; u1 ist die Eingangsvariable und y1 die Ausgangsvariable des Scifunc-Blocks.
In den Block für die Strecke wird die Übertragungsfunktion eingetragen. Als Zähler die Verstärkung Ks, also 0.72. Im Nenner das Polynom (1+0.11*s) für die Charakteristik der Strecke. Mit ‚Simulate – Run’ wird die Simulation gestartet. Als Ergebnis sollte das Einschwingen der Stellgröße (schwarz) und der Regelgröße (grün), wie in folgender Abbildung erscheinen.

[[Bild:Sprungantwort_DZR.png]]

Man kann nun mit den Reglerparametern und verschiedenen Abtastzeiten spielen, um zu sehen wie sich die Änderungen auswirken. Zum Beispiel wird bei einer Verdopplung der Abtastzeit der Regelkreis bereits instabil.

Diese Beispiele sind nur ein kurzer Auszug von den Möglichkeiten mit Scilab/Scicos für den Einsatz in der Regelungstechnik. Darüber hinaus ist es auch sehr gut geeignet bei anderen Optimierungsverfahren wie z.B. beim WOK-Verfahren (Wurzelortskurven) oder zur Analyse und Optimierung von modernen Reglern wie z.B. Zustandsregler und Kalmanfilter.

===LTspice/SwitcherCad III===
Dieses Programm ist ein SPICE-Derivat von der Firma Linear Technology und ist unter den 2 Namen LTspice und SwitcherCad III bekannt. Der Einfachheit halber wird für die weitere Beschreibung hier nur der Name LTspice verwendet. Das Programm ist Freeware und kann unter diesem Link herunter geladen werden. http://ltspice.linear.com/software/LTspiceIV.exe

LTspice ist ein Simulationsprogramm zur Analyse von elektronischen Schaltungen. Mit LTspice kann sowohl im Zeitbereich als auch im Frequenzbereich analysiert werden und bietet sich dadurch mit den entsprechenden Modellen auch für den Einsatz in der Regelungstechnik an. Wer sich bereits mit SPICE-Programmen auskennt, für den sollte es auch in der Regelungstechnik die 1.Wahl sein.

Der Vorteil von LTspice ist die Möglichkeit einer sehr detaillierten Analyse, vorausgesetzt die Modelle sind auch so detailliert nachgebildet. Insbesondere für analoge Regler, wo die elektrische Schaltung direkt umgesetzt werden kann, empfiehlt sich der Einsatz von LTspice. Der Nachteil ist, LTspice ist nicht auf regeltechnische Belange ausgelegt worden und spezifische Symbole für die Regelungstechnik müssen selbst erstellt werden. Einige selbst erstellte Symbole für dynamische Grundelemente in LTspice sind hier abgebildet.

[[Bild:LTSpiceSymb.png]]

Die 3 Symbole können [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=285 hier] heruntergeladen werden. Weitere Symbole können anhand dieser Beispiele sehr leicht selbst erstellt werden. Ein P-Glied kann durch eine spannungsgesteuerte Spannungsquelle (E-Source) oder Operationsverstärker mit einstellbarer Verstärkung dargestellt werden.

'''Analyse im Zeitbereich'''

Das Beispiel des [[Regelungstechnik#Beispiel:_Drehzahlregelung| Drehzahlreglers]] mit analogem Regler wird hier mit LTspice simuliert. Das Schaltbild des Regelkreises zeigt nachfolgende Abbildung.

[[Bild:LTspice_TRAN.png]]

Der Vergleicher (U1) und der analoge PI-Regler (U2) sind so dargestellt, wie es auch in Wirklichkeit ausgeführt werden kann. Da der PI-Regler in der Schaltung bereits invertiert, wurden die Eingänge am Vergleicher vertauscht, damit die Polarität wieder stimmt. Der Rest des Regelkreises wurde stark vereinfacht, kann aber nach Bedarf auch ausführlicher dargestellt werden. Das PT1-Glied U3 simuliert die Strecke des Regelkreises und der Verstärker U4 dient nur zur Umrechnung auf die Drehzahl. Zur Simulation im Zeitbereich wird auf den Führungswert w mit der Spannungsquelle V1 ein Sprung gegeben. In der Reglerschaltung wurde bewusst ein Operationsverstärker mit Versorgungsspannung gewählt, damit auch der Einfluss einer Begrenzung mit simuliert wird. Die Zeitbereichsanalyse wird durch den LTspicebefehl .TRAN erreicht. Die Sprungantwort (Tachospannung) bei diesem Regelkreis sieht dann folgendermaßen aus.

[[Bild:Tacho2.png]]

Durch Ändern der Bauelemente R5, R6 und C1 kann man den Regler optimieren. Eine Umrechnung auf die Reglerparameter Kp und Ki ist mit folgenden Formeln möglich, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5

Ki = 1/(R5*C1)

Mit einem Mausklick auf den entsprechenden Knoten in der Schaltung können noch weitere Signale, wie z.B. die Stellgröße y angezeigt werden. Durch Verändern der Versorgungsspannung V3, V4 kann man sich auch die Auswirkung der Begrenzung ansehen.

'''Analyse im Frequenzbereich'''

Für die Darstellung des Bode-Diagramms der offenen Regelschleife in LTspice muss ein Trick angewendet werden, denn durch das Auftrennen der Regelschleife würde der Arbeitspunkt verloren gehen und dadurch die offene Schleife ohne Gegenkopplung an den Anschlag fahren.

Mit einer zusätzlichen Spannungsquelle in der Schleife kann man dieses Problem umgehen. Die Schleife bleibt für den Erhalt des Arbeitspunktes weiterhin geschlossen und man kann trotzdem die Verstärkung der offenen Schleife durch das Verhältnis der Spannung vor und hinter der Spannungsquelle bestimmen. Das erweiterte Blockschaltbild sieht folgendermaßen aus.

[[Bild:LTspice_AC.png]]

V2 ist die zusätzliche Spannungsquelle für die AC-Analyse. Die Spannungsquelle V1 wird von Pulsform auf Gleichspannung umgestellt. Sie wird so gewählt, dass sich der gewünschte Arbeitspunkt einstellt. Durch den LTspicebefehl .AC wird die Analyse im Frequenzbereich veranlasst. Um das Bode-Diagramm des offenen Regelkreises darzustellen, wird als Kurve nicht ein einzelner Knoten ausgewählt, sondern das Verhältnis der Spannung vom Ende zum Anfang des Regelkreises, in unserem Beispiel also V(tacho)/V(x). Zur Anzeige kommt dann das Bode-Diagramm (grüne Kurve) der offenen Schleife, wie in der folgenden Abbildung zu sehen. Für den Amplitudengang (durchgezogene Linien) gilt die linke Skala in dB, für den Phasengang (gestrichelte Linien) die rechte Skala in Grad.

[[Bild:LTspice_Bode.png]]

Zusätzlich ist noch das Bode-Diagramm der Strecke (rote Kurve) zu sehen. Dies ist durch einfaches Hinzufügen einer weiteren Kurve mit dem Ausdruck V(tacho)/V(y) durchgeführt worden.

Im Gegensatz zur üblichen Darstellung des Bode-Diagramms eines offenen Regelkreises, beinhaltet das mit LTspice erstellte Bode-Diagramm auch die -180 Grad Phasendrehung der Gegenkopplung. Der Phasenrand ist deshalb nicht auf -180 Grad sondern auf 0 Grad zu beziehen. In unserem Beispiel ist der Phasenrand etwa 90 Grad, also ein sehr stabiler Regelkreis. Zu beachten ist, dass die Frequenzachse des Bode-Diagramms wie auch schon bei Scilab in der Einheit Hertz anstatt wie üblich in der Kreisfrequenzeinheit rad/s dargestellt ist.

==Modellierung eines Motors/Antriebs==
[[Bild:ESB_Motor.png|thumb|320px|Ersatzschaltbild DC-Motor]]
Der Motor ist ein oft verwendeter Aktuator in der Robotik. Deshalb wird hier am Beispiel des Gleichstrommotors mit Permanentmagnet (Nebenschlussmotor) die Modellbildung gezeigt. Zur Modellierung gibt es mehrere Möglichkeiten. Je nachdem wie detailliert die Simulation sein soll, kann man sich ein Modell, von sehr einfach bis sehr detailliert, auswählen. Zwei Zeitkonstanten bestimmen die Dynamik eines Gleichstrommotors. Eine davon ist die mechanische Zeitkonstante, die ist meistens die dominierende Zeitkonstante und wird durch das Trägheitsmoment J des Rotors verursacht. Die zweite Zeitkonstante ist die elektrische Zeitkonstante, sie wird durch die Induktivität L bestimmt. Bei einfachen Regelungen kann in den meisten Fällen die elektrische Zeitkonstante vernachlässigt werden, damit reduziert sich das Modell auf ein einzelnes PT1-Glied.

'''Definition: Motor und Antrieb'''

Als '''Motor''' wird hier der Motor alleine verstanden. Die Ausgangsgröße ist die Winkelgeschwindigkeit w (Drehzahl).

Als '''Antrieb''' wird hier der komplette Antrieb eines Fahrzeugs verstanden, also Motor inklusive Getriebe und Masse des Fahrzeugs. Für die Dynamik ist nicht nur das Trägheitsmoment des Motors sondern auch die Masse des Fahrzeugs verantwortlich. Die Ausgangsgröße der Einheit „Antrieb“ ist die Geschwindigkeit v.

Die hier vorgestellten Modelle gelten sowohl für einen Motor als auch für einen kompletten Antrieb, wenn man die Elastizität und das Spiel des Getriebes vernachlässigt.

===Einfaches Modell mit PT1-Glied===
Die einfachste Art einen Motor oder Antrieb zu simulieren, ist mit einem PT1-Glied als Modell. Das Simulationsprogramm [[Regelungstechnik#Scicos|Scicos]] bietet dazu einen Block zur Eingabe der Übertragungsfunktion (num(s)=Zähler, den(s)=Nenner der Übertragungsfunktion).
{| border=0 cellpadding=10
|Übertragungsfunktion:

<math>G(s)=\frac{K}{1+Ts}</math>

|Beispiel:
num(s) = K = 0.72
den(s) = 1 + Ts = 1 + 0.11s
|[[Bild:Scicos_TF.png]]
|}

Wird nicht nur das Ausgangssignal, also die Geschwindigkeit oder Drehzahl in der Simulation benötigt, sondern auch die Beschleunigung, dann kann nachfolgendes Modell verwendet werden. Dieses Modell ist der Differentialgleichung eines PT1-Glieds nachempfunden und liefert das gleiche Ergebnis wie vorheriges Modell, bietet aber noch den Zugriff auf das Beschleunigungssignal.
{| border=0 cellpadding=10
|Differentialgleichung:

<math>v'=\frac{K}{T}U-\frac{1}{T}v</math>

|
v = Geschwindigkeit
v’= Beschleunigung (Ableitung von v)
K = Übertragungsmaß
T = Zeitkonstante
U = Eingangsgröße (z.B. Spannung)
|[[Bild:Antrieb_PT1.png|thumb|Einfaches Modell eines Antriebs]]
|}

Die beiden Parameter K und T müssen ausgemessen werden, wenn sie nicht bekannt sind. Die Zeitkonstante T kann in einem Anlaufversuch ermittelt werden. Dazu wird auf den Motor ein Spannungssprung gegeben und die Sprungantwort am Ausgang nachgemessen. Bei einem Antrieb erspart diese Methode die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente (Motor, Getriebe, Fahrzeug). Bei der Ermittlung des Übertragungsmaß K ist zu beachten, dass sich möglicherweise der Motor durch starke Reibung erst ab einer bestimmten Spannung dreht. Hier ist die Steigung der Kennlinie mit delta v / delta U auszuwerten, wie im folgenden Bild zu sehen ist.

[[Bild:Antrieb_stat.png]]

Die einfachen Modelle gelten nur für den linearen Teil der Kennlinie. Soll auch die Nichtlinearität durch Reibung modelliert werden, dann sind detailliertere Modelle, wie im Folgenden beschrieben, zu verwenden. Die Auswirkung einer Haftreibung ist auch in dem Geschwindigkeitsdiagramm durch die Hysterese in der Kennlinie zu sehen. Beim Hochfahren der Ansteuerspannung bewegt sich das Fahrzeug erst ab ca. 1.25V, während beim Herunterfahren der Ansteuerspannung das Fahrzeug noch bis 0.75V rollt und erst unter 0.75V stehen bleibt.

===Detailliertes Modell===

[[Bild:Motor_Model.png|thumb|350px|Detailliertes Motormodell]]
Ein detailliertes Motormodell ist rechts in dem Bild zu sehen. Es hat auf der linken Seite den elektrischen Teil mit den Parametern R (Widerstand) und L (Induktivität) und auf der rechten Seite den mechanischen Teil mit den Blöcken Trägheitsmoment und Reibung. Der elektrische Teil liefert das Stromsignal i, welches mit der Motorkonstante Km in das Drehmoment M umgerechnet wird. Mit dem folgenden Summierglied kann über einen zusätzlichen Eingang auch ein extern angreifendes Lastmoment mit simuliert werden. Am Ausgang des mechanischen Teils steht die Winkelgeschwindigkeit w in der Einheit [rad/s] bzw. über den Umrechnungsfaktor 9.55 die Drehzahl in [Upm] zur Verfügung. Die Reibung wird in einem nichtlinearen Block mittels Lookup-Table simuliert. In der einschlägigen Literatur wird die Reibung meistens mit einem Dämpfungsfaktor (linear) simuliert, was einer viskosen Reibung entspricht. Das passt aber nicht so gut für Kleinmotoren, da überwiegt vor allem die trockene Reibung. Die trockene Reibung hat ein konstantes Bremsmoment wenn sich der Motor dreht (unabhängig von Drehzahl, Vorzeichen abhängig von Drehrichtung). So eine Funktion kann sehr einfach mit einer Lookup-Table realisiert werden. Die Lookup-Table kann auch dazu verwendet werden, Mischformen von trockener, viskoser und turbulenter Reibung und sogar noch Haftreibung in einem Block zu simulieren, wenn man will.

Bei einigen Herstellern, wie z.B. Faulhaber und Maxon, kann man die für das Modell nötigen Parameter im Datenblatt finden. Das Bremsmoment der Reibung berechnet sich aus dem Leerlaufstrom wie folgt: Bremsmoment = Motorkonstante * Leerlaufstrom

Falls die Daten nicht verfügbar sind, muss man sie selbst ausmessen. Eine Hilfestellung zur Bestimmung der Motorkonstante und des Trägheitsmoments gibt es hier:
*http://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=96750&highlight=#96750
*http://www.roboternetz.de/phpBB2/viewtopic.php?t=12793

[[Bild:Antrieb_Modell.png|thumb|350px|Modell eines Antriebs]]

Das detaillierte Motormodell kann auch für einen Antrieb verwendet werden, wenn man eine starre Kopplung zwischen Motor und Antriebsrad voraussetzt, also Elastizität und Spiel des Getriebes vernachlässigt. Anstelle der rotatorischen Kenngrößen (Drehmoment M, Trägheitsmoment J, Winkelgeschwindigkeit w) werden die translatorischen Kenngrößen (Kraft F, Masse m, Geschwindigkeit v) eingesetzt. Das Drehmoment wird mittels Getriebeübersetzung ü und Radius r des Antriebsrades in die entsprechende Vortriebskraft umgerechnet. Daraus ergibt sich die Kraftkonstante Kf, die für das Antriebsmodell verwendet wird.

Die Umrechnung ist: Kf = Km * ü/r

Bei der Trägheitsmasse m muss neben der Masse des Fahrzeugs auch das Trägheitsmoment des Motors mit berücksichtigt werden. Die Umrechnung von Trägheitsmoment in eine äquivalente Masse = J * (ü/r)²

Der Reibungsblock in diesem Modellbeispiel enthält eine Mischform aus Haftreibung, trockener und viskoser Reibung, wie sie typisch für einen Kleinbot mit 2 Antriebsrädern und einem Gleitpin ist.

==Beispiel: Drehzahlregelung==
Es wird ein Gleichstrommotor in der Drehzahl geregelt. Als Sensor ist ein Tachogenerator vorhanden, der direkt auf der Motorwelle sitzt. Das System ist in einem kleinen Modellfahrzeug eingebaut und wird zur Geschwindigkeitsregelung eingesetzt, da die Drehzahl proportional zur Geschwindigkeit ist.

Das Funktionsschaltbild sieht folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl1.gif

Als Störgröße können unterschiedliche Reibwerte oder Steigung und Gefälle rückwirkend über das Getriebe die Drehzahl beeinflussen. Das Getriebe und die Last sind zwar außerhalb der Regelschleife, beeinflussen aber durch die feste Kopplung des Getriebes die Dynamik des Regelkreises. Durch die starre Kopplung kann das Trägheitsmoment des Motors und die Masse des Fahrzeugs zusammengefasst werden. Das Gleiche gilt auch für die Reibwerte. Damit vereinfacht sich die Modellierung und das Blockschaltbild reduziert sich auf folgende Schaltung:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl2.gif

Zur Ermittlung des dynamischen Verhaltens der Regelstrecke wird die Sprungantwort gemessen. Dazu wird auf den Eingang der Regelstrecke (Stellglied) ein Spannungssprung gegeben und die Antwort am Ausgang des Tachogenerators nachgemessen. Diese Methode erspart die aufwändige Ermittlung der elektrischen und mechanischen Daten der einzelnen Elemente der Regelstrecke (Motor, Getriebe, Fahrzeug). Die Messung ergab folgende Sprungantwort der Regelstrecke:

http://www.roboternetz.de/wiki/uploads/Main/tacho.gif

Wie zu erwarten, ist die Sprungantwort annähernd ein Verzögerungsglied 1.Ordnung. Die abgelesene Zeitkonstante ist 0.11s. Die Verstärkung der Regelstrecke ist Ks = 0.72. Das Übertragungsmaß des Tachogenerators ist 1V pro 2480Upm. Damit kann auf die Drehzahl rückgerechnet werden.

Da die Regelstrecke nur aus einem PT1-Glied besteht, könnte eine analoge Regelung fast beliebig schnell gemacht werden. Wegen der Begrenzung bringt aber das Ausreizen der Optimierung für das Führungsverhalten nicht viel, nur für das Störverhalten wäre eine schnellere Regelung sinnvoll. Um aber einen Vergleich zwischen analogem und digitalem Regler anstellen zu können wird eine Parametrierung gewählt, die auch für den digitalen Regler mit seiner Totzeit noch stabil ist. Es wird deshalb auch auf einen D-Anteil im Regler verzichtet und nur ein PI-Regler realisiert. Das vereinfachte Blockschaltbild mit den dynamischen Elementen sieht damit folgendermaßen aus:

http://www.roboternetz.de/wiki/uploads/Main/drehzahl3.gif

Zur Veranschaulichung wurde ein analoger als auch ein digitaler Regler realisiert. Die Parametrierung des analogen Reglers wurde mit dem Programm [[Regelungstechnik#LTspice.2FSwitcherCad_III| LTspice]] durchgeführt. Es bot sich an, da die analoge Reglerschaltung exakt simuliert werden konnte. Für die Optimierung des digitalen Reglers wurde dann [[Regelungstechnik#Scicos| Scicos]] verwendet.

===Realisierung mit analogem Regler===
Die elektrische Schaltung für einen analogen PI-Regler ist in der nächsten Abbildung zu sehen. Der erste Operationsverstärker vergleicht den Sollwert w mit dem Istwert x. Der zweite Operationsverstärker bildet den PI-Regler. Die Werte R5, R6 und C1 sind für die Charakteristik des PI-Reglers zuständig. Mit R6 kann der P-Anteil und mit C1 der I-Anteil eingestellt werden. Die Optimierung der Werte wurde empirisch in einer Simulation mit LTspice durchgeführt. Da die Schaltung des PI-Reglers invertiert, wurden zum Ausgleich am Vergleicher die Eingänge an U1 vertauscht, so dass sich über die gesamte Schaltung wieder die richtige Polarität ergibt.

[[Bild:Analogregler.png]]

Zum Umrechnen auf Kp und Ki können diese Formeln verwendet werden, siehe auch [[Regelungstechnik#PI-Regler| PI-Regler]]:

Kp = R6/R5 = 18

Ki = 1/(R5*C1) = 147

===Realisierung mit digitalem Regler===
Im digitalen Regelkreis wird der Istwert '''x''' vom Tachogenerator mit einem A/D-Wandler digitalisiert. Der Sollwert '''w''' wird dem µC als digitaler Wert übergeben. Die Stellgröße '''y''' entspricht dem PWM-Wert für den Motortreiber. Um zum analogen Regler vergleichbar zu sein, wurde sowohl für den A/D-Wandler als auch für den PWM-Steller eine 8-Bit-Breite vorgesehen. Damit ist die Verstärkung in beiden Fällen gleich und analoger und digitaler Regler besser vergleichbar.

Eigentlich könnte man bei kleiner Abtastzeit direkt die Parametrierung des analogen Reglers für die digitale Realisierung übernehmen. Aber es gibt doch kleine Unterschiede in der Dynamik zwischen analoger und digitaler Ausführung und um sicher zu gehen, dass die gewählte Abtastzeit einen nicht zu großen Einfluss hat, wird noch einmal mit [[Regelungstechnik#Scicos| Scicos]] nachoptimiert. Mit einer Abtastzeit Ta = 10ms und den Parametern des analogen Reglers ergibt sich ein Überschwingen, das nur sehr langsam auf den Endwert abklingt. Durch Verringern des I-Anteils auf 60 wird ein optimales Einschwingen für den digitalen Regler erreicht. Die Parameter sind:

Kp = 18

Ki = 60

Ta = 0.01

Zur Umsetzung in einen Code wurde die Programmiersprache C gewählt. Da der Code sehr einfach ist, sollte es auch kein Problem sein, den Code als Beispiel für andere Sprachen zu verwenden. Der Algorithmus wird im Takt der Abtastzeit, also alle 10ms aufgerufen. In der Reglergleichung kann zur Vereinfachung das Produkt Ki*Ta durch eine Ersatzvariable, die gleich das Ergebnis aus dem Produkt 60*0.01 = 0.6 hat, ersetzt werden. Zum besseren Verständnis wurde es hier beim Ki*Ta belassen. Um einen Windup-Effekt zu verhindern, wird die Summenbildung esum auf +-400 begrenzt. Der Wert wurde so gewählt, dass noch eine volle Aussteuerung durch den I-Anteil möglich ist. Zum Schluss wird die Stellgröße y auf die mögliche Aussteuerung des Stellglieds (0...255) begrenzt.

'''Programmbeispiel digitaler PI-Regler:'''

<pre>
e = w - x; //Vergleich
esum = esum + e; //Integration I-Anteil
if (esum < -400) {esum = -400;} //Begrenzung I-Anteil
if (esum > 400) {esum = 400;}
y = Kp*e + Ki*Ta*esum; //Reglergleichung
if (y < 0) {y = 0;} //Begrenzung Stellgröße
if (y > 255) {y = 255;}
PWM = y; //Übergabe Stellgröße
</pre>

== Beispiel: Lageregelung ==
Unter einer Lageregelung versteht man die Positionierung von Objekten. Als Beispiel soll hier ein kleiner Bot mit Radencoder eine bestimmte Weglänge fahren. Gegenüber der Drehzahl- oder Geschwindigkeitsregelung ist bei der Lageregelung noch ein zusätzlicher Integrator in der Strecke vorhanden. Die gesamte Strecke ist damit ein I-Glied mit Verzögerung. Laut Tabelle im Abschnitt „Dimensionierung des Reglers“ ist dafür ein PD-Regler gut geeignet. Der PD-Regler wird digital ausgeführt, zur Simulation und Parametrierung bietet sich deshalb Scicos an.

Da bei einer Lageregelung der Geschwindigkeitsbereich von Null aus geht, also über den nichtlinearen Bereich geht, sollte auch in der Simulation die Nichtlinearität berücksichtigt sein. Für das Beispiel wird deshalb das Modell eines Antriebs mit Haft- und Gleitreibung genommen, wie es unter "Modellierung eines Antriebs – detailliertes Modell" bereits vorgestellt wurde. Im Scicos-Modell ist der Antrieb der Übersichtlichkeit wegen als Superblock ausgeführt. Das Blockschaltbild des Antriebs im Detail ist [http://www.roboternetz.de/wissen/images/7/73/Antrieb_Modell.png hier] zu sehen. Die Daten sind:

R = 16 Ohm; L = 6 mH; m = 0.31 kg; Kf = 6.6 N/A

Als Sensor kommt ein Inkrementalgeber zum Einsatz, allerdings muss der richtungssensibel sein, sonst ist keine Lageregelung möglich. Der Sensor wird in Scicos mit der Rundungsformel (round(u1*500)) simuliert. Das ergibt bei einer Auflösung von 2mm ganzzahlige Schritte, wie es auch die Hardware (Inkrementalgeber mit nachfolgendem Zähler) in Wirklichkeit macht.

[[Bild:Lageregelung.png]]

Nach dem Regler folgt ein Block mit der Verstärkung (5/255), der den PWM-Wert auf die Ansteuerspannung für den Motor umsetzt. Der Bruch 5/255 entspricht der Ansteuerspannung von 5V bei PWM=255. Der PD-Regler kann damit in Scicos exakt so simuliert werden, wie er schlussendlich auch als C-Code umgesetzt wird. Dazu wird der Code des PD-Reglers als Funktion in den Scifunc-Block eingegeben. Der Code ist etwas unterschiedlich zum C-Code des realen Bots, da die Syntax in Scicos doch geringfügig anders ist und die Eingangs- und Ausgangsvariablen nur bestimmte Bezeichnungen haben dürfen. Im nachfolgenden Codefenster sind beide Varianten im Vergleich zu sehen.
{|
| '''Scifunc-Code:'''
<pre>

y1=Kp*u1+Kd/Ta*(u1-z);
z=u1;
if y1>255 then
y1=255;
end
if y1<-255 then
y1=-255;
end
</pre>
| '''C-Code für µC:'''
<pre>
e = w - x;
y = Kp*e + Kd/Ta*(e-ealt);
ealt = e;
if (y > 255) {
y = 255;
}
if (y < -255) {
y = -255;
}
</pre>
| '''Kommentar:'''
<pre>
Vergleich
PD-Reglergleichung
alten Wert speichern

pos. Begrenzung

neg. Begrenzung

</pre>
|}

In der praktischen Umsetzung des C-Codes wird man den Bruch Kd/Ta durch eine Ersatzvariable oder Konstante ersetzen. Dabei ergibt sich (wie in diesem Beispiel 2/0.01 = 200) meistens ein ganzzahliger Wert, was sich positiv auf die Rechenzeit auswirkt.

Für die Abtastzeit Ta wurde 10ms gewählt. Das ist einerseits nicht zu schnell für einen µC und andererseits nicht zu lang, um die Regelung unnötig zu verlangsamen. Die Parametrierung von Kp und Kd erfolgte empirisch durch Probieren in der Simulation. Begonnen wurde mit einem reinen P-Regler und kleinem P-Anteil (Kp=1, Kd=0). In groben Schritten wurde Kp solange erhöht, bis sich deutlich Überschwinger zeigten. Dann wurde ein D-Anteil hinzugefügt und Kd so variiert, dass der Überschwinger verschwindet. Mit ein bisschen Feintuning ergaben sich so die Werte Kp=61 und Kd=2. Das Simulationsergebnis für Ansteuerspannung, Geschwindigkeit und Weg sieht damit folgendermaßen aus:

[[Bild:Lage_antwort.png]]

==Autoren==
* [[Benutzer:Waste|Waste]]

==Siehe auch==
* [[SwitcherCAD-Tutorial]]

== External links ==
*[http://www.roboternetz.de/phpBB2/viewtopic.php?t=11818 Post: Line follower with PID controller]
*[http://www.scicos.org/ Scicos Homepage]
* [http://www.scicoslab.org/ ScicosLab Homepage]
* [http://www.scilab.org/ Scilab Homepage]
* [http://ltspice.linear.com/software/swcadiii.exe LTspice / SwitcherCAD III Download]
* [http://www.kahlert.com/web set_download.php demo version of WinFACT 7]
* [http://www.physi.uni-heidelberg.de/fp/anleitg/E01.pdf instructions for electronic placement, the last part is based PID controller]
* [http://www.simapp.com/ SimApp website] with trial
* [http://www.expertcontrol.com/ ExpertControl Homepage, Automatische Reglerauslegung mit ecICP] ecICP-Trial über Support-Seite verfügbar
* [http://www.me.th-mittelhessen.de/personen/professoren/orlowski/simulation-regelungstechnik/ TH-Mittelhessen Prof. Peter F. Orlowski, Simulationsprogramm SIMLER-PC]

[[Category: Microcontroller]]
[[Category: Software]]
[[Category: Elektronik]]

Datei:Digreg.gif

2014-09-13T07:46:43Z

SprinterSB: reimport von [http://www.roboternetz.de/wiki/uploads/Main/digreg.gif]

reimport von [http://www.roboternetz.de/wiki/uploads/Main/digreg.gif]