Mikrocontroller.net - Benutzerbeiträge [de]

Versorgung aus einer Zelle

2015-02-13T14:17:50Z

Jackfritt: /* ICs */

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

== Erste Ideen ==

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

Die erste Idee ist, einen 9V-Block mit dahintergehängtem Linearregler à la 7805 zu verwenden. Dieser Ansatz ist einfach, er hat aber einen sehr schlechten Wirkungsgrad. Bei Abwärtsregelung auf 5V verbrät der Regler immerhin 45% => 55% Wirkungsgrad, bei 3,3V verbrät er 64% => nur noch 36% Wirkungsgrad), und auch der Platzbedarf auf der Leiterplatte ist erheblich. Angesichts dessen kann man schon fast vernachlässigen, dass der klassische 7805 ca. 5mA für sich selber braucht. Das ist meist mehr als ein Mikrocontroller! Diesbezüglich besser sind Low Power Linearregler wie z. B. der [http://www.national.com/mpf/LP/LP2950.html LP2950] (ca. 75μA Eigenverbrauch) oder gar ein [http://focus.ti.com/docs/prod/folders/print/tps71501.html TPS715xx] von [http://www.ti.com Texas Instuments], der mit unglaublich geringen 3,2 μA auskommt.
Statt des Linearreglers könnte man natürlich auch einen Step-Down-Schaltregler benutzen, dann hätte man zumindest einen besseren Wirkungsgrad von 80-90%. Last but not least ist die Energiedichte von 9V-Blocks im Verhältnis zu Mignonzellen eher gering.

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

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

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

Als weitere Möglichkeit wären vier Mignonzellen (leer 3,6V, voll 6V) mit nachgeschaltetem LowDrop-Linearregler zu verwenden. Wenn die Schaltung mit 3,3V auskommt, dann ist man mit dieser Möglichkeit bestens bedient. Die Batterien können bis zum Ende ausgenutzt werden und der Wirkungsgrad liegt bei ca. 75%.
Allerdings bleibt ein Nachteil, wenn man 5V braucht: Die Batterien werden nicht einmal annähernd geleert, weil sie bereits bei 1,25V pro Zelle zusammen gerade noch 5V ergeben, der Regler aber auch gern noch seinen Teil abhaben will (Dropout Voltage). Zu bedenken sind hierbei die Entladekennlinien von Batterien oder noch schlimmer, die von Akkus.

{| class="wikitable"
|+ '''Sparsame Spannungsregler'''
!Bezeichnung || Ausgangsspannung [V] || Stromverbrauch [µA] || DropOut @ 50/150/250mA [mV] || Lieferant
|-
|LP2950
| align="center" |3 / 3,3 / 5
| align="center" |75
| align="center" |300 / - / -
| [[Elektronikversender#Reichelt | Rei]]
|-
|LF33
| align="center" |3,3
| align="center" |500
| align="center" |100 / 175 / 250
| [[Elektronikversender#Reichelt | Rei]], [[Elektronikversender#IT-WNS | I]]
|-
|LF50
| align="center" |5
| align="center" |500
| align="center" |100 / 175 / 250
| [[Elektronikversender#Reichelt | Rei]]
|-
|TPS715xx
| align="center" |1,2..5
| align="center" |3.2
| align="center" |415 / - / -
| [[Elektronikversender#RS Components | RS]]

|-
| [http://www.robotikhardware.de/download/tps78233.pdf TPS78233]
| align="center" |3.3
| align="center" |0.42
| align="center" |130
| [[Elektronikversender#Robotikhardware | RH]]

|-
|MCP1702
| align="center" |1,2..5
| align="center" |2
| align="center" |15 / 40 / 650
| [[Elektronikversender#Reichelt | Rei]],[[Elektronikversender#IT-WNS | I]]
|-
|MCP1824
| align="center" |0,8..5
| align="center" |120
| align="center" |30 / 90 / 150
| [[Elektronikversender#RS Components | RS]]
|-
|ZLDO330
| align="center" |3,3
| align="center" |1000
| align="center" |20 / 50 / 85
| [[Elektronikversender#Reichelt | Rei]]
|}

=== Drei Mignonzellen ohne Spannungsregler ===

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

=== Lithiumzelle ===

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

Um ein Gerät nur im Notfall mit einer Lithiumzelle zu betreiben (Pufferbetrieb, Netzausfallsicherung), braucht man eine unterbrechungsfreie Umschaltung zwischen Netzteilbetrieb und Batteriebetrieb. Kritisch ist das vor allem für die Lithiumzelle (damit ist kein Lithiumakku gemeint!), da diese nicht aufgeladen werden darf. Sie wird dabei mit heftiger Reaktion zerstört! Eine einfache Schaltung ist die Nutzung von zwei Schottkydioden zur Entkopplung von Batterie und Netzteil, wie es im Artikel ''Speicher'' über [[Speicher#EEPROM_Schreibzugriffe_minimieren | EEPROM]] gezeigt wird.

Der Nachteil dieser Lösung ist der relativ hohe Spannungsabfall von 300..400mV über den Dioden. Besser ist der Einsatz eines P-Kanal MOSFETs zum Schalten der Batteriespannung. Dadurch kann der Spannungsabfall auf wenige Millivolt gesenkt werden. Die Schaltung dazu ist im diesem [http://www.mikrocontroller.net/topic/72275#591483 Beitrag] zu finden.

== Bessere Lösungsansätze ==

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

=== Step-Down-Schaltregler (Abwärtsregler, Tiefsetzsteller) ===

Falls die Batteriespannung auch am Ende der Entladung höher als die Versorgungsspannung ist, bieten sich Step-down Regler an.
* TPS62056 : Uin 2,7 .. 10 V, Uout=0,7 .. 6 V, 12 µA Eigenverbrauch, SMD-Gehäuse MSOP10
* TPS62202 : Uin 2,5 .. 6 V, Uout 1,8V, 12 µA Eigenverbrauch, SMD-Gehäuse SOT23-5
* OKI-78SR-xx : Uin 7 .. 36 V, Uout 3.3V/5V, Module mit Standard 78xx Anschluss.

=== Step-Up-Schaltregler (Aufwärtsregler, Hochsetzsteller) ===

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

==== ICs ====

'''Vorteile'''

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

'''Nachteile'''

* teuer, vor allem die, welche ab 1V arbeiten
* teilweise schwer zu bekommen
* benötigen mehr Aufwand für Filterung und Schirmung als Linearregler.

[[Kategorie:Bauteile]]
{| class="wikitable"
|+ '''Schaltregler-ICs'''
|-
! style="width: 10%"| IC !! style="width:*"| Bemerkung !! style="width:7em"| Lieferant
|-
| [http://www.tranzistoare.ro/datasheets/2300/57048_DS.pdf LT1073-5]
| 1V (1 Zelle) auf 5V, 40mA
|-
| [http://cds.linear.com/docs/en/datasheet/1111fd.pdf LT1111]
| 2V-12V Step-Up, bis 30V Step-Down, 72kHz Schaltfrequenz, Bezeichnung -5 und -12 mit fester Ausgangsspannung 5V bzw. 12V
| R
|-
| [http://www.ortodoxism.ro/datasheets/lineartechnology/lt1301.pdf LT1301]
| 2V (2 Zellen) auf 5V oder 12V, 250mA
| C
|-
| [http://www.ortodoxism.ro/datasheets/lineartechnology/lt1302.pdf LT1302] ||2V (2 Zellen) auf 5V oder 12V, 250mA
| C, R, RobHard<ref name="plat_mod">Platinen/ Module</ref>
|-
| [http://cds.linear.com/docs/en/datasheet/3401fb.pdf LTC3401] ||ziemlich geniales Teil, weil es mit hoher Schaltfrequenz arbeitet, dadurch kann eine kleine Spule verwendet und ein sehr hoher Wirkungsgrad erzielt werden. 0.5...5.5V Vin, 1,0V Startup-Voltage, 2,6...5,5V Vout, bis 1A
|-
| [http://cds.linear.com/docs/Datasheet/3429fa.pdf LTC3429]||0,5...4,4V Vin, 1,0V Startup-Voltage, 2,5...4,3V Vout, 100mA aus einer Zelle, 250mA aus zwei Zellen bei 3,3V Vout
|-
| [http://www.linear.com/pc/downloadDocument.do?navId=H0,C1,C1003,C1042,C1031,C1060,P13393,D9338 LTC3525-5] ||
|-
| [http://datasheets.maxim-ic.com/en/ds/MAX866-MAX867.pdf MAX866/MAX867] ||ziemlich geniales Teil, weil es mit hoher Schaltfrequenz arbeitet, ab 0.8V, bei 0.9V Start-Up-Voltage
|-
|-
| [http://www.maximintegrated.com/datasheet/index.mvp/id/1207] || wie MAX866/867 jedoch 85% Wirkungsgrad bei 100mA und 500kHz Schaltgeschwindigkeit
|-
| [http://datasheets.maxim-ic.com/en/ds/MAX1595.pdf MAX1595] || dito, benötigt lediglich 3 Kondensatoren als Außenbeschaltung
|-
| [http://datasheets.maxim-ic.com/en/ds/MAX1674-MAX1676.pdf MAX1674-1676] ||bis zu ein Ampere, bei einer Zelle ist aber bei 100mA Schluss, und das auch nur, wenn die Spannung beim "Hochfahren" höher war und die richtige Spule verwendet wird
|I (MAX1674)
|-
| [http://datasheets.maxim-ic.com/en/ds/MAX1759.pdf MAX1759] || noch ein Hochfrequenz-Teil
|-
| [http://datasheets.maxim-ic.com/en/ds/MAX1722-MAX1724.pdf MAX1722-1724] || bis 150 mA
|-
| [http://ww1.microchip.com/downloads/en/DeviceDoc/22234B.pdf MCP1640] ||ab 0.35V bei 0.65V startup, einfache Beschaltung, regelbare Ausgangsspannung, bis 350 mA, 19µA quiescent current, nur kleine Induktivität (4,7µH) nötig
| C, R
|-
| [http://www.prema.com/Application/whiteleddriver.html PR4401/PR4402]||22 und 44 mA, benötigen lediglich 1 externes Bauteil, die Spule. Einfach zu handhaben
| R, I
|-
| [http://www.prema.com/Application/pr4404_e.html PR4404]||150 mA von einer, und 300 mA von zwei Zellen. Preiswert
| R, I
|-
| [http://www.sipex.com/Files/DataSheets/sp6648.pdf SP6648]
||
|-
| [http://focus.ti.com/lit/ds/symlink/tps61200.pdf TPS61200/201/202] ||1,8..5,5V out, Quellspannung bis herunter auf 0,3V, ?>90%, 0,5mm Pinabstand, 3,15*3,15mm, 10-Pin QFN
|
|-
| [http://focus.ti.com/lit/ds/symlink/tps61220.pdf TPS61220] ||1,8..5,5V out, Quellspannung bis herunter auf 0,7V, >90%, 6-pin SC-70(DCK),2mm*2mm
|R
|-
| [http://focus.ti.com/docs/prod/folders/print/tps61006.html TPS6100x]||Single- and Dual-Cell Boost Converster, min 0,8V Vin, 1,5V...3,3V Vout, min. 100mA aus einer Zelle, min.250mA auf zwei Zellen, Gehäuse 10MSOP
|-
| [http://focus.ti.com/docs/prod/folders/print/tps61016.html TPS6101x]||1-Cell and 2-Cell Boost Converters, TPS61006 and TPS61016 are functionally equivalent. TPS61006 is non-synchronous. TPS61016 is synchronous and does not require an external Schottky diode.
|-
| TPS6030x, TPS6031x, [http://www.ortodoxism.ro/datasheets/lineartechnology/15023f.pdf LTC1502-3.3] ||(typ. 3,x V bei 15-20 mA)
|-
| [http://www.ortodoxism.ro/datasheets2/7/0y1y62f9lzj79rs7uuf28jq4xtwy.pdf LM2621]
||
|-
| [[MC34063]]||(ungeeignet, läuft erst ab 3V)
| R, I
|-
| [http://atmel.com/dyn/products/product_card.asp?part_id=4523 ATtiny43U]||AVR-Microcontroller, der einen Boost-Converter eingebaut hat und damit eine Batterie bis auf 0.7V aussaugen kann.
|-
| [http://www.onsemi.com/pub_link/Collateral/NCP1400A-D.PDF NCP1400A]||Startup 0.8V / |
| W<ref name="plat_mod" />
|-
| [http://www.onsemi.com/pub_link/Collateral/NCP1402-D.PDF NCP1402]||Startup 0.8V, 200mA, Preis < 1 Euro
| W<ref name="plat_mod" />
|-
| [http://cds.linear.com/docs/en/datasheet/338813f.pdf LTC3388] ||Nanopower Step Down Regulator, weniger als 1µA Leerlaufstrom, 50mA Ausgangsstrom
|}
Lieferanten '''C'''onrad, '''R'''eichelt, '''W'''atterott, '''Rob'''otik'''Hard'''ware.de, '''I'''T-WNS <references />

'''Dioden'''

*Prakisch kann nahezu jede Schottkydiode mit ausreichend Strombelastbarkeit genutzt werden, siehe [[Dioden-Übersicht]].

==== Diskrete Schaltungen ====

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

'''Nachteile:'''

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

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

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

=== Ladungspumpen ===

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

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

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

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

== Forumsbeiträge zum Thema ==

*[http://www.mikrocontroller.net/topic/45101 3v3 Volt aus einer 1v2 Volt Zelle]
*[http://www.mikrocontroller.net/topic/18789 Stromversorgung aus einer Zelle]
*[http://www.mikrocontroller.net/topic/73532 Step-Up Mignon zu 5V]
*[http://www.mikrocontroller.net/topic/141635 Stepup/-down: Konstante 5V aus 4xMonozelle]
*[http://www.mikrocontroller.net/topic/189526 Ersatz 9V-Block durch Mikrozelle]

== Externe Links ==

* [http://www.powerdesignersusa.com/InfoWeb/index.shtml Powerdesigners InfoWeb] - Free tools, resources and education for power electronics designers and students (engl.)
* http://www.linear.com/products/Step-Up_(Boost)_Regulators
* http://www.ti.com/power
* http://www.maxim-ic.com/products/power/
* [http://focus.ti.com/lit/an/slaa105/slaa105.pdf TI Application Report SLAA 105] Simple 1.5-V Boost Converter for MSP430
* 2-6V DC nach 5V DC Konverter auf der Basis des '''LT1302''' als [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?cPath=83&products_id=195 Fertigmodul] bzw. [http://www.shop.robotikhardware.de/shop/catalog/product_info.php?products_id=194 Platine] (Shop robotikhardware.de)
* [http://www.heise.de/mobil/Langzeittest-von-NiMH-Akkus-mit-reduzierter-Selbstentladung--/artikel/143297 Langzeittest von NiMH-Akkus mit reduzierter Selbstentladung] auf heise.de
* [http://spritesmods.com/?art=ucboost Run an uC from an AA-battery] auf spritesmods.com
* [http://www.powerstream.com/BatteryFAQ.html PowerStream Battery Chemistry FAQ]
* [http://ww1.microchip.com/downloads/en/AppNotes/01416a.pdf AN1416: Low-Power Design Guide] von Microchip (PDF)

[[Kategorie:Bauteile]]
[[Kategorie:Spannungsversorgung und Energiequellen]]

C

2014-12-10T09:09:17Z

Jackfritt: Diverse tote links entfernt. Link auf Verzeichnisse mit nichtssagenden PDF Dateien entfernt.

Hardwarenahe Programmiersprache, ursprünglich als eine Art maschinenunabhängiger Makroassembler gedacht. C ist neben Assembler die bei Mikrocontrollern am häufigsten verwendete Programmiersprache.

== C-Tutorials/Einführungen ==

* [http://roboternetz.de/download/c_tutorial.zip Download umfangreiches C-Tutorial mit Beispielen für RN-Control und andere AVR-Boards im ZIP-Archiv] von A.Seeger
* [http://www.c-howto.de Einführung in C] von E. Fischer
* [http://www.schellong.de/c.htm C-Tutorial] von H. Schellong
* [http://www.c-plusplus.de/c.htm verschiedene Tutorials] zum Download
* [http://www.tutorials.at/ tutorials.at] auch für Pascal, Basic
* [http://suparum.rz.uni-mannheim.de/manuals/c/cde.htm C-Tutorial von C. Wirth]
* [http://www.strath.ac.uk/IT/Docs/Ccourse/ C programming] by S. Holmes
* [http://www.haw-hamburg.de/rzbt/dankert/c_tutor.html/ C und C++ für UNIX, DOS und MS-Windows] von J. Dankert, zum download
* [http://openbook.galileocomputing.de/c_von_a_bis_z/ online Version des Buchs "C von A bis Z"] von J. Wolf
* [http://home.fhtw-berlin.de/~junghans/cref/ C-Referenz] von M. Leslie/G.Junghanns
* [http://info.baeumle.com/ansic.html "Einiges zu Ansi-C"] von B. Baeumle-Courth
* [http://www2.informatik.uni-wuerzburg.de/dclc-faq/ FAQ der Newsgroup de.comp.lang.c]
* [http://www.coding-guidelines.com/cbook/cbook1_0a.pdf Derek M. Jones: The New C Standard] e-Buch, engl., >1600 Seiten, mehr als "nur" Einführung/Tutorial

== Weitere Links ==
* [http://www.crasseux.com/books/ctutorial/Precedence-of-operators.html#Precedence%20of%20operators Liste aller Operatoren und ihrer Prioritäten]

[[Category:Programmiersprachen]]
[[Category:C| ]]

AVR - Die genaue Sekunde / RTC

2014-02-12T19:19:46Z

Jackfritt: /* Durchlaufender Hardwarezähler und fortlaufende Addition */

== Einleitung ==
Oftmals sieht man Projekte, bei denen ein externer RTC-Baustein (engl. '''R'''eal '''T'''ime '''C'''lock, Echtzeituhr; z. B. PCF8583 mit [[I2C]]-Anschluss [http://www-us.semiconductors.philips.com/acrobat/datasheets/PCF8583_5.pdf Datenblatt (PDF)]) angeschlossen ist, ohne dessen Vorteil wirklich zu nutzen.

Die wichtigsten Vorteile einer externen RTC sind
# Die Zeitzählung läuft während eines Ausfalls der Hauptstromversorgung über eine kleine Stützbatterie bei geringem Strombedarf weiter.
# Es gibt hochgenaue RTCs, die man im Gegensatz zu Selbstbaulösungen nicht abgleichen muss.
# Der Strombedarf eines externen RTC ist in der Regel etwas niedriger als die RTC Funktion eines Prozessors. Als Vergleich diene ein DS1302(300nA@2V) zu einem Mega32(5uA@2.7V) als nicht ganz neuer Vertreter, bzw. ein Mega324P(500nA@1.8V) als moderner Vertreter. Dieser Vorteil kommt bei Datenschreibern (engl. data logger) zum Tragen, welche die meiste Zeit inaktiv im [[Sleep Mode]] sind.

In allen anderen Fällen ist die zusätzliche Hardware nicht unbedingt nötig und man kann eine präzise Zeitbasis bequem mit dem Hauptquarz des Mikrokontrollers programmieren. Daraus ergeben sich sogar noch zusätzliche Vorteile, wie eine geringere Temperaturabhängigkeit und höhere Güte, die Quarze im MHz-Bereich gegenüber Quarzen im kHz-Bereich besitzen. Ich möchte hiermit die Angst vor dem bisschen Mathematik nehmen, welche zur Berechnung der Teilerfaktoren benötigt wird.

==Lösung==

Speziell für den AVR kommen Quarze im Bereich 1MHz bis 16MHz zum Einsatz, d.h. in einer Sekunde werden 1.000.000 bis 16.000.000 Zyklen durchlaufen (Zyklen pro Sekunde = Frequenz). Möchte man eine Sekunde messen, kann man somit die entsprechende Anzahl Zyklen von Null an hochzählen oder von dem entsprechenden Wert bis auf 0 runterzählen. Für das Zählen bietet sich im µC der Compare-Modus eines Timers an.

Die obigen Zahlen lassen sich jedoch nicht in einer 16 Bit Variablen ausdrücken da sie zu gross sind und somit ist ein direktes Setzen des Compare-Wertes des Timers T1 im AVR nicht möglich. Deshalb unterteilt man die Quarzfrequenz in zwei Faktoren; der erste (Softwareteiler) bestimmt die Periode des Timers T1 und der zweite den Reloadwert eines Registers, welches im Timerinterrupt runtergezählt wird.

==Beispiel==

Im Beispiel AVR wird ein 11,0592-MHz-Quarz verwendet, was einem üblichen [[Baudratenquarz]] entspricht, d.h. damit können die UART-Standardbaudraten erzeugt werden.

Der Softwareteiler wird mit 256 gewählt, d.h. 256 Timerinterrupts pro Sekunde, und kann somit mit nur einem einzigen Byte realisiert werden. Für größere Werte muß der Softwareteiler als int (2 Byte) deklariert werden. Bei kleineren Werten als 256 muss man beachten, dass der zweite Faktor immer noch in 2 Byte passt, um als Comparewert für den 16-Bit-Timer 1 verwendet werden zu können.

Die Timerroutine wird in einer Sekunde Softwareteiler-Mal aufgerufen. Mit diesen 256 Hz ergibt sich eine Timerinterruptzeit von ca. 4ms, die auch sehr gut zum Entprellen von Tasten benutzt werden kann. Eine Entprellroutine kann also bequem in den Timerinterrupt mit eingefügt werden. Beachten muss man nur noch, dass das Nullsetzen des Timers erst einen Zyklus nach dem Comparematch erfolgt.

==Berechnung==

Die Berechnung des Comparewertes ist sehr einfach:

<syntaxhighlight lang="c">
Comparewert OCR1A = 11059200 / 256 - 1 = 43199, Rest 0.
</syntaxhighlight>

Da haben wir ja noch mal Glück gehabt, es gibt keinen Rest bei der Division und die Sekunde ist exakt
256 * 43200 = 11059200 Zyklen lang. 
Theoretisch. 
Denn selbst wenn auf dem Quarz eine Frequenz von 11,0592 Mhz aufgedruckt ist, so schwingt er doch auf
einer etwas anderen Frequenz. Der Grund dafür sind Fertigungstoleranzen und natürlich die Tatsache,
dass die Frequenz eines Quarzes auch von der Temperatur abhängig ist. Es gilt also zunächst einmal
herauszufinden, auf welcher Frequenz der Quarz wirklich schwingt.

Dazu wird eine Uhr programmiert und mit dem theoretischen Wert laufen gelassen. Nun habe ich die Uhr
einen Tag laufen lassen und festgestellt, dass sie 1,5 s nach geht (Dazu kann man beispielsweise die Tagesschau nutzen, welche jeden Tag um 20:00 (+einer konstanten Zeitverschiebung durch das Übertragungsmedium SAT,DVB-T, ...) beginnt und sogar eine Uhr dabei einblendet). D.h. die Quarzfrequenz beträgt in
Wirklichkeit:
<syntaxhighlight lang="c">
11059200 * (1 - 1,5 / 24 / 60 / 60) = 11059008 Hz.
</syntaxhighlight>
Ausführliche Rechnung:
<syntaxhighlight lang="c">
(Zyklen in 24h - Zyklen Verspätung) / Sekunden pro 24h = korrekte Frequenz
((24 * 60 * 60 * 256 * 43200) - (1,5 * 256 * 43200)) / (24 * 60 * 60) = 11059008 Hz.
</syntaxhighlight>

Also die ganze Rechnung nochmal:
<syntaxhighlight lang="c">
OCR1A = 11059008 / 256 - 1 = 43198, Rest 64.
</syntaxhighlight>
Nun haben wir einen Rest und es würden uns jede Sekunde 64 Zyklen fehlen. Das geht natürlich nicht.

Deshalb wird jedesmal, wenn der Softwareteiler Null ist und die Sekunde weitergezählt wird, ein
anderer Comparewert geladen. Dieser ist dann um den Rest größer. Und beim nächsten Timerinterrupt
wird dann wieder der Comparewert geladen, der das Ergebnis der Division war.

Es ergeben sich somit:
<syntaxhighlight lang="c">
255 * (43198 + 1) + 1 * (43198 + 64 + 1) = 11059008 Zyklen
</syntaxhighlight>
Exakt so, wie wir es wollten.

==Das Programm==

Nachfolgend nun das C-Programm. Da wir ja alle nicht gerne rechnen, lassen wir das einfach den C-Compiler erledigen. D.h. wir brauchen nur noch per Definition für XTAL den entsprechenden Wert eintragen und der Compiler rechnet alle nötigen Konstanten ganz alleine aus.

So ein Compiler ist auch ziemlich faul, der merkt sofort, wenn die Operanden für eine Berechnung alles Konstanten sind. Und ehe er sich damit abquält, extra Code für diese Berechnungen zu erzeugen, rechnet er es lieber selber aus und fügt das Ergebnis direkt in den Code ein.

Der Assembler kann auch 32-Bit Konstanten-Berechnungen ausführen. Allerdings muß man dann die entsprechenden Präprozessoroperationen benutzen. Man könnte auch eine Divisionsroutine aufrufen, aber dann würde ja echter Code erzeugt.

===Beispiel in C===

Wichtig: Ab Ver.1.4.0 haben sich Namen/Funktionen geändert: 

"There are currently two different styles present for naming the vectors. One form uses names starting with SIG_, followed by a relatively verbose but arbitrarily chosen name describing the interrupt vector. This has been the only available style in avr-libc up to version 1.2.x.

Starting with avr-libc version 1.4.0, a second style of interrupt vector names has been added, where a short phrase for the vector description is followed by _vect. The short phrase matches the vector name as described in the datasheet of the respective device (and in Atmel's XML files), with spaces replaced by an underscore and other non-alphanumeric characters dropped. Using the suffix _vect is intented to improve portability to other C compilers available for the AVR that use a similar naming convention...."

Quelle: http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html
<syntaxhighlight lang="c">
/************************************************************************/
/* */
/* Precise 1 Second Timebase */
/* */
/* Author: Peter Dannegger */
/* danni@specs.de */
/* */
/************************************************************************/
// Target: Mega8, 2313

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

#ifndef OCR1A
#define OCR1A OCR1 // 2313 support
#endif

#ifndef WGM12
#define WGM12 CTC1 // 2313 support
#endif

#ifndef PINC
#define KEY_INPUT PIND // 2313
#else
#define KEY_INPUT PINC // Mega8
#endif
#define LED_DIR DDRB

//#define XTAL 11059201L // nominal value
#define XTAL 11059008L // after measuring deviation: 1.5s/d

#define DEBOUNCE 256L // debounce clock (256Hz = 4msec)

#define uchar unsigned char
#define uint unsigned int

uchar prescaler;
uchar volatile second; // count seconds

SIGNAL (SIG_OUTPUT_COMPARE1A)
{
/************************************************************************/
/* Insert Key Debouncing Here */
/************************************************************************/

#if XTAL % DEBOUNCE // bei rest
OCR1A = XTAL / DEBOUNCE - 1; // compare DEBOUNCE - 1 times
#endif
if( --prescaler == 0 ){
prescaler = (uchar)DEBOUNCE;
second++; // exact one second over
#if XTAL % DEBOUNCE // handle remainder
OCR1A = XTAL / DEBOUNCE + XTAL % DEBOUNCE - 1; // compare once per second
#endif
}
}

int main( void )
{
LED_DIR = 0xFF;
while( KEY_INPUT & 1 ); // start with key 0 pressed

TCCR1B = (1<<WGM12) | (1<<CS10); // divide by 1
// clear on compare
OCR1A = XTAL / DEBOUNCE - 1; // Output Compare Register
TCNT1 = 0; // Timmer startet mit 0
second = 0;
prescaler = (uchar)DEBOUNCE; //software teiler

TIMSK = 1<<OCIE1A; // beim Vergleichswertes Compare Match
// Interrupt (SIG_OUTPUT_COMPARE1A)
sei();

for(;;){
if( second == 60 )
second = 0;
PORTB = second; // display second (binary)
}
}
</syntaxhighlight>

===Beispiel in Assembler===

<syntaxhighlight lang="avrasm">
;************************************************************************/
;* */
;* Precise 1 Second Timebase */
;* */
;* Author: Peter Dannegger */
;* danni@specs.de */
;* */
;************************************************************************/
.nolist
.include "m8def.inc"

.equ xtal = 11059008
.equ debounce = 256
.equ remainder = xtal - xtal / debounce * debounce

.def isreg = r15
.def wr0 = r16
.def iwr0 = r17
.def prescaler = r18
.def second = r19

.list
rjmp init
.org OC1Aaddr
rjmp OC1Aint
;-------------------------------------------------------------------------
OC1Aint:
in isreg, sreg
;************************************************************************/
;* Insert Key Debouncing Here */
;************************************************************************/

ldi iwr0, high( xtal / debounce - 1 )
out ocr1ah, iwr0
ldi iwr0, low( xtal / debounce - 1 )
out ocr1al, iwr0

dec prescaler
brne _oci1

ldi prescaler, debounce
inc second

ldi iwr0, high( xtal / debounce + remainder - 1 )
out ocr1ah, iwr0
ldi iwr0, low( xtal / debounce + remainder - 1 )
out ocr1al, iwr0
_oci1:
out sreg, isreg
reti
;-------------------------------------------------------------------------
init:
ldi wr0, 0xFF
out ddrb, wr0
sbic pinc, 0
rjmp init

ldi wr0, high( ramend )
out sph, wr0
ldi wr0, low( ramend )
out spl, wr0

ldi wr0, 1<<WGM12^1<<CS10
out TCCR1B, wr0

ldi wr0, high( xtal / debounce - 1 )
out ocr1ah, wr0
ldi wr0, low( xtal / debounce - 1 )
out ocr1al, wr0
out tcnt1l, wr0
ldi prescaler, debounce

ldi wr0, 1<<OCIE1A
out TIMSK, wr0
sei
main:
ldi second, 0
_mai1:
cpi second, 60
breq main
out PORTB, second
rjmp _mai1
;------------------------------------
</syntaxhighlight>

===Verbesserte Version mit durchlaufendem Hardwarezähler===

Hier sind trotzdem kleine Verbesserungsvorschläge.

Wird im Timer die Option "Clear On Compare Match" verwendet, so verliert man den Overflow Interrupt. Oder möchte man nebenher noch eine Zeit mit dem Capture Interrupt messen, so benötigt man einen durchlaufenden Timer. Um dies zu erreichen, wird OCR1A nicht fest eingestellt, sondern bei jedem Aufruf um den gleichen Wert erhöht.

In Peters Code wurde der Rest auf einmal abgearbeitet. Damit erspart man sich bei jedem Interrupt einen Vergleich und die Verarbeitungszeit verkürzt sich in seinem Code. Der Unterschied zwischen kurzem und langem Interrupt ist hier der Rest. Bei den geänderten Codeschnipseln wird der Rest gleichmäßiger abgearbeitet. Der Unterschied zwischen kurzem und langem Interrupt beträgt 1 Takt.

ungetesteter Code für den durchlaufenden Timer:

<syntaxhighlight lang="c">
SIGNAL (SIG_OUTPUT_COMPARE1A) {
/************************************************************************/
/* Insert Key Debouncing Here */
/************************************************************************/

if( --prescaler == 0 ){
prescaler = (uchar) DEBOUNCE;
second++; // exact one second over
}
#if XTAL % DEBOUNCE
if (prescaler <= XTAL % DEBOUNCE)
OCR1A += XTAL / DEBOUNCE +1; /* um 1 Takt längere Periode um den Rest abzutragen */
else
#endif
OCR1A += XTAL / DEBOUNCE; /* kurze Periode */
}
</syntaxhighlight>

===Durchlaufender Hardwarezähler und fortlaufende Addition===

Gänzlich ohne Hin- und Hertogglen eines Bits kommt man aus, wenn irgendein Timer mit einer Überlauf-Interruptfrequenz > 1Hz arbeitet. Dann kann die ISR eine 32-bit-Konstante auf einen 32-bit-Akkumulator addieren; bei Überlauf ist eine Sekunde vergangen. Zugegeben, es gibt "lange" und "kurze" Sekunden, aber der Fehler summiert sich nicht, und der Code ist sehr einfach.

Hier ein Beispiel:

Es gibt ein Programm gettick(), das einen Wert holt. Dieser Wert wird von Zeit zu Zeit von der Hardware (Beispiel AVR: der Timer) oder dem Betriebssystem ermittelt. (Beispiel Linux: gettick ruft getmsec, getmsec ruft gettimeofday)

Dieser aufgerufene Wert sollte pro Sekunde um TICKPERSEC erhöht werden, was aber mit einer gewissen Ungenauigkeit geschieht.

Die Laufzeitkorrektur wird dadurch ausgeführt, dass der von gettick() zurückgegebene Wert mit einem Faktor TFAK multipliziert wird. Der Faktor sollte so gewählt werden, dass:

* Das Ergebnis actual_value immer in 32 Bit hineinpasst.
* Die Multiplikation durch Schiebeopertionen ersetzt werden kann, weil der Faktor eine 2-er-Potenz ist. (Das erledigt avr-gcc)

Immer wenn tsdaytim_calibrated() erkennt, dass eine Sekunde vergangen, wird last_value um die Zahl onesecond erhöht.

Der Zahlenwert onsecond wird mit TICKPERSEC*TFAK initalisiert und kann angezeigt oder neu eingegeben werden (Die Bedienung der seriellen Schnittstelle hierfür ist in diesem Beispiel nicht enthalten).

Wenn festgestellt wird, dass die Uhr pro Zeit (P) um (E) zu schnell geht, dann kann der Wert onsecond korrigiert werden.

c = d * (P+E)/P
Beispiel Pro 7 Tage 120 Sekunden zu viel:

7 Tage = 7*86400= 604800 sekunden
c = 992000000 * (604800+120)/604800=991803175
Dann wird die Uhr genauer gehen.

<syntaxhighlight lang="c">
/****************************************************************/
/* File home/cc/qq/danclock.cpp */
/* Precise 1 Second Timebase */
/* */
/* Author: Peter Dannegger / Hjherbert */
/* danni@specs.de */
/* */
/****************************************************************/
// Target: atmega8, (2313?)

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

#ifndef OCR1A
#define OCR1A OCR1 // 2313 support
#endif

#ifndef WGM12
#define WGM12 CTC1 // 2313 support
#endif

#ifndef PINC
#define KEY_INPUT PIND // 2313
#else
#define KEY_INPUT PINC // Mega8
#endif

//#define F_CPU 11059201L // nominal value

#define DIVISOR 256

#define TICKPERSEC (F_CPU/DIVISOR)

uint8_t volatile second; // count seconds

// TFAK ? TICKPERSEC must not exceed 2^32
#define TM (0x7FFFFFFFUL/2/TICKPERSEC) // max of TFAK

#define TFAK ( ( (TM>>1) | (TM>>2) | (TM>>3) | (TM>>4) | (TM>>5) | (TM>>6) | (TM>>7) \
| (TM>>8) | (TM>>9) | (TM>>10) | (TM>>11) | (TM>>12) | (TM>>13) | (TM>>14) | (TM>>15) \
| (TM>>16) | (TM>>17) | (TM>>18) | (TM>>19) | (TM>>20) | (TM>>21) | (TM>>22) | (TM>>23) \
| (TM>>24) | (TM>>25) | (TM>>26) | (TM>>27) | (TM>>28) | (TM>>29) | (TM>>30) | (TM>>31) \
) + 1 )
// TFAK is a power the biggest power of two which is less than TM

uint32_t onesecond = 1*TICKPERSEC*TFAK ; // correct this value if see the clock is late / too fast
uint32_t last_value ;
uint32_t ticks ;

SIGNAL (SIG_OUTPUT_COMPARE1A)
{
++ticks ;
}

uint32_t gettick( void )
{
uint32_t l ;
cli();
l = ticks ;
sei();
return l ;
}

void tsdaytim_calibrated(void)
// Keep the time-of-the-day actual
// Add a second, if a second if gone
{
uint32_t actual_value ; // gettick() multiplied by factor 2^n

actual_value = gettick() * TFAK ; // because TFAK is a power of two
// The compiler will create some shift commands

if ( actual_value - last_value > onesecond )
{ // once per second
if ( ++second >= 60 )
{
second = 0 ;
}
last_value += onesecond ; // One second more
}
}

int main( void )
{
DDRB = 0xFF;
while( KEY_INPUT & 1 ); // start with key 0 pressed

TCCR1B = 1<<WGM12^1<<CS10; // divide by 1
// clear on compare
OCR1A = DIVISOR ; // Output Compare Register
TCNT1 = 0; // Timer start value
second = 0;

TIMSK = 1<<OCIE1A; // beim Vergleichswertes Compare Match
// Interrupt (SIG_OUTPUT_COMPARE1A)
sei();
last_value = gettick() * TFAK ;
for(;;)
{
tsdaytim_calibrated();
PORTB = second; // display second (binary)
}
}

</syntaxhighlight>

== Echtzeituhr mit Uhrenquarz ==

=== RTC mit wenig Stromverbrauch ===

Das vorgestellte Verfahren ist leider nicht direkt anwendbar, wenn man eine RTC mit einem 32,768 KHz Uhrenquarz realisieren möchte. Dieser Weg ist dann notwendig, wenn der Controller [[Ultra low power | batteriebetrieben]] sehr lange laufen soll und durch Verwendung des [[Sleep Mode]] Strom gespart wird.

=== Begrenzung der Auflösung ===

Wo liegt das Problem? Das obige Verfahren nutzt recht hochfrequente Quarze mit 1 MHz und mehr. Wenn man die Frequenz eines Quarzes von 1 MHz = 1.000.000 Hz mit einer [[Auflösung und Genauigkeit| Auflösung]] von 1 Hz angibt, entspricht das einem maximalen Fehler von 1/1.000.000 oder 1ppm (engl. parts per million, millionstel Teil). Das ist sehr wenig. Eine RTC mit einem Fehler von 1ppm hat eine Gangabweichung von 86,4ms pro Tag, oder 2,5s pro Monat. Das ist ein sehr guter Wert. Wenn ich nun aber die Frequenz 32768 Hz mit 1 Hz Auflösung angebe, ist das schlimmstenfalls ein Fehler von 1/32768 = 30,5ppm, was einer Abweichung von 2,5s pro Tag und 75s pro Monat entspricht!

=== Uhrentakt genau messen und digital korrigieren ===

Wie kann man das Problem lösen? Die AVRs können im [[Sleep Mode]] den Uhrenquarz nur am Timer 2 betreiben, welcher ein 8 Bit Timer ist. D.H. ein Überlauf passiert alle 256 Takte, sprich 7,8125ms (=128 Hz). Man kann auch einen Prescaler verwenden, welcher das Problem aber nicht löst.

Wie bereits festgestellt, müssen wir die Frequenz des 32768Hz Uhrenquarzes genauer messen und darstellen. Wir wollen hier annehmen, dass wir die Frequenz auf 0,001Hz = 1mHz (Millihertz) auflösen, ein guter Frequenzzähler kann das problemlos und ist auch so [[Auflösung und Genauigkeit|'''genau''']]. Wir können beispielsweise feststellen, dass ein Quarz mit 32768,423Hz schwingt, das entspricht einem Fehler von

<math>F_r=(\frac{f_{ist}}{f_{soll}} -1 )\cdot 10^6=(\frac{32768,423}{32768} -1 )\cdot 10^6=12,9ppm</math>

Dabei ist zu beachten, daß diese Messung '''nicht''' direkt am Quarz erfolgen darf, auch nicht mit kapazitätsarmen 10:1 Tastköpfen! Denn so ein Quarz wird von kleinsten Kapazitäten im Bereich von weniger als ein pF messbar verstimmt. Darum muss man in so einem Fall den Uhrentakt auf ein anderes IO-Pin ausgeben und dort messen. Beim [[MSP430]] ist das einfach, man kann ACLK auf ein Pin direkt ausgeben. Der [[AVR]] kann das leider nicht. Hier muss man zu einem Trick greifen. Man benutzt die Output Compare Funktion, um mit Timer 2 einen 128 Hz Takt zu erzeugen. Dieser ist fest mit dem Uhrentakt verbunden und kann anstellte dessen gemessen werden, ohne den Quarz zu verstimmen. Die Messung ergibt in diesem Fall eine Frequenz von 128,00165 Hz.

OK, jetzt haben wir den Takt gemessen, wir wissen, daß pro Sekunde 128 Timerüberläufe passieren (Prescaler =1). Wir wissen, dass unser Quarz pro Sekunde um 0,423 Takte zu schnell ist. Wir können aber keine halben Takte mehr oder weniger zählen? Doch! Mit [[Festkommaarithmetik]]! Denn nach 1000s ist unser Quarz um 423 Takte zu weit gelaufen und muss um diese Anzahl zurückgestellt werden. Also könnte man im ersten Ansatz nach 1000 Sekunden den Timer 2 um diesen Betrag korrigieren. Das Problem dabei ist nur, dass der Zähler nur 8 Bit breit ist. Ein Addieren oder Subtrahieren von 423 würde mehrfache Überläufe verursachen, welche programmtechnisch nur schwer zu handhaben wären. Also muss eine etwas bessere Methode her.

=== Bresenham für RTCs ===

Wenn man sich die Idee der [[Festkommaarithmetik]] mal eine Weile durch den Kopf gehen lässt, kommt man vielleicht auf folgende Idee. Der Frequenzfehler beträgt in unserem Beispiel 0,423 Hz, also Takte pro Sekunde. Oder aber 423 Tausendstel Takte pro Sekunde. Nach drei Sekunden sind es schon 1,269 Takte oder 1269 Tausendstel Takte. Moment! '''Einen''' Takt können wir korrigieren, indem wir den Zähler um 1 Takt zurück setzen. Den Restfehler von 269 Tausendstel merken wir uns und akkumulieren weiter. Wenn dann wieder die 1000er Marke überschritten wird machen wir das Gleiche. Analog dazu natürlich auch bei negativem Vorzeichen, sprich wenn der Quarz zu langsam schwingt wird er um einen Takt vorgestellt. É Voilà! Dieses Verfahren ist sehr ähnlich zum [http://de.wikipedia.org/wiki/Bresenham-Algorithmus Bresenham-Algorithmus] zum Zeichnen von Linien auf Computermonitoren.

=== Beispielprogramm ===

Das folgende Beispiel stellt eine RTC mit sehr niedrigem Stromverbrauch zur Verfügung. Laut Datenblatt beträgt die Stromaufnahme nur ca. 6µA bei 3V Versorgungsspannung, besser als einige kommerzielle RTCs! Möglich macht das die Nutzung des Power Save [[Sleep Mode]]s. Die Frequenz kann auf <math>10^{-5}</math> Hz genau abgeglichen werden, was in diesem Fall bei einer Messfrequenz von 128Hz einer Auflösung von 0,078ppm entspricht. Das bedeutet eine Abweichung von 6,7ms pro Tag, 0,2s pro Monat oder 2,46s pro Jahr!

Die Abweichung des Quarzes wird in einer vorzeichenbehafteten 16 Bit Variable in der Einheit <math>10^{-3}</math> Hz gespeichert. D.h. es kann ein Frequenzfehler von +/- 32,768 Hz korrigiert werden, das sind 1000ppm! Normale Quarze haben Abweichungen von max. 100ppm, meist viel weniger. Jede Sekunde wird der Frequenzfehler neu berechnet und in den darauffolgenden 128 Interrupts ggf. mehrfach korrigiert. Wichtig ist dabei, dass die Korrektur wirklich ganz am Anfang der ISR steht, weil hier das Timing wirklich kritisch ist. Denn innerhalb eines Uhrenquarztaktes von ~30µs muss der Timer 2 neu beschrieben werden. Bei 1 MHz RC-Oszillatortakt sind das nur 30 Takte, wovon 6 zum Aufwachen und 4 zum Anspringen der ISR benötigt werden. Dazu kommen noch das Sichern einiger Register am Anfang der ISR, was man im C nicht direkt sieht. Sicherheitshalber sollte man auch einen höheren Takt einstellen, z. B. 2 MHz, dann ist das Timing wesentlich entspannter.

<syntaxhighlight lang="c">
/*
************************************************************************
*
* Stromsparende Echtzeituhr mit 32768Hz Uhrenquarz
*
* ATmega88 mit internem 2 MHz Oszillator + 32,768 kHz Quarz
*
* Fuses bleiben auf Standardeistellungen
* LOW Fuse Byte = 0x62
* HIGH Fuse Byte = 0xDF
* EXT Fuse Byte = 0xF9
*
* LED mit 1K Vorwiderstand an PB5
* Kalibriertaktausgang an PB3
************************************************************************
*/

#define F_CPU 2000000L // Systemtakt in Hz
#define F_CAL 12800000L // gemessener Kalibriertakt in 10^-5 Hz
// Endung L ist wichtig!

#define LED_TOGGLE PORTB ^= (1<<PB5);

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include <util/delay.h>

// EEPROM Daten

int16_t ee_rtc_cal EEMEM = (F_CAL-12800000)*256/100; // Kalibrierung für RTC, Frequenzfehler in 1/1000 Hz

// globale Variablen

// beidseitiger Zugriff durch ISR und Hauptprogramm

volatile uint32_t time; // 24h Zeitstempel, 1s Auflösung
volatile int16_t rtc_cal; // Kalibrierung des 32K Quarzes
volatile uint8_t flag_1s; // Flag für 1s Intervall

void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

int main (void) {

// Clock divider auf /4

CLKPR = 0x80; // update enable
CLKPR = 2; // Prescaler /4

// IO konfigurieren

DDRB = (1<<PB3) | (1<<PB5);
PORTB = ~((1<<PB3) | (1<<PB5)); // Pull ups
PORTC = 0xFF;
PORTD = 0xFF;

// Analogcomparator ausschalten

ACSR = 0x80;

// Timer2 konfigurieren

ASSR = (1<< AS2); // Timer2 asynchron takten
long_delay(1000); // Einschwingzeit des 32kHz Quarzes
TCCR2A = (1<<COM2A1) | (1<<WGM21) | (1<<WGM20); // Fast PWM, non inverted
TCCR2B = 1; // Vorteiler 1 -> 7,8ms Überlaufperiode
OCR2A = 128; // PWM, Tastverhältnis 50%
while((ASSR & (1<< TCR2BUB))); // Warte auf das Ende des Zugriffs
TIFR2 &= ~(1<<TOV2); // Interrupts löschen
TIMSK2 |= (1<<TOIE2); // Timer overflow Interrupt freischalten

// EEPROM Werte auslesen

rtc_cal= eeprom_read_word(&ee_rtc_cal);

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

while((ASSR & (1<< OCR2AUB))); // Warte auf das Ende des Zugriffs
set_sleep_mode(SLEEP_MODE_PWR_SAVE);
sleep_mode(); // in den Schlafmodus wechseln

// hier wachen wir wieder auf, nach Ausführung des 7,8ms Timerinterupt

if (flag_1s) {
flag_1s =0;
LED_TOGGLE // Test
}

}
}

// Timer2 overflow Interrupt

ISR(TIMER2_OVF_vect) {
static uint8_t ticks; // Hilfsvariable für Messintervall
static int16_t time_error; // RTC Fehlerkompensation

// Zeitkritische Dinge, welche am Anfang der ISR stehen müssen!

OCR2A=128; // Dummy-Write zur Sicherung des Timings
// von Timer 2 im asynchronen Modus

// RTC Fehler korrigieren

if (time_error>999) { // RTC zu schnell
TCNT2 = 2; // Zähler einen Schritt zurück setzen (2 Takte Verzögerung!)
time_error -= 1000;
} else if (time_error<-999) { // RTC zu langsam
TCNT2 = 4; // Zähler einen Schritt vor setzen (2 Takte Verzögerung!)
time_error += 1000;
}

// ab hier ist es nicht mehr zeitkritisch

// Echtzeituhr
ticks++; // 1/128tel Sekunde
if (ticks==128) { // Sekundenintervall
time_error += rtc_cal; // RTC Fehler akkumulieren

// 24h Timer
time++;
if (time==86400) time=0; // 24h Überlauf

ticks=0;
flag_1s =1; // setzte Flag für 1s Verarbeitung in main Endlosschleife
}
}
</syntaxhighlight>

=== Weitere Verbesserungen ===

Der Algorithmus ermöglicht eine sehr hochauflösende Kalibrierung der RTC. Allerdings heisst das leider noch lange nicht, daß die RTC dann auch wirklich so genau ist. Denn diese Kalibrierung gilt nur für eine exakte Temperatur! Auch ein Quarz hat eine Temperaturabhängigkeit der Schwingfrequenz. Wenn man nun eine sehr genaue RTC bauen möchte, welche über einen grossen Temperaturbereich genau läuft, muss man periodisch die Temperatur messen und in die Kalibrierung einbeziehen. Einen typischen Temperaturverlauf des Frequenzfehlers zeigt das folgende Bild.

[[bild:rtc_tk.gif|thumb|260px|left|Temperaturgang eines Uhrenquarzes]]
 

Weiterhin kann man natürlich die Kalibrierung ohne erneutes Kompilieren des Quelltextets vornehmen, indem man den Kalibrierwert per [[UART]] oder [[I2C]] an den AVR sendet und im [[Speicher#EEPROM | EEPROM]] speichert.

Kernpunkt der Kalibrierung ist natürlich die Messung der realen Quarzfrequenz. Die oben beschriebene Methode per Tagesschau und 1 Tag warten ist sehr zeitaufwändig und hat eine begrenzte Genauigkeit von ca. 1/2 Sekunde, das entspricht 5,8ppm. Hier muss zwangsläufig ein guter Frequenzzähler her. Da dieser nicht jedem Hobbybastler zur Verfügung steht, muss man sich in Lehrwerkstätten, Universitäten oder Firmen im Elektronikbereich umsehen und nachfragen, ob man einen Frequenzzähler vor Ort kurze Zeit nutzen kann.

Einige GPS-Module bieten auch einen hochgenauen 1PPS (Pulse Per Second) Ausgang an, der sich für den Abgleich gut heranziehen lässt. Auch das Sekunden-Zeichen eines DCF77-Funkuhr-Moduls ist sehr genau und kann als Referenz dienen.

== Links ==

*[http://www.mikrocontroller.net/articles/Uhr Implementierung einer Uhr mit Siebensegmentausgabe auf einem AVR ATTiny2313]
*[http://www.mikrocontroller.net/topic/165249 Uhr mit genauer Sekunde BASCOM]
*[https://www.mikrocontroller.net/topic/298306 Stromsparende und günstige Zeitmessung: ATtiny mit Uhrenquarz getaktet]

[[Category:AVR-Projekte]]
[[Category:Timer und Uhren]]

AVR Bootloader FastBoot von Peter Dannegger

2014-01-23T08:55:35Z

Jackfritt: /* Added links for avrdude support */

''von Karsten Donat''

== Was ist ein Bootloader? ==

Der Bootloader ist selbst ein kleines Programm. Es wird beim Start des Controllers zuerst ausgeführt. Damit sich das PC-Programm für das Firmware-Update melden kann, wartet der Bootloader eine gewisse Zeit (hier 0,33 Sekunden) auf ein Zeichen über die serielle Schnittstelle (UART RS232, USB). Kommt dies Zeichen, wird die neue Firmware gebrannt. Andernfalls wird das eigentliche Programm des Controllers ausgeführt.

Dem eigentlichen Anwendungsprogramm geht natürlich der Platz verloren, den der Bootloader benötigt. Da Peters Bootloader jedoch in ein 512Bytes (256 Worte!) großes Segment passt, stört das nicht weiter.

Normalerweise wird der Programmcode des Mikrocontrollers mit einem ISP-Dongle in den Flash gebrannt. Aus verschiedenen Gründen kann dies jedoch nicht möglich/ gewünscht sein:
* Geschwindigkeit: Der ISP-Dongle kann langsam sein (z. B. myAVR mit aktuellem AVRDude)
* PINs: Man braucht die PINs und will ISP abschalten (Fuses, aber Vorsicht!, danach kann man nur mit dem Bootloader oder einem [[AVR HV-Programmer]] noch an den Flash-Speicher)
* Komfort: Man möchte dem Kunden/Nutzer die Möglichkeit geben, eine neue Firmware selbst einzuspielen. In der Regel hat dieser jedoch keinen ISP-Dongle zur Hand. Eine RS232- oder USB-Schnittstelle ist aber oftmals vorhanden.
* Sicherheit: Man möchte dem Kunden nicht die Firmware in deassemblierbarer Form geben (über geänderten Bootloader kann die Datei verschlüsselt sein).

== Features ==
* Automatische Erkennung der vom PC verwendeten Baudrate
* [http://www.mikrocontroller.net/topic/73196#610574 Ein] oder zwei Wire Betrieb
* Support für viele verschiedene AVRs wie: tiny13, tiny2313, tiny25, tiny261, tiny44, tiny45, tiny461, tiny84, tiny85, tiny861, mega48, mega8, mega8515, mega8525, mega88, mega16, mega162, mega168, mega32, mega64, mega644, mega128, mega1281, mega2561.
* Passwortschutz gegen unberechtigtes Umprogrammieren (aber keine Verschlüsselung des Programms).
* Freie Software - unter GPL lizenziert ([http://www.mikrocontroller.net/topic/73196?goto=848377#848377 Link]). Das eigentliche Anwendungsprogramm, das über den Bootloader geladen wird muß deswegen *nicht* unter der GPL stehen und dessen Quelltext auch *nicht* veröffentlicht werden ([http://www.mikrocontroller.net/topic/73196?goto=950943#950943 Link]).

== Anforderungen an das zu ladende Programm ==
Bei AVRs ohne "boot reset vector fuse" (BOOTRST) wie beispielsweise ATtinys und kleinen ATmegas (ATmega48) muß der erste Befehl ein RJMP sein. Für C-Programme ist das automatisch sichergestellt (und für Assembler-Programme leicht selbst sicherzustellen).

== Downloads ==

'''Thread zum Bootloader: [http://www.mikrocontroller.net/topic/73196 UART Bootloader ATtiny13 - ATmega644]'''

* '''Version 2.1''' (Forumsbeiträge):
** [http://www.mikrocontroller.net/topic/goto_post/850843 Ursprüngliche Version von Peter Dannegger], inkl. DOS Host-Software
** [http://www.mikrocontroller.net/topic/goto_post/1824790 Angepasste Version für AVR-GCC-Toolchain]
** [http://www.mikrocontroller.net/topic/goto_post/685654 Protokollbeschreibung] Host <-> Target Kommunikation
** [http://www.mikrocontroller.net/topic/goto_post/610574 Schaltbild für One-Wire-Betrieb]
* '''Host-Software für Version 2.1'''
** [http://www.mikrocontroller.net/topic/goto_post/2320796 Linux-Host] (mit One-Wire-Unterstützung), Sourcecode im [https://github.com/Boregard/FBoot-Linux GitHub]
** [http://www.avrfreaks.net/index.php?module=Freaks%20Academy&func=viewItem&item_type=project&item_id=1927 Linux- und Mac-Host] (ohne One-Wire-Unterstützung), nur mit Anmeldung
** [http://www.mikrocontroller.net/topic/goto_post/1855508 Dev-C++ Portierung] (Win64)
** [http://www.mikrocontroller.net/topic/314358 Windows-Host mit GUI] von [http://www.leo-andres.de/2012/09/updateloader-benutzeroberflache-fur-avr-bootloader/ leo-andres.de], [http://www.mikrocontroller.net/topic/goto_post/2827323 alte Version]
* '''Host-Software für Version 1.7'''
** [http://www.kreatives-chaos.com/artikel/fastboot17-frontend-python Python-Script] von kreatives-chaos.com
** [http://www.mikrocontroller.net/topic/goto_post/698193 Dev-C++ Portierung] (Win32)
* '''Sonstiges'''
** Atmel AVR-Studio (um Bootloader zu assemblieren): [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725]
** Ältere Version dieser Anleitung als PDF: [http://www.KarstenDonat.de/AVR/Bootloader.pdf http://www.KarstenDonat.de/AVR/Bootloader.pdf]

== Bootloader anpassen ==

=== CPU auswählen – BOOTLOAD.ASM ===

Die CPU (der Atmel auf dem der Bootloader laufen soll) wird durch Einkommentieren der zugehörigen Include-Files ausgewählt. Im Beispiel für einen ATtiny45.

<syntaxhighlight lang="avrasm">
; select the appropriate include file:
;.include "tn13def.inc"
;.include "tn2313def.inc"
;.include "tn25def.inc"
;.include "tn261def.inc"
;.include "tn44def.inc"
.include "tn45def.inc"
;.include "tn461def.inc"
;.include "m48def.inc"
;.include "tn84def.inc"
;.include "tn85def.inc"
;.include "tn861def.inc"
</syntaxhighlight>

Dabei nicht vergessen, die bisher (per Default) ausgewählte CPU ATmega168 auszukommentieren:

<syntaxhighlight lang="avrasm">
;.include "m168def.inc"
</syntaxhighlight>

=== UART Port und Pins festlegen – BOOTLOAD.ASM ===

Da die verwendeten Pins für die Schnittstelle frei wählbar sind, müssen diese noch eingestellt werden.

STX_PORT: Hier den Sendeport angeben. Für die Pins des Hardware-UARTs des M8 wäre das Port D. Es müssen zwar nicht dieselben Pins sein, wenn man sie aber ohnehin als Schnittstelle nutzt, ist es sinnvoll, sie auszuwählen. Verwendet wird immer ein im Bootloader integrierter Software-UART, der auf beliebigen I/O-Pins lauschen kann.

<syntaxhighlight lang="avrasm">
.equ STX_PORT = PORTD
.equ STX = PD1

.equ SRX_PORT = PORTD
.equ SRX = PD0
</syntaxhighlight>
''Beispiel für gleiche Bepinnung wie Hardware-UART im ATMega 8, 48, 168''

Für One-Wire-Betrieb muß für TX und RX zweimal der gleiche Pin angeben werden. Beim Assemblieren wird das erkannt und One-Wire aktiviert - es ist keine weitere Änderung nötig.

=== CPU-Frequenz und Wartezeit festlegen - FASTLOAD.H ===

Bei XTAL die benutzte Frequenz des Controllers einstellen (jungfräuliche AVRs haben oft intern 1MHz aktiviert!).
Im Standard Makefile von WinAVR steht die Frequenz unter F_CPU

<syntaxhighlight lang="avrasm">
.equ XTAL = 8000000 ; 8MHz, not critical
</syntaxhighlight>

Um die Wartezeit auf das Firmware-Update beim Booten anzupassen:
<syntaxhighlight lang="avrasm">
.equ BootDelay = XTAL / 3 ; 2.66s
</syntaxhighlight>

== Assemblieren des Bootloaders ==

Da der Bootloader in Assembler geschrieben ist, kann WinAVR nicht so ohne weiteres damit umgehen.
Das einfachste ist, sich das AVRStudio von Atmel herunterzuladen [http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725 http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2725]

Im Unterverzeichnis AvrAssembler2 befindet sich der benötigte Assembler. Das Einfachste ist, sich die unter "Appnotes" benötigte Include Datei des jeweiligen Controllers (oder das komplette Verzeichnis) und die avrasm2.exe ins Verzeichnis des Bootloaders zu kopieren.

Danach wird der Assembler aufgerufen (m8.asm für ATMega 8) und der Bootloader kompiliert:
<pre>
avrasm2 -fI BOOTLOAD.ASM
</pre>

Es ist wichtig, dass die Includes des avrasm2 und nicht die der alten Version verwendet werden, da es sonst beim Assemblieren zu dem Fehler
"''fastload.h(112): error: Use of undefined or forward referenced symbol 'SRAM_START' in .org''"
kommt.

Das AVRStudio lässt sich unter Linux auch mit WINE installieren (die IDE des AVR Studio 4 geht allerdings nur mit ein paar Tricks aus der AppDB - ist für das Assemblieren des Bootloaders aber nicht nötig). Wenn "avrasm2.exe" und die zum AVR passende Include-Datei (beispielsweise "tn45def.inc" für ATtiny45) im gleichen Verzeichnis wie die restlichen Dateien des Bootloaders liegen, kann der Bootloader mit folgendem Befehl assembliert werden:
<pre>
wine avrasm2.exe -fI BOOTLOAD.ASM
</pre>

== Brennen des Bootloaders ==

Der nun erzeugte Bootloader wird mit dem vorhanden ISP Dongle in den AVR gebrannt (Intel Hex Format):

"avrdude" -p m8 -c avr910 -P com1 -U flash:w:"C:\Test\m8 3686400.hex":i -U flash:v:"C:\Test\m8 3686400.hex":i -y

''Brennen mit AVRDude auf COM 1 und einem AVR910 kompatiblen Dongle (z. B. myAVR USB)''

== Einstellen der Fuses ==

Damit der Bootloader zu Beginn gestartet wird, müssen die entsprechenden Fuses gesetzt werden. Möglich ist dies u.a. mit der AVRDude GUI.
* BOOTRST muss auf 0 gestellt werden (aktiviert den Bootloader)
* BOOTSZ muss auf 256 Worte (= 512 Byte) (oder dem minimal möglichen Wert, wenn AVR nur größere Bootloader Regionen unterstützt) gestellt werden. Beispielsweise ist für den ATMega8 der Wert 10.

Bei einigen Controllern wie z. B. dem ATMega 48 wird das Flag
* Selfprogramming enabled gesetzt.

Auf dieser [http://www.engbedded.com/fusecalc/ Website (Fusecalc)] kann man sich die Fuses elegant zusammenstellen und erhält gleich die Parameter für avrdude. Eine schnelle und *sichere* Alternative zum fehlerträchtigen "Kaputtflashen" von Atmels.

== Brennen des eigentlichen Programmes ==

Damit das Programm mit Peters Tool in den Controller geladen werden kann, muss es im Intel HEX Format vorliegen. Im makefile Template von WinAVR (und auch der ATMegaIDE) ist dies standardmäßig eingestellt.
<syntaxhighlight lang="c">
# Output format. (can be srec, ihex, binary)
FORMAT = ihex
</syntaxhighlight>

Danach wird Peters Firmware-Update Tool aufgerufen (hier COM2)

<pre>
fboot /C2 /Pmain.hex
</pre>
''hier wird die main.hex als Hauptprogramm gebrannt''

Wichtig hierbei ist, dass der Dateiname der alten DOS Konvention entspricht. Also keine langen Dateinamen.

Peters Firmware-Update Tool lässt sich unter Linux leider nicht mit WINE starten, dafür aber mit DOSBOX. Der Aufruf ist dann der gleiche wie unter Windows.

Wenn noch keine Firmware im Controller ist (direkt nach dem Installieren des Bootloaders), startet der Brennvorgang automatisch. Andernfalls wartet das Programm auf den Reset des Controllers. Peters Tool arbeitet nur mit COM1 bis COM4 zusammen. Also ggf. den USB Adapter im Gerätemanager umstellen.

Die Ausgabe sieht dann wie folgt aus:
<pre>
C:\DOCUME~1\zzzzzz\Desktop\avr\_soft\fboot18>fboot18 /Ptest.hex /b9600 /c1
COM 1 at 9600 Baud: Connected (One wire)
Bootloader V1.8
Target: 1E9108
Buffer: 32 Byte
Size available: 1534 Byte
Program test.hex: 00000 - 00073 successful
CRC: o.k.
Elapsed time: 1.43 seconds
</pre>

Für Linux steht ebenfalls ein [https://github.com/Boregard/FBoot-Linux Programmiertool] (aus diesem [http://www.mikrocontroller.net/topic/73196#1067153 Beitrag]) für die aktuelle Version 2.1 des Bootloaders für die Kommandozeile zur Verfügung, das auch den One-Wire-Betrieb unterstützt.

Es lässt sich nach dem Entpacken durch ein simples "make" übersetzen. Die Verwendung ist analog zum DOS-Tool:
<pre>
./bootloader -d /dev/ttyS0 -b 115200 -p tiny45test.hex

=================================================
| BOOTLOADER, Target: V2.1 |
=================================================
Port : /dev/ttyS0
Baudrate: 115200
File : tiny45test.hex
Reading : tiny45test.hex... File read.
Size : 2717 Bytes
Program device.
-------------------------------------------------
Waiting for device... connected (one wire)!
Bootloader : V2.1
Target : 1E9206 ATtiny45
Buffer : 64 Byte
Size available: 3582 Byte
CRC enabled and OK.
Programming : 00000 - 00A9D
Writing | ##################################### | 100%
Elapsed time: 0.79 seconds, 3439 Bytes/sec.

++++++++++ Device successfully programmed! ++++++++++

...starting application
</pre>

== Bootloader-Support in ATMegaIDE 2007 ==

Die IDE kann wahlweise mit AVRDude und einem entsprechenden ISP-Dongle oder mit dem Bootloader das Programm in den Flash brennen.

=== Anpassen des Programms ===
Um das Firmware Update komfortabler zu gestalten, kann ein Software-Reset eingebaut werden, der per RS232- bzw. USB-Schnittstelle oder Tastendruck ausgelöst wird.

==== Tastendruck ====
In der mitgelieferten Standard.h gibt es den Befehl void Reset();. Er löst mit Hilfe des Watchdog-Timers einen Hardwarereset aus. Man kann jetzt z. B. auf einen bestimmten Tastendruck (-kombination) hin diesen Reset ausführen.

==== RS232/USB ====
Alternativ kann ein entsprechender Befehl über die RS232 gesendet werden. Standardmäßig ist dies 0xFF ‚R‘.

=== Einstellungen in der IDE ===

Der Bootloader Support kann bei den Projekt-Eigenschaften eingestellt werden. Beim Brennen wird er dann automatisch benutzt.

== ToDo ==

=== Komfortables Stand-Alone Firmware-Update ===

Basierend auf dem Code der IDE wird es im September noch ein Standalone-Programm für das Firmware-Update geben. Es wird auch ein entsprechendes Protokoll zur Versionskontrolle haben (die bisherige Soft- und viel wichtiger Hardwareversion wird überprüft). Eine Verschlüsselung der Firmware-Datei ist in Planung.

=== Automatisches Erzeugen des Bootloaders ===
Sobald ich Zeit habe kommt in die IDE auch die Möglichkeit, die Anpassungen des Bootloaders von der IDE durchführen zu lassen.

=== Integration von fastboot in avrdude ===
Scheint zu laufen, wurde aber wegen diversen Änderungen in avrdude noch nicht integriert.
Eventuell erbarmt sich ja mal jemand :)
* [http://savannah.nongnu.org/patch/?7594 patch #7594 Support for Atmel serial UART-Bootloader "FastBoot"]
* [http://www.mikrocontroller.net/topic/73196#1789173 Patch von Stefan G. (sgm)]
[[Kategorie:AVR-Programmer und -Bootloader|B]]

AVR - Die genaue Sekunde / RTC

2013-09-07T11:37:09Z

Jackfritt: /* Uhrentakt genau messen und digital korrigieren */

== Einleitung ==
Oftmals sieht man Projekte, bei denen ein externer RTC-Baustein (engl. '''R'''eal '''T'''ime '''C'''lock, Echtzeituhr; z. B. PCF8583 mit [[I2C]]-Anschluss [http://www-us.semiconductors.philips.com/acrobat/datasheets/PCF8583_5.pdf Datenblatt (PDF)]) angeschlossen ist, ohne dessen Vorteil wirklich zu nutzen.

Die wichtigsten Vorteile einer externen RTC sind
# Die Zeitzählung läuft während eines Ausfalls der Hauptstromversorgung über eine kleine Stützbatterie bei geringem Strombedarf weiter.
# Es gibt hochgenaue RTCs, die man im Gegensatz zu Selbstbaulösungen nicht abgleichen muss.
# Der Strombedarf eines externen RTC ist in der Regel etwas niedriger als die RTC Funktion eines Prozessors. Als Vergleich diene ein DS1302(300nA@2V) zu einem Mega32(5uA@2.7V) als nicht ganz neuer Vertreter, bzw. ein Mega324P(500nA@1.8V) als moderner Vertreter. Dieser Vorteil kommt bei Datenschreibern (engl. data logger) zum Tragen, welche die meiste Zeit inaktiv im [[Sleep Mode]] sind.

In allen anderen Fällen ist die zusätzliche Hardware nicht unbedingt nötig und man kann eine präzise Zeitbasis bequem mit dem Hauptquarz des Mikrokontrollers programmieren. Daraus ergeben sich sogar noch zusätzliche Vorteile, wie eine geringere Temperaturabhängigkeit und höhere Güte, die Quarze im MHz-Bereich gegenüber Quarzen im kHz-Bereich besitzen. Ich möchte hiermit die Angst vor dem bisschen Mathematik nehmen, welche zur Berechnung der Teilerfaktoren benötigt wird.

==Lösung==

Speziell für den AVR kommen Quarze im Bereich 1MHz bis 16MHz zum Einsatz, d.h. in einer Sekunde werden 1.000.000 bis 16.000.000 Zyklen durchlaufen (Zyklen pro Sekunde = Frequenz). Möchte man eine Sekunde messen, kann man somit die entsprechende Anzahl Zyklen von Null an hochzählen oder von dem entsprechenden Wert bis auf 0 runterzählen. Für das Zählen bietet sich im µC der Compare-Modus eines Timers an.

Die obigen Zahlen lassen sich jedoch nicht in einer 16 Bit Variablen ausdrücken da sie zu gross sind und somit ist ein direktes Setzen des Compare-Wertes des Timers T1 im AVR nicht möglich. Deshalb unterteilt man die Quarzfrequenz in zwei Faktoren; der erste (Softwareteiler) bestimmt die Periode des Timers T1 und der zweite den Reloadwert eines Registers, welches im Timerinterrupt runtergezählt wird.

==Beispiel==

Im Beispiel AVR wird ein 11,0592-MHz-Quarz verwendet, was einem üblichen [[Baudratenquarz]] entspricht, d.h. damit können die UART-Standardbaudraten erzeugt werden.

Der Softwareteiler wird mit 256 gewählt, d.h. 256 Timerinterrupts pro Sekunde, und kann somit mit nur einem einzigen Byte realisiert werden. Für größere Werte muß der Softwareteiler als int (2 Byte) deklariert werden. Bei kleineren Werten als 256 muss man beachten, dass der zweite Faktor immer noch in 2 Byte passt, um als Comparewert für den 16-Bit-Timer 1 verwendet werden zu können.

Die Timerroutine wird in einer Sekunde Softwareteiler-Mal aufgerufen. Mit diesen 256 Hz ergibt sich eine Timerinterruptzeit von ca. 4ms, die auch sehr gut zum Entprellen von Tasten benutzt werden kann. Eine Entprellroutine kann also bequem in den Timerinterrupt mit eingefügt werden. Beachten muss man nur noch, dass das Nullsetzen des Timers erst einen Zyklus nach dem Comparematch erfolgt.

==Berechnung==

Die Berechnung des Comparewertes ist sehr einfach:

<syntaxhighlight lang="c">
Comparewert OCR1A = 11059200 / 256 - 1 = 43199, Rest 0.
</syntaxhighlight>

Da haben wir ja noch mal Glück gehabt, es gibt keinen Rest bei der Division und die Sekunde ist exakt
256 * 43200 = 11059200 Zyklen lang. 
Theoretisch. 
Denn selbst wenn auf dem Quarz eine Frequenz von 11,0592 Mhz aufgedruckt ist, so schwingt er doch auf
einer etwas anderen Frequenz. Der Grund dafür sind Fertigungstoleranzen und natürlich die Tatsache,
dass die Frequenz eines Quarzes auch von der Temperatur abhängig ist. Es gilt also zunächst einmal
herauszufinden, auf welcher Frequenz der Quarz wirklich schwingt.

Dazu wird eine Uhr programmiert und mit dem theoretischen Wert laufen gelassen. Nun habe ich die Uhr
einen Tag laufen lassen und festgestellt, dass sie 1,5 s nach geht (Dazu kann man beispielsweise die Tagesschau nutzen, welche jeden Tag um 20:00 (+einer konstanten Zeitverschiebung durch das Übertragungsmedium SAT,DVB-T, ...) beginnt und sogar eine Uhr dabei einblendet). D.h. die Quarzfrequenz beträgt in
Wirklichkeit:
<syntaxhighlight lang="c">
11059200 * (1 - 1,5 / 24 / 60 / 60) = 11059008 Hz.
</syntaxhighlight>
Ausführliche Rechnung:
<syntaxhighlight lang="c">
(Zyklen in 24h - Zyklen Verspätung) / Sekunden pro 24h = korrekte Frequenz
((24 * 60 * 60 * 256 * 43200) - (1,5 * 256 * 43200)) / (24 * 60 * 60) = 11059008 Hz.
</syntaxhighlight>

Also die ganze Rechnung nochmal:
<syntaxhighlight lang="c">
OCR1A = 11059008 / 256 - 1 = 43198, Rest 64.
</syntaxhighlight>
Nun haben wir einen Rest und es würden uns jede Sekunde 64 Zyklen fehlen. Das geht natürlich nicht.

Deshalb wird jedesmal, wenn der Softwareteiler Null ist und die Sekunde weitergezählt wird, ein
anderer Comparewert geladen. Dieser ist dann um den Rest größer. Und beim nächsten Timerinterrupt
wird dann wieder der Comparewert geladen, der das Ergebnis der Division war.

Es ergeben sich somit:
<syntaxhighlight lang="c">
255 * (43198 + 1) + 1 * (43198 + 64 + 1) = 11059008 Zyklen
</syntaxhighlight>
Exakt so, wie wir es wollten.

==Das Programm==

Nachfolgend nun das C-Programm. Da wir ja alle nicht gerne rechnen, lassen wir das einfach den C-Compiler erledigen. D.h. wir brauchen nur noch per Definition für XTAL den entsprechenden Wert eintragen und der Compiler rechnet alle nötigen Konstanten ganz alleine aus.

So ein Compiler ist auch ziemlich faul, der merkt sofort, wenn die Operanden für eine Berechnung alles Konstanten sind. Und ehe er sich damit abquält, extra Code für diese Berechnungen zu erzeugen, rechnet er es lieber selber aus und fügt das Ergebnis direkt in den Code ein.

Der Assembler kann auch 32-Bit Konstanten-Berechnungen ausführen. Allerdings muß man dann die entsprechenden Präprozessoroperationen benutzen. Man könnte auch eine Divisionsroutine aufrufen, aber dann würde ja echter Code erzeugt.

===Beispiel in C===

Wichtig: Ab Ver.1.4.0 haben sich Namen/Funktionen geändert: 

"There are currently two different styles present for naming the vectors. One form uses names starting with SIG_, followed by a relatively verbose but arbitrarily chosen name describing the interrupt vector. This has been the only available style in avr-libc up to version 1.2.x.

Starting with avr-libc version 1.4.0, a second style of interrupt vector names has been added, where a short phrase for the vector description is followed by _vect. The short phrase matches the vector name as described in the datasheet of the respective device (and in Atmel's XML files), with spaces replaced by an underscore and other non-alphanumeric characters dropped. Using the suffix _vect is intented to improve portability to other C compilers available for the AVR that use a similar naming convention...."

Quelle: http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html
<syntaxhighlight lang="c">
/************************************************************************/
/* */
/* Precise 1 Second Timebase */
/* */
/* Author: Peter Dannegger */
/* danni@specs.de */
/* */
/************************************************************************/
// Target: Mega8, 2313

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

#ifndef OCR1A
#define OCR1A OCR1 // 2313 support
#endif

#ifndef WGM12
#define WGM12 CTC1 // 2313 support
#endif

#ifndef PINC
#define KEY_INPUT PIND // 2313
#else
#define KEY_INPUT PINC // Mega8
#endif
#define LED_DIR DDRB

//#define XTAL 11059201L // nominal value
#define XTAL 11059008L // after measuring deviation: 1.5s/d

#define DEBOUNCE 256L // debounce clock (256Hz = 4msec)

#define uchar unsigned char
#define uint unsigned int

uchar prescaler;
uchar volatile second; // count seconds

SIGNAL (SIG_OUTPUT_COMPARE1A)
{
/************************************************************************/
/* Insert Key Debouncing Here */
/************************************************************************/

#if XTAL % DEBOUNCE // bei rest
OCR1A = XTAL / DEBOUNCE - 1; // compare DEBOUNCE - 1 times
#endif
if( --prescaler == 0 ){
prescaler = (uchar)DEBOUNCE;
second++; // exact one second over
#if XTAL % DEBOUNCE // handle remainder
OCR1A = XTAL / DEBOUNCE + XTAL % DEBOUNCE - 1; // compare once per second
#endif
}
}

int main( void )
{
LED_DIR = 0xFF;
while( KEY_INPUT & 1 ); // start with key 0 pressed

TCCR1B = (1<<WGM12) | (1<<CS10); // divide by 1
// clear on compare
OCR1A = XTAL / DEBOUNCE - 1; // Output Compare Register
TCNT1 = 0; // Timmer startet mit 0
second = 0;
prescaler = (uchar)DEBOUNCE; //software teiler

TIMSK = 1<<OCIE1A; // beim Vergleichswertes Compare Match
// Interrupt (SIG_OUTPUT_COMPARE1A)
sei();

for(;;){
if( second == 60 )
second = 0;
PORTB = second; // display second (binary)
}
}
</syntaxhighlight>

===Beispiel in Assembler===

<syntaxhighlight lang="avrasm">
;************************************************************************/
;* */
;* Precise 1 Second Timebase */
;* */
;* Author: Peter Dannegger */
;* danni@specs.de */
;* */
;************************************************************************/
.nolist
.include "m8def.inc"

.equ xtal = 11059008
.equ debounce = 256
.equ remainder = xtal - xtal / debounce * debounce

.def isreg = r15
.def wr0 = r16
.def iwr0 = r17
.def prescaler = r18
.def second = r19

.list
rjmp init
.org OC1Aaddr
rjmp OC1Aint
;-------------------------------------------------------------------------
OC1Aint:
in isreg, sreg
;************************************************************************/
;* Insert Key Debouncing Here */
;************************************************************************/

ldi iwr0, high( xtal / debounce - 1 )
out ocr1ah, iwr0
ldi iwr0, low( xtal / debounce - 1 )
out ocr1al, iwr0

dec prescaler
brne _oci1

ldi prescaler, debounce
inc second

ldi iwr0, high( xtal / debounce + remainder - 1 )
out ocr1ah, iwr0
ldi iwr0, low( xtal / debounce + remainder - 1 )
out ocr1al, iwr0
_oci1:
out sreg, isreg
reti
;-------------------------------------------------------------------------
init:
ldi wr0, 0xFF
out ddrb, wr0
sbic pinc, 0
rjmp init

ldi wr0, high( ramend )
out sph, wr0
ldi wr0, low( ramend )
out spl, wr0

ldi wr0, 1<<WGM12^1<<CS10
out TCCR1B, wr0

ldi wr0, high( xtal / debounce - 1 )
out ocr1ah, wr0
ldi wr0, low( xtal / debounce - 1 )
out ocr1al, wr0
out tcnt1l, wr0
ldi prescaler, debounce

ldi wr0, 1<<OCIE1A
out TIMSK, wr0
sei
main:
ldi second, 0
_mai1:
cpi second, 60
breq main
out PORTB, second
rjmp _mai1
;------------------------------------
</syntaxhighlight>

===Verbesserte Version mit durchlaufendem Hardwarezähler===

Hier sind trotzdem kleine Verbesserungsvorschläge.

Wird im Timer die Option "Clear On Compare Match" verwendet, so verliert man den Overflow Interrupt. Oder möchte man nebenher noch eine Zeit mit dem Capture Interrupt messen, so benötigt man einen durchlaufenden Timer. Um dies zu erreichen, wird OCR1A nicht fest eingestellt, sondern bei jedem Aufruf um den gleichen Wert erhöht.

In Peters Code wurde der Rest auf einmal abgearbeitet. Damit erspart man sich bei jedem Interrupt einen Vergleich und die Verarbeitungszeit verkürzt sich in seinem Code. Der Unterschied zwischen kurzem und langem Interrupt ist hier der Rest. Bei den geänderten Codeschnipseln wird der Rest gleichmäßiger abgearbeitet. Der Unterschied zwischen kurzem und langem Interrupt beträgt 1 Takt.

ungetesteter Code für den durchlaufenden Timer:

<syntaxhighlight lang="c">
SIGNAL (SIG_OUTPUT_COMPARE1A) {
/************************************************************************/
/* Insert Key Debouncing Here */
/************************************************************************/

if( --prescaler == 0 ){
prescaler = (uchar) DEBOUNCE;
second++; // exact one second over
}
#if XTAL % DEBOUNCE
if (prescaler <= XTAL % DEBOUNCE)
OCR1A += XTAL / DEBOUNCE +1; /* um 1 Takt längere Periode um den Rest abzutragen */
else
#endif
OCR1A += XTAL / DEBOUNCE; /* kurze Periode */
}
</syntaxhighlight>

===Durchlaufender Hardwarezähler und fortlaufende Addition===

Gänzlich ohne Hin- und Hertogglen eines Bits kommt man aus, wenn irgendein Timer mit einer Überlauf-Interruptfrequenz > 1Hz arbeitet. Dann kann die ISR eine 32-bit-Konstante auf einen 32-bit-Akkumulator addieren; bei Überlauf ist eine Sekunde vergangen. Zugegeben, es gibt "lange" und "kurze" Sekunden, aber der Fehler summiert sich nicht, und der Code ist sehr einfach.

Hier ein Beispiel:

Es gibt ein Programm gettick(), das einen Wert holt. Dieser Wert wird von Zeit zu Zeit von der Hardware (Beispiel AVR: der Timer) oder dem Betriebssystem (Beispiel Linux: gettick ruft getmsec, getmsec ruft gettimeofday)

Dieser aufgerufene Wert sollte pro Sekunde um TICKPERSEC erhöht werden, was aber mit einer gewissen Ungenauigkeit geschieht.

Die Laufzeitkorrektur wird dadurch ausgeführt, dass der von gettick() zurückgegebene Wert mit einem Faktor TFAK multipliziert wird. Der Faktor sollte so gewählt werden, dass:

* Das Ergebnis actual_value immer in 32 Bit hineinpasst.
* Die Multiplikation durch Schiebeopertionen ersetzt werden kann, weil der Faktor eine 2-er-Potenz ist. (Das erledigt avr-gcc)

Immer wenn tsdaytim_calibrated() erkennt, dass eine Sekunde vergangen, wird last_value um die Zahl onesecond erhöht.

Der Zahlenwert onsecond wird mit TICKPERSEC*TFAK initalisiert und kann angezeigt oder neu eingegeben werden (Die Bedienung der seriellen Schnittstelle hierfür ist in diesem Beispiel nicht enthalten).

Wenn festgestellt wird, dass die Uhr pro Zeit (P) um (E) zu schnell geht, dann kann der Wert onsecond korrigiert werden.

c = d * (P+E)/P
Beispiel Pro 7 Tage 120 Sekunden zu viel:

7 Tage = 7*86400= 604800 sekunden
c = 992000000 * (604800+120)/604800=991803175
Dann wird die Uhr genauer gehen.

<syntaxhighlight lang="c">
/****************************************************************/
/* File home/cc/qq/danclock.cpp */
/* Precise 1 Second Timebase */
/* */
/* Author: Peter Dannegger / Hjherbert */
/* danni@specs.de */
/* */
/****************************************************************/
// Target: atmega8, (2313?)

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

#ifndef OCR1A
#define OCR1A OCR1 // 2313 support
#endif

#ifndef WGM12
#define WGM12 CTC1 // 2313 support
#endif

#ifndef PINC
#define KEY_INPUT PIND // 2313
#else
#define KEY_INPUT PINC // Mega8
#endif

//#define F_CPU 11059201L // nominal value

#define DIVISOR 256

#define TICKPERSEC (F_CPU/DIVISOR)

uint8_t volatile second; // count seconds

// TFAK ? TICKPERSEC must not exceed 2^32
#define TM (0x7FFFFFFFUL/2/TICKPERSEC) // max of TFAK

#define TFAK ( ( (TM>>1) | (TM>>2) | (TM>>3) | (TM>>4) | (TM>>5) | (TM>>6) | (TM>>7) \
| (TM>>8) | (TM>>9) | (TM>>10) | (TM>>11) | (TM>>12) | (TM>>13) | (TM>>14) | (TM>>15) \
| (TM>>16) | (TM>>17) | (TM>>18) | (TM>>19) | (TM>>20) | (TM>>21) | (TM>>22) | (TM>>23) \
| (TM>>24) | (TM>>25) | (TM>>26) | (TM>>27) | (TM>>28) | (TM>>29) | (TM>>30) | (TM>>31) \
) + 1 )
// TFAK is a power the biggest power of two which is less than TM

uint32_t onesecond = 1*TICKPERSEC*TFAK ; // correct this value if see the clock is late / too fast
uint32_t last_value ;
uint32_t ticks ;

SIGNAL (SIG_OUTPUT_COMPARE1A)
{
++ticks ;
}

uint32_t gettick( void )
{
uint32_t l ;
cli();
l = ticks ;
sei();
return l ;
}

void tsdaytim_calibrated(void)
// Keep the time-of-the-day actual
// Add a second, if a second if gone
{
uint32_t actual_value ; // gettick() multiplied by factor 2^n

actual_value = gettick() * TFAK ; // because TFAK is a power of two
// The compiler will create some shift commands

if ( actual_value - last_value > onesecond )
{ // once per second
if ( ++second >= 60 )
{
second = 0 ;
}
last_value += onesecond ; // One second more
}
}

int main( void )
{
DDRB = 0xFF;
while( KEY_INPUT & 1 ); // start with key 0 pressed

TCCR1B = 1<<WGM12^1<<CS10; // divide by 1
// clear on compare
OCR1A = DIVISOR ; // Output Compare Register
TCNT1 = 0; // Timer start value
second = 0;

TIMSK = 1<<OCIE1A; // beim Vergleichswertes Compare Match
// Interrupt (SIG_OUTPUT_COMPARE1A)
sei();
last_value = gettick() * TFAK ;
for(;;)
{
tsdaytim_calibrated();
PORTB = second; // display second (binary)
}
}

</syntaxhighlight>

== Echtzeituhr mit Uhrenquarz ==

=== RTC mit wenig Stromverbrauch ===

Das vorgestellte Verfahren ist leider nicht direkt anwendbar, wenn man eine RTC mit einem 32,768 KHz Uhrenquarz realisieren möchte. Dieser Weg ist dann notwendig, wenn der Controller [[Ultra low power | batteriebetrieben]] sehr lange laufen soll und durch Verwendung des [[Sleep Mode]] Strom gespart wird.

=== Begrenzung der Auflösung ===

Wo liegt das Problem? Das obige Verfahren nutzt recht hochfrequente Quarze mit 1 MHz und mehr. Wenn man die Frequenz eines Quarzes von 1 MHz = 1.000.000 Hz mit einer [[Auflösung und Genauigkeit| Auflösung]] von 1 Hz angibt, entspricht das einem maximalen Fehler von 1/1.000.000 oder 1ppm (engl. parts per million, millionstel Teil). Das ist sehr wenig. Eine RTC mit einem Fehler von 1ppm hat eine Gangabweichung von 86,4ms pro Tag, oder 2,5s pro Monat. Das ist ein sehr guter Wert. Wenn ich nun aber die Frequenz 32768 Hz mit 1 Hz Auflösung angebe, ist das schlimmstenfalls ein Fehler von 1/32768 = 30,5ppm, was einer Abweichung von 2,5s pro Tag und 75s pro Monat entspricht!

=== Uhrentakt genau messen und digital korrigieren ===

Wie kann man das Problem lösen? Die AVRs können im [[Sleep Mode]] den Uhrenquarz nur am Timer 2 betreiben, welcher ein 8 Bit Timer ist. D.H. ein Überlauf passiert alle 256 Takte, sprich 7,8125ms (=128 Hz). Man kann auch einen Prescaler verwenden, welcher das Problem aber nicht löst.

Wie bereits festgestellt, müssen wir die Frequenz des 32768Hz Uhrenquarzes genauer messen und darstellen. Wir wollen hier annehmen, dass wir die Frequenz auf 0,001Hz = 1mHz (Millihertz) auflösen, ein guter Frequenzzähler kann das problemlos und ist auch so [[Auflösung und Genauigkeit|'''genau''']]. Wir können beispielsweise feststellen, dass ein Quarz mit 32768,423Hz schwingt, das entspricht einem Fehler von

<math>F_r=(\frac{f_{ist}}{f_{soll}} -1 )\cdot 10^6=(\frac{32768,423}{32768} -1 )\cdot 10^6=12,9ppm</math>

Dabei ist zu beachten, daß diese Messung '''nicht''' direkt am Quarz erfolgen darf, auch nicht mit kapazitätsarmen 10:1 Tastköpfen! Denn so ein Quarz wird von kleinsten Kapazitäten im Bereich von weniger als ein pF messbar verstimmt. Darum muss man in so einem Fall den Uhrentakt auf ein anderes IO-Pin ausgeben und dort messen. Beim [[MSP430]] ist das einfach, man kann ACLK auf ein Pin direkt ausgeben. Der [[AVR]] kann das leider nicht. Hier muss man zu einem Trick greifen. Man benutzt die Output Compare Funktion, um mit Timer 2 einen 128 Hz Takt zu erzeugen. Dieser ist fest mit dem Uhrentakt verbunden und kann anstellte dessen gemessen werden, ohne den Quarz zu verstimmen. Die Messung ergibt in diesem Fall eine Frequenz von 128,00165 Hz.

OK, jetzt haben wir den Takt gemessen, wir wissen, daß pro Sekunde 128 Timerüberläufe passieren (Prescaler =1). Wir wissen, dass unser Quarz pro Sekunde um 0,423 Takte zu schnell ist. Wir können aber keine halben Takte mehr oder weniger zählen? Doch! Mit [[Festkommaarithmetik]]! Denn nach 1000s ist unser Quarz um 423 Takte zu weit gelaufen und muss um diese Anzahl zurückgestellt werden. Also könnte man im ersten Ansatz nach 1000 Sekunden den Timer 2 um diesen Betrag korrigieren. Das Problem dabei ist nur, dass der Zähler nur 8 Bit breit ist. Ein Addieren oder Subtrahieren von 423 würde mehrfache Überläufe verursachen, welche programmtechnisch nur schwer zu handhaben wären. Also muss eine etwas bessere Methode her.

=== Bresenham für RTCs ===

Wenn man sich die Idee der [[Festkommaarithmetik]] mal eine Weile durch den Kopf gehen lässt, kommt man vielleicht auf folgende Idee. Der Frequenzfehler beträgt in unserem Beispiel 0,423 Hz, also Takte pro Sekunde. Oder aber 423 Tausendstel Takte pro Sekunde. Nach drei Sekunden sind es schon 1,269 Takte oder 1269 Tausendstel Takte. Moment! '''Einen''' Takt können wir korrigieren, indem wir den Zähler um 1 Takt zurück setzen. Den Restfehler von 269 Tausendstel merken wir uns und akkumulieren weiter. Wenn dann wieder die 1000er Marke überschritten wird machen wir das Gleiche. Analog dazu natürlich auch bei negativem Vorzeichen, sprich wenn der Quarz zu langsam schwingt wird er um einen Takt vorgestellt. É Voilà! Dieses Verfahren ist sehr ähnlich zum [http://de.wikipedia.org/wiki/Bresenham-Algorithmus Bresenham-Algorithmus] zum Zeichnen von Linien auf Computermonitoren.

=== Beispielprogramm ===

Das folgende Beispiel stellt eine RTC mit sehr niedrigem Stromverbrauch zur Verfügung. Laut Datenblatt beträgt die Stromaufnahme nur ca. 6µA bei 3V Versorgungsspannung, besser als einige kommerzielle RTCs! Möglich macht das die Nutzung des Power Save [[Sleep Mode]]s. Die Frequenz kann auf <math>10^{-5}</math> Hz genau abgeglichen werden, was in diesem Fall bei einer Messfrequenz von 128Hz einer Auflösung von 0,078ppm entspricht. Das bedeutet eine Abweichung von 6,7ms pro Tag, 0,2s pro Monat oder 2,46s pro Jahr!

Die Abweichung des Quarzes wird in einer vorzeichenbehafteten 16 Bit Variable in der Einheit <math>10^{-3}</math> Hz gespeichert. D.h. es kann ein Frequenzfehler von +/- 32,768 Hz korrigiert werden, das sind 1000ppm! Normale Quarze haben Abweichungen von max. 100ppm, meist viel weniger. Jede Sekunde wird der Frequenzfehler neu berechnet und in den darauffolgenden 128 Interrupts ggf. mehrfach korrigiert. Wichtig ist dabei, dass die Korrektur wirklich ganz am Anfang der ISR steht, weil hier das Timing wirklich kritisch ist. Denn innerhalb eines Uhrenquarztaktes von ~30µs muss der Timer 2 neu beschrieben werden. Bei 1 MHz RC-Oszillatortakt sind das nur 30 Takte, wovon 6 zum Aufwachen und 4 zum Anspringen der ISR benötigt werden. Dazu kommen noch das Sichern einiger Register am Anfang der ISR, was man im C nicht direkt sieht. Sicherheitshalber sollte man auch einen höheren Takt einstellen, z. B. 2 MHz, dann ist das Timing wesentlich entspannter.

<syntaxhighlight lang="c">
/*
************************************************************************
*
* Stromsparende Echtzeituhr mit 32768Hz Uhrenquarz
*
* ATmega88 mit internem 2 MHz Oszillator + 32,768 kHz Quarz
*
* Fuses bleiben auf Standardeistellungen
* LOW Fuse Byte = 0x62
* HIGH Fuse Byte = 0xDF
* EXT Fuse Byte = 0xF9
*
* LED mit 1K Vorwiderstand an PB5
* Kalibriertaktausgang an PB3
************************************************************************
*/

#define F_CPU 2000000L // Systemtakt in Hz
#define F_CAL 12800000L // gemessener Kalibriertakt in 10^-5 Hz
// Endung L ist wichtig!

#define LED_TOGGLE PORTB ^= (1<<PB5);

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include <util/delay.h>

// EEPROM Daten

int16_t ee_rtc_cal EEMEM = (F_CAL-12800000)*256/100; // Kalibrierung für RTC, Frequenzfehler in 1/1000 Hz

// globale Variablen

// beidseitiger Zugriff durch ISR und Hauptprogramm

volatile uint32_t time; // 24h Zeitstempel, 1s Auflösung
volatile int16_t rtc_cal; // Kalibrierung des 32K Quarzes
volatile uint8_t flag_1s; // Flag für 1s Intervall

void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

int main (void) {

// Clock divider auf /4

CLKPR = 0x80; // update enable
CLKPR = 2; // Prescaler /4

// IO konfigurieren

DDRB = (1<<PB3) | (1<<PB5);
PORTB = ~((1<<PB3) | (1<<PB5)); // Pull ups
PORTC = 0xFF;
PORTD = 0xFF;

// Analogcomparator ausschalten

ACSR = 0x80;

// Timer2 konfigurieren

ASSR = (1<< AS2); // Timer2 asynchron takten
long_delay(1000); // Einschwingzeit des 32kHz Quarzes
TCCR2A = (1<<COM2A1) | (1<<WGM21) | (1<<WGM20); // Fast PWM, non inverted
TCCR2B = 1; // Vorteiler 1 -> 7,8ms Überlaufperiode
OCR2A = 128; // PWM, Tastverhältnis 50%
while((ASSR & (1<< TCR2BUB))); // Warte auf das Ende des Zugriffs
TIFR2 &= ~(1<<TOV2); // Interrupts löschen
TIMSK2 |= (1<<TOIE2); // Timer overflow Interrupt freischalten

// EEPROM Werte auslesen

rtc_cal= eeprom_read_word(&ee_rtc_cal);

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

while((ASSR & (1<< OCR2AUB))); // Warte auf das Ende des Zugriffs
set_sleep_mode(SLEEP_MODE_PWR_SAVE);
sleep_mode(); // in den Schlafmodus wechseln

// hier wachen wir wieder auf, nach Ausführung des 7,8ms Timerinterupt

if (flag_1s) {
flag_1s =0;
LED_TOGGLE // Test
}

}
}

// Timer2 overflow Interrupt

ISR(TIMER2_OVF_vect) {
static uint8_t ticks; // Hilfsvariable für Messintervall
static int16_t time_error; // RTC Fehlerkompensation

// Zeitkritische Dinge, welche am Anfang der ISR stehen müssen!

OCR2A=128; // Dummy-Write zur Sicherung des Timings
// von Timer 2 im asynchronen Modus

// RTC Fehler korrigieren

if (time_error>999) { // RTC zu schnell
TCNT2 = 2; // Zähler einen Schritt zurück setzen (2 Takte Verzögerung!)
time_error -= 1000;
} else if (time_error<-999) { // RTC zu langsam
TCNT2 = 4; // Zähler einen Schritt vor setzen (2 Takte Verzögerung!)
time_error += 1000;
}

// ab hier ist es nicht mehr zeitkritisch

// Echtzeituhr
ticks++; // 1/128tel Sekunde
if (ticks==128) { // Sekundenintervall
time_error += rtc_cal; // RTC Fehler akkumulieren

// 24h Timer
time++;
if (time==86400) time=0; // 24h Überlauf

ticks=0;
flag_1s =1; // setzte Flag für 1s Verarbeitung in main Endlosschleife
}
}
</syntaxhighlight>

=== Weitere Verbesserungen ===

Der Algorithmus ermöglicht eine sehr hochauflösende Kalibrierung der RTC. Allerdings heisst das leider noch lange nicht, daß die RTC dann auch wirklich so genau ist. Denn diese Kalibrierung gilt nur für eine exakte Temperatur! Auch ein Quarz hat eine Temperaturabhängigkeit der Schwingfrequenz. Wenn man nun eine sehr genaue RTC bauen möchte, welche über einen grossen Temperaturbereich genau läuft, muss man periodisch die Temperatur messen und in die Kalibrierung einbeziehen. Einen typischen Temperaturverlauf des Frequenzfehlers zeigt das folgende Bild.

[[bild:rtc_tk.gif|thumb|260px|left|Temperaturgang eines Uhrenquarzes]]
 

Weiterhin kann man natürlich die Kalibrierung ohne erneutes Kompilieren des Quelltextets vornehmen, indem man den Kalibrierwert per [[UART]] oder [[I2C]] an den AVR sendet und im [[Speicher#EEPROM | EEPROM]] speichert.

Kernpunkt der Kalibrierung ist natürlich die Messung der realen Quarzfrequenz. Die oben beschriebene Methode per Tagesschau und 1 Tag warten ist sehr zeitaufwändig und hat eine begrenzte Genauigkeit von ca. 1/2 Sekunde, das entspricht 5,8ppm. Hier muss zwangsläufig ein guter Frequenzzähler her. Da dieser nicht jedem Hobbybastler zur Verfügung steht, muss man sich in Lehrwerkstätten, Universitäten oder Firmen im Elektronikbereich umsehen und nachfragen, ob man einen Frequenzzähler vor Ort kurze Zeit nutzen kann.

Einige GPS-Module bieten auch einen hochgenauen 1PPS (Pulse Per Second) Ausgang an, der sich für den Abgleich gut heranziehen lässt. Auch das Sekunden-Zeichen eines DCF77-Funkuhr-Moduls ist sehr genau und kann als Referenz dienen.

== Links ==

*[http://www.mikrocontroller.net/articles/Uhr Implementierung einer Uhr mit Siebensegmentausgabe auf einem AVR ATTiny2313]
*[http://www.mikrocontroller.net/topic/165249 Uhr mit genauer Sekunde BASCOM]
*[https://www.mikrocontroller.net/topic/298306 Stromsparende und günstige Zeitmessung: ATtiny mit Uhrenquarz getaktet]

[[Category:AVR-Projekte]]
[[Category:Timer und Uhren]]

PLL

2012-10-24T15:27:06Z

Jackfritt: /* Software */

Eine '''PLL''' (engl.: phase locked loop) ist ein Regelkreis in Hardware oder Software, der sich auf einen Eingangstakt synchronisieren kann.

== Hardware ==
PLLs sind als analoge Schaltkreise aufgebaut, die einen Eingangstakt hoch multiplizieren und wieder herunter dividieren und somit als nichtganzzahliger [[Taktteiler]] fungieren. Ferner wird in der Regel die Phase verschoben, dass ein gewünschtes Verhältnis eingestellt wird. Durch einen sog. feedback loop wird erreicht, dass sich die Phase auf dem hohen Frquenzniveau stabil verhält und dem [[Jitter]] des Eingangstaktes nur langsam folgt. Zur Stabilisierung des hochfrequenten Zwischentaktes werden rückgekoppelte Filter benutzt, die genau in dem Frequenzbereich stabil sind. Bei FPGAs sind diese Filter oft parametier- und umschaltbar.

Die Einstellung erfolg voll analog, also nicht zeitdiskret.

== Software ==
Solche Regelkreise lassen sich in SW nachbilden, wenn sich ein [[Microcontroller]] auf einen eingehenden seriellen Takt einstellt bzw ein [[FPGA]] einen Eingangstakt ausmisst und sich in die Mitte stellt, um parallele Daten zu verarbeiten. (siehe [[SERDES]], [[GTP]]).

Die Verarbeitung erfolgt dann voll digital, also diskret mit dem Systemtakt des FPGAs / des Controllers.

== Siehe auch ==
In dieser Tabelle werden die durch ganzzahlige Teiler und Multiplizierer erreichbaren Frequenzverhältnisse aufgelistet:
[[Settings for Multiplier and Divider]]

[[Category:Timer und Uhren]]
[[Category:Grundlagen]]

PLL

2012-10-24T15:26:34Z

Jackfritt: /* Software */

Eine '''PLL''' (engl.: phase locked loop) ist ein Regelkreis in Hardware oder Software, der sich auf einen Eingangstakt synchronisieren kann.

== Hardware ==
PLLs sind als analoge Schaltkreise aufgebaut, die einen Eingangstakt hoch multiplizieren und wieder herunter dividieren und somit als nichtganzzahliger [[Taktteiler]] fungieren. Ferner wird in der Regel die Phase verschoben, dass ein gewünschtes Verhältnis eingestellt wird. Durch einen sog. feedback loop wird erreicht, dass sich die Phase auf dem hohen Frquenzniveau stabil verhält und dem [[Jitter]] des Eingangstaktes nur langsam folgt. Zur Stabilisierung des hochfrequenten Zwischentaktes werden rückgekoppelte Filter benutzt, die genau in dem Frequenzbereich stabil sind. Bei FPGAs sind diese Filter oft parametier- und umschaltbar.

Die Einstellung erfolg voll analog, also nicht zeitdiskret.

== Software ==
Solche Regelkreise lassen sich in SW nachbilden, wenn sich ein [[Microcontroller]] auf einen eingehenden seriellen Takt einstellt bzw ein [[FPGA]] einen Eingangstakt ausmisst und sich in die Mitte stellt, um parallele Daten zu verarbeiten. (siehe [[SERDES]], [[GTP]]).

Die Verarbeitung erfolg dann voll digital, also diskret mit dem Systemtakt des FPGAs / des Controllers.

== Siehe auch ==
In dieser Tabelle werden die durch ganzzahlige Teiler und Multiplizierer erreichbaren Frequenzverhältnisse aufgelistet:
[[Settings for Multiplier and Divider]]

[[Category:Timer und Uhren]]
[[Category:Grundlagen]]

AVR-GCC-Tutorial/Der Watchdog

2012-09-24T08:21:31Z

Jackfritt: /* Watchdog-Anwendungshinweise */

Und hier kommt das ultimative Mittel gegen die Unvollkommenheit von uns
Programmierern, der [[Watchdog]].

So sehr wir uns auch anstrengen, es wird uns kaum je gelingen, das absolut
perfekte und fehlerfreie Programm zu entwickeln.

Der Watchdog kann uns zwar auch nicht zu besseren Programmen verhelfen aber er
kann dafür sorgen, dass unser Programm, wenn es sich wieder mal in's Nirwana
verabschiedet hat, neu gestartet wird, indem ein Reset des Controllers
ausgelöst wird.

== Ein Fallbeispiel ==

Betrachten wir doch einmal folgende Codesequenz:

<c>
uint8_t x;

x = 10;

while (x >= 0)
{
// tu was

x--;
}
</c>

Wenn wir die Schleife mal genau anschauen sollte uns auffallen, dass dieselbe niemals beendet wird. Warum nicht? Ganz einfach, weil eine als '''''unsigned''''' deklarierte Variable niemals kleiner als Null werden kann (der Compiler sollte jedoch eine ensprechende Warnung ausgeben).
Das Programm wird also ewig diese Schleife durchlaufen.
Und hier genau kommt der Watchdog zum Zug.

== Wie funktioniert nun der Watchdog? ==

Der Watchdog enthält einen separaten Timer/Counter, welcher mit einem intern erzeugten Takt von 1 MHz bei 5V Vcc getaktet wird. Einige Controller haben einen eigenen Watchdog Oszillator, z. B. der Tiny2313 mit 128kHz. Nachdem der Watchdog aktiviert und der gewünschte Vorteiler eingestellt wurde, beginnt der Counter von 0 an hochzuzählen.
Wenn nun die je nach Vorteiler eingestellte Anzahl Zyklen erreicht wurde, löst der Watchdog einen Reset aus. Um nun also im Normalbetrieb den Reset zu verhindern, müssen wir den Watchdog regelmäßig wieder neu starten bzw. rücksetzen (Watchdog Reset).
Dies sollte innerhalb unserer Hauptschleife passieren.

Um ein unbeabsichtigtes Ausschalten des Watchdogs zu verhindern, muss ein spezielles Prozedere verwendet werden, um den WD auszuschalten. Es müssen zuerst die beiden Bits WDTOE und WDE in einer einzelnen Operation (also nicht mit sbi) auf 1 gesetzt werden.
Dann muss innerhalb der nächsten 4 Taktzyklen das Bit WDE auf 0 gesetzt werden.

Das Watchdog Control Register:

{| class="wikitable"
|-
| '''WDTCR'''
| '''W'''atch'''D'''og '''T'''imer  '''C'''ontrol '''R'''egister

In diesem Register stellen wir ein, wie wir den Watchdog verwenden möchten.

Das Register ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''-'''|| '''-'''|| '''-'''|| '''WDTOE'''|| '''WDE'''|| '''WDP2'''|| '''WDP1'''|| '''WDP0'''
|-
! R/W
| R|| R|| R|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|}

'''WDTOE''' ('''W'''atch'''d'''og '''T'''urn '''O'''ff '''E'''nable)
:Dieses Bit muss gesetzt sein, wenn das Bit '''WDE''' gelöscht wird, andernfalls wird der Watchdog nicht ausgeschaltet.
:Wenn das Bit einmal gesetzt ist, wird es von der Hardware nach 4 Taktzyklen automatisch wieder gelöscht.

'''WDE''' ('''W'''atch'''d'''og '''E'''nable)
:Wenn dieses Bit gesetzt wird, so wird der Watchdog aktiviert.
:Das Bit kann nur gelöscht werden, solange das Bit '''WDTOE''' auf 1 steht.

'''WDP2''', '''WDP1''', '''WDP0''' ('''W'''atch'''d'''og Timer '''P'''rescaler Bits)
:Diese 3 Bits bestimmen die Anzahl Oszillatorzyklen für den Watchdog, also, wie lange es dauert, bis ein Reset ausgelöst wird:

:{| class="wikitable" style="text-align:center"
|-
! WDP2|| WDP1|| WDP0|| Anzahl Zyklen|| Typ. Timeoutzeit bei Vcc = 3V|| Typ. Timeoutzeit bei Vcc = 5V
|-
| 0 || 0 || 0 || 16K|| 47ms|| 15ms
|-
| 0 || 0 || 1 || 32K|| 94ms|| 30ms
|-
| 0 || 1 || 0 || 64K|| 0.19s|| 60ms
|-
| 0 || 1 || 1 || 128K|| 0.38s|| 0.12s
|-
| 1 || 0 || 0 || 256K|| 0.75s|| 0.24s
|-
| 1 || 0 || 1 || 512K|| 1.5s|| 0.49s
|-
| 1 || 1 || 0 || 1024K|| 3s|| 0.97s
|-
| 1 || 1 || 1 || 2048K|| 6s|| 1.9s
|}

|}

Um den Watchdog mit dem avr-gcc Compiler zu verwenden, muss die Headerdatei ''wdt.h'' (''#include <avr/wdt.h>'') in die Quelldatei eingebunden werden.

Danach können die folgenden Funktionen verwendet werden:

* '''wdt_enable(uint8_t timeout)'''
:Aktiviert den Watchdog und stellt den Vorteiler auf den gewünschten Wert ein bzw. der in timeout übergebene Wert wird in das WDTCR-Register eingetragen. Einige Timeout-Werte sind als Konstanten vordefiniert
:Mögliche Timeoutwerte:
<div align="center">
{| class="wikitable"
! Konstante || Wert || TimeOut
|-
| WDTO_15MS || 0 || 15 ms
|-
| WDTO_30MS || 1 || 30 ms
|-
| WDTO_60MS || 2 || 60 ms
|-
| WDTO_120MS || 3 || 120 ms
|-
| WDTO_250MS || 4 || 250 ms
|-
| WDTO_500MS || 5 || 500 ms
|-
| WDTO_1S || 6 || 1 s
|-
| WDTO_2S || 7 || 2 s
|}
</div>
;wdt_disable():Mit dieser Funktion kann der Watchdog ausgeschaltet werden. Dabei wird das notwendige Prozedere, wie oben beschrieben, automatisch ausgeführt.
;wdt_reset():Dies ist wohl die wichtigste der Watchdog-Funktionen. Sie erzeugt einen Watchdog-Reset, welcher periodisch, und zwar vor Ablauf der Timeoutzeit, ausgeführt werden muss, damit der Watchdog nicht den AVR zurücksetzt.

Selbstverständlich kann das '''WDTCR'''-Register auch mit den uns bereits bekannten Funktionen für den Zugriff auf Register programmiert werden.

== Watchdog-Anwendungshinweise ==

Ob nun der Watchdog als Schutzfunktion überhaupt verwendet werden soll, hängt stark von der Anwendung, der genutzten Peripherie und dem Umfang und der Qualitätssicherung des Codes ab. Will man sicher gehen, dass ein Programm sich nicht in einer Endlosschleife verfängt, ist der Watchdog das geeignete Mittel dies zu verhindern. Weiterhin kann bei geschickter Programmierung der Watchdog dazu genutzt werden, bestimmte Stromsparfunktionen zu implementieren. Bei einigen neueren AVRs (z. B. dem ATTiny13) kann der Watchdog auch direkt als Timer genutzt werden, der den Controller aus einem Schlafmodus aufweckt. Auch dies kann im '''WDTCR'''-Register eingestellt werden. Außerdem bietet der WD die einzige Möglichkeit einen beabsichtigten System-Reset (ein "richtiger Reset", kein "jmp 0x0000") ohne externe Beschaltung auszulösen, was z. B. bei der Implementierung eines Bootloaders nützlich ist. Bei bestimmten Anwendungen kann die Nutzung des WD als "ultimative Deadlock-Sicherung für nicht bedachte Zustände" natürlich immer als zusätzliche Sicherung dienen.

Es besteht die Möglichkeit herauszufinden, ob ein Reset durch den Watchdog ausgelöst wurde (beim ATmega16 z. B. Bit WDRF in MCUCSR). Diese Information sollte auch genutzt werden, falls ein WD-Reset in der Anwendung nicht planmäßig implementiert wurde. Zum Beispiel kann man eine LED an einen freien Pin hängen, die nur bei einem Reset durch den WD aufleuchtet oder aber das "Ereignis WD-Reset" im internen EEPROM des AVR absichern, um die Information später z. B. über UART oder ein Display auszugeben (oder einfach den EEPROM-Inhalt über die ISP/JTAG-Schnittstelle auslesen).

Bei neueren AVR-Typen bleibt der Watchdog auch nach einem Reset durch den Watchdog aktiviert. Wenn ein Programm nach dem Neustart bis zur erstmaligen Rückstellung des Watchdogs länger braucht, als die im Watchdog eingestellte Zeit, sollte man den Watchdog explizit möglichst früh deaktivieren. Ansonsten resetet der Watchdog den Controller immerfort von Neuem. Die frühe Deaktivierung sollte durch eine Funktion erfolgen, die noch vor allen anderen Operationen (insbesondere vor dem mglw. länger andauernden internen Initialisierungen vor dem Sprung zu main()) ausgeführt wird. Näheres zur Implementierung mit avr-gcc/avr-libc findet sich in der Dokumentation der avr-libc (Suchbegriffe: attribut, section, init).

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/index.html Dokumentation der avr-libc] Abschnitt [http://www.nongnu.org/avr-libc/user-manual/group__avr__watchdog.html Modules/Watchdog timer handling]
* [http://www.mikrocontroller.net/topic/77273#642501 Bug in ATtiny2313?]

[[Kategorie:avr-gcc Tutorial]]
[[Kategorie:Timer und Uhren]]

Transformatoren und Spulen

2012-09-20T13:09:22Z

Jackfritt: /* Drosseln */

== Vorwort ==

Dieser Text ist eine Übersetzung des englischen [http://ludens.cl/Electron/Magnet.html Originals]. Es wurde nur dahin erweitert bzw. verändert, dass für alle Formelzeichen die in Deutschland gängigen Buchstaben verwendet wurden. Weiterhin sind alle Formeln bei der ersten Erklärung doppelt geschrieben. Einmal mit Formelzeichen und einmal mit den dazugehörigen Einheiten, welche dann in eckigen Klammern [ ] dargestellt werden.
Dieser Artikel existiert auch als leicht überarbeitetes PDF zum Herunterladen und Drucken: [[Datei:Transformatoren_und_Spulen.pdf]].

== Einleitung ==

Es gibt viele Elektroniker, sowohl Hobbybastler als auch Profis, welche mit dem Elektromagnetismus auf Kriegsfuß stehen. Immer, wenn sie eine [http://de.wikipedia.org/wiki/Spule_%28Elektrotechnik%29 Spule] oder einen [http://de.wikipedia.org/wiki/Transformator Transformator] entwerfen müssen, tut sich ein Abgrund der Verzweiflung vor diesen Leuten auf. Das Schlimmste ist, dass diese armen Opfer meist nicht schuld sind, da die Autoren von Sachbüchern scheinbar eine Verschwörung geschmiedet haben, um diese Dinge möglichst kompliziert zu erklären, so dass sie niemand wirklich verstehen kann. Oder die Autoren haben es selber nicht richtig verstanden?

Gut – das Internet rettet uns. Ich werde die Grundlagen in einfachen, verständlichen Worten erklären. Hier findest du die meisten Informationen, welche benötigt werden, um elektromagnetische Teile zu entwickeln.

==Die Einheiten==

Ich habe eine Bitte. Wer auf dieser Seite landet, soll bitte alle alten und absurden Einheiten, mit denen die Sachbücher vollgestopft sind, vergessen. Am meisten zu nennen Zoll (Inch), Gauß und Oersted. Entferne diese Worte vollständig aus deinem Vokabular. Die haben dort keinen Platz. Sie sind grundlegende Schuldige bei der Verwirrung der Menschen, welche magnetische Entwicklungen machen wollen, sie machen sie irre. Nachdem wir sie nun losgeworden sind, können wir anfangen.

Die erste Einheit, die wir nutzen werden, ist das Weber, geschrieben als Wb. Das ist die offizielle Einheit des magnetischen Flusses <math>\Phi</math>. Wenn man eine Leiterschleife nimmt und 1 V für 1 s anlegt, wird der Fluß in der Schleife sich um 1 Wb geändert haben. Man beachte, dass das immer so ist, egal wie groß oder geformt die Schleife ist und egal, was sich in ihr befindet. Offiziell ist die Definition des Weber so
::<math>\Phi = U \cdot t</math>

::<math>[\Phi] = \text{Wb} = \text{V} \cdot \text{s}</math>

Aber ich bevorzuge die Gleichung in etwas praktischerer Form, bei der die Windungszahl N einer Spule berücksichtigt wird. Das ist eine unserer grundlegenden Wahrheiten.

:<math>(1)\quad \Phi = \frac{U \cdot t}{N}</math>

d.h. die Änderung des magnetischen Flusses (in Weber) ist die Spannung (in Volt) multipliziert mit der Zeit (in Sekunden) geteilt durch die Windungszahl. Das ist eine der mächtigsten und nützlichsten Formeln die wir haben.

Wenn wir ein gewisses Maß an magnetischem Fluß durch eine bestimme Fläche pressen, dann können wir von Flußdichte sprechen. Die Einheit ist Tesla, geschrieben als T, das Formelzeichen ist B. Die Definition ist einfach und offensichtlich.

:<math>(2)\quad B = \frac{\Phi}{A}</math>

::<math>\left[\text{B}\right] = \frac{\text{Wb}}{\text{m}^2}</math>

Man beachte, daß die Sprache von Quadratmetern im Bereich der Elektronik etwas praxisfern klingt, da die meisten Bauteile eher Querschnitte im Bereich von Quadratzentimetern haben. Aber bitte glaub mir daß es praktischer ist, diese "unpraktischen" Dinge zu akzeptieren als ein Dutzend verschiedene Umrechnungsfaktoren zu benutzen! Die Grundeinheiten haben den großen Vorteil, daß absolut keine Umrechnung nötig ist.

Die Grundeigenschaft einer jeden Spule ist [http://de.wikipedia.org/wiki/Induktivit%C3%A4t Induktivität], Formelzeichen L. Sie ist gemessen in Henry, geschrieben als H, definiert durch:

:<math>(3)\quad L = \frac{\Phi}{I}</math>

::<math>[\text{L}] = \frac{\text{Wb}}{\text{A}}</math>

oder in Worten: Ein Henry ist die Induktivität, welche den Strom um 1 Ampere steigen läßt, wenn man für eine Sekunde ein Volt anlegt. Diese Gleichung ist für unser Zwecke auch sehr nützlich. Jetzt können wir anfangen zu spielen. Wir können Gleichung (1) und (3) verbinden und erhalten das Folgende

::<math>L = \frac{\Phi \cdot N}{I}</math>
::<math>[\text{L}] = \frac{\text{Wb}}{\text{A}}</math>

Solche mathematischen Umwandlungen stimmen immer und geben uns die Möglichkeit, unbekannte Größen zu bestimmen.

=== Tabelle aller verwendeten Formelzeichen ===

{| class="wikitable" style="text-align:center"
|-
!Parameter || Formelzeichen || Einheit || Einheit Kurzform
|-
| magnetischer Fluß || <math>\!\,\Phi</math> || Weber || Wb
|-
| magnetische Flußdichte || B || Tesla || T
|-
| Induktivität || L || Henry || H
|-
| Spannung || U || Volt || V
|-
| Strom || I || Ampere || A
|-
| Fläche || A || Quadratmeter || <math>\!\,\text{m}^2</math>
|-
| Zeit || t || Sekunde || s
|-
| Energie || E || Joule || J
|-
| Windungszahl || N || keine || 1
|-
| Frequenz || f || Hertz || Hz
|-
| Länge || l || Meter || m
|-
| Widerstand || R || Ohm || <math>\!\,\Omega</math>
|-
| spezifischer Widerstand || <math>\!\,\rho</math> || Ohm mal Quadratmillimeter pro Meter||<math>\frac{\Omega \cdot \text{mm}^2}{\text{m}}</math>
|-
| Relative Permeabilität || <math>\mu_r</math> || keine || 1
|}

Achtung! Nicht das Formelzeichen der Fläche mit der Einheit des Stroms verwechseln!

Aber jetzt geht's an praktische Dinge.

== Entwicklung von Netztrafos ==

Während fast jeder Elektroniker weiß, daß das Spannungsverhältnis eines Transformators von dem Windungsverhältnis abhängt, taucht die Frage bei vielen Anfängern auf

"Wieviele Windungen pro Volt brauche ich?"

Es ist sehr einfach. Man hat einen Eisenkern, den will man bewickeln. Als erstes mißt man den Querschnitt des Eisens, durch den der magnetische Fluß geht. Sagen wir, der Mittelschenkel eines Transformators ist 2cm breit und der ganze Stapel der laminierten Bleche ist gut zusammengepreßt auf 3cm. Das bringt uns <math>6cm^2</math> bzw. <math>6 * 10^{-4} m^2</math> Querschnitt. Nun müssen wir entscheiden, wieviel Flußdichte wir in unserem Eisen haben wollen. Bei niedrigen Frequenzen wie bei 50Hz Netztrafos ist der begrenzende Faktor die Sättigung des Kerns. Sehr bescheidene Transformatoren sättigen bei 1T, aber typische Werte liegen bei 1,2 oder 1,3T, und ein gutes kornorientiertes Material geht vielleicht bis 1,6 oder sogar 1,7T. Wenn man wirklich nicht weiß welches Material man hat sollte man besser bei 1T auf der sicheren Seite bleiben. Für diese Beispiel nehmen wir an, daß das Eisen für 1,2T gut genug ist.

Durch Anwendung von Formel (2) erhält man den maximal zulässigen Fluß von 0,72mWb. Doch bevor es weitergeht, warte für einen Moment und denk nach!!! Eisen kann in beide Richtungen magnetisiert werden. Die Gesamtänderung des magnetischen Flusses, vom maximal negativem zum maximal positiven kann 1,4mWb betragen! Weiter mit Formel (1) und der Berechnung der Windungen. Nehmen wir an wir reden von Chile oder einem anderen Land mit 220V und 50 Hz.

::<math>1,44~\text{mWb}=\frac{220~\text{V} \cdot 10~\text{ms}}{N}</math>
::<math>N=\frac{220~\text{V} \cdot 10~\text{ms}}{1,44~\text{mWb}}=1528</math>

Das ist die Windungszahl der 220V Primärwicklung.
Einfach, oder? In Wirklichkeit ist das oben Gesagte zu einfach um wahr zu sein. Es gibt einen anderen Faktor, den ich übersprungen habe. Das Obige wäre wahr, wenn die Netzspannung 220V Rechteck wäre. In Wahrheit ist es aber ein Sinus mit 220V Effektivwert, während der Mittelwert etwas anders ist. Und der magnetische Flußaufbau hängt vom Mittelwert ab, '''nicht''' vom Effektivwert! Also müssen wir einen kleinen Korrekturfaktor einführen, welcher durch Mathematik aus der Sinusfunktion abgeleitet werden kann. Anstatt mit der exakten Mathematik hier zu nerven empfehle ich mein Kochbuchrezept. 11% zu unserem Vorteil. Also reichen hier 1376 Windungen. Wo kommen die 10ms her, mag man fragen? Denk noch mal. Die Änderung vom maximal negativen zum maximal positiven Fluß passiert in einer Halbwelle. Und bei 50 Hz sind das 10ms. Wir können das alles in eine einfache, universelle Formel packen, gültig für die Berechnung der Windungen für alle Transformatoren und Spulen mit Sinusspannung.

:<math>(4)\quad N = \frac{U_{RMS}}{4,44 \cdot A \cdot f \cdot B}</math>
::<math>[Windungen] = \frac{[V]}{4,44 \cdot [m^2] \cdot [Hz] \cdot [T]}</math>

Die 4,44 ist kein Umrechnungsfaktor, sondern ergibt sich aus 2 * 2 * 1,11. Eine "2" ist für die Tatsache, daß der magnetische Umschwung doppelt so groß wie der einseitige ist (damit kann man die einfache Sättigungsgrenze einsetzen), die andere "2" entsteht durch die zwei Halbwellen der Sinusschwingung und die 1.11 ist der Umrechnungsfaktor von Effektivwert auf Mittelwert der Sinusspannung.

=== Leistung ===

Eine andere Frage ist meistens, wieviel Leistung ein Trafo bestimmter Größe übertragen kann. Laßt uns das analysieren.

Der magnetische Fluß im Kern hängt ab von der Spannung, welche an die Windungen angelegt wird, der Frequenz, aber '''nicht''' dem Strom, welcher der Transformator liefert! Oh, na gut, ein wenig Abhängigkeit gibt es da schon durch Effekte der realen Welt. Wenn man mehr Strom zieht, fällt durch den Widerstand der Wicklung etwas Spannung ab, wodurch die effektiv an der Wicklung wirksame Spannung reduziert wird und dadurch der magnetische Fluß proportional reduziert wird. Aber der entscheidende Punkt ist, daß der Kern des Trafos '''nicht''' die Ausgangsleistung beeinflußt. Diese Grenze kommt von den Wicklungen und hat zwei Seiten. Eine ist der Spannungsabfall, welche proportional zum Ausgangsstrom ist und an einem Punkt so groß sein wird, daß die Spannung für die Last nicht mehr ausreicht. Die andere ist Erwärmung. Mit steigender Last steigt die Verlustleistung in den Wicklungen quadratisch, und wenn man genügend Leistung lange genug entnimmt werden sie abbrennen.

All das Gesagte macht klar, daß die Leistung eines Transformators abhängt von dem magnetischen Kernquerschnitt (weil mehr Querschnitt weniger Windungen benötigt, damit dickerer Draht verwendet werden kann) und von der Größe des Wickelfensters, das ist der Querschnitt wo sich die Wicklungen befinden. Aber es gibt keine lineare Formel für den Zusammenhang dieser beiden Dinge zur Leistung! Wenn ein Transformator größer wird, wird der Pfad zur Wärmeableitung länger und somit wird das Anwachsen der Leistung geringer als das Produkt der beiden Querschnittsflächen.

Bei all dem Durcheinander werde ich keine Abschätzungen abgeben, dafür aber die reale Berechnung empfehlen. Für einen gegebenen Eisenkern, berechne die benötigten Windungen, beachte den verfügbaren Platz dafür, berechne die Drahtstärke und über den spezifischen Widerstand von Kupfer von <math>0,0178 \Omega \cdot mm^2/m</math> den Gesamtwiderstand der Wicklung. Jetzt kann es helfen zu wissen, daß für kleine Transformatoren ein maximaler Verlust von 10% (5% pro Wicklung) normalerweise akzeptiert wird. Das sollte es ermöglichen, die Leistung zu berechnen, welche sicher aus dem Trafo entnommen werden kann, wenn man genug Wissen für diese Rechnung hat! Man braucht nicht mehr Mathematik als man in der Schule gelernt hat, etwa in der 5. Klasse.

Hey, ich höre euch schreien!!! OK, OK, um die Sache klarer zu machen werde ich ein Beispiel vorrechnen. Nehmen wir den Kern von oben an, mit <math>6cm^2</math> Querschnitt und <math>10cm^2</math> verfügbar für die Wicklungen und daß eine Windung im Mittel 20cm lang ist. Wir verteilen den Wickelraum gleichmäßig auf Primär- und Sekundärseite. Und wir nehmen an, daß nur 40% des Wickelfensters wirklich für Kupfer genutzt werden, der Rest ist Isolation, Luft und verlorener Zwischenraum. Das ist in etwa eine realistische Annahme und beschert uns <math>2cm^2</math> für das Kupfer pro Wicklung. Mit 1376 Windungen hat die Primärwicklung einen Drahtquerschnitt von <math>0,14mm^2</math>, die Gesamtlänge ist 275m. Der Widerstand berechnet sich aus

::<math>R = \frac{\rho \cdot l}{A} = \frac{0,0178 \frac{\Omega \cdot mm^2}{m} \cdot 275m}{0,14mm^2}=35 \Omega</math>

Wir erlauben 5% Verlust in jeder Wicklung. Bei 220V sind das 11V. Nun einfach das ohmsche Gesetz anwenden und der maximal Primärstrom ist 0,32A, multipliziert mit 220V ergibt das ein maximale Eingangsleistung von 70VA für diesen Trafo.

Cool, he? ;-)

Man beachte, daß der Magnetisierungsstrom hier nicht berücksichtigt wird. Du sagst vielleicht, daß selbst wenn es nur 10 oder 20% des Maximalstroms sind, er doch berücksichtigt werden muß! Wenn du das sagst, liegst du falsch. Der Magnetisierungsstrom ist 90 Grad phasenverschoben zum transformierten Laststrom und dadurch, selbst wenn es 20% des Laststrom sind, die Spitze der vektoriellen Summe der beiden sehr nahe beim Laststrom allein liegt. Es lohnt sich nicht den kleinen Unterschied zu beachten.

== Transformatoren für Schaltnetzteile ==

Das vorherige Kapitel kann nahezu vollständig auf Transformatoren höherer Frequenz in Schaltnetzteilen angewendet werden. Es gibt nur ein paar praktische Unterschiede, welche ich jetzt nennen werde.

Bei Frequenzen über ein paar hundert Hertz ist die Sättigung nicht mehr der begrenzende Faktor bei Auswahl der maximalen Flußdichte. Der Grund liegt darin, daß die Verluste des magnetischen Materials so hoch werden, daß die Flußdichte verringert werden muß, um ein akzeptables Maß an Verlusten zu erreichen! Man braucht wirklich das Datenblatt des Herstellers um festzustellen, welche Flußdichte akzeptabel ist. Um eine grobe Vorstellung zu erhalten sollte man bedenken, daß fast immer Ferritmaterial benutzt wird. Ferrit sättigt bei 0,3 bis 0,4T, das ist die absolute Grenze. Für ein typisches Leistungsferrit muß man die Flußdichte bei 25kHz unterhalb 150mT halten, und über 100kHz unter 50mT. Aber viel hängt auch von der Kerngröße ab. Ein größerer Kern muß dabei mit geringerer Flußdichte arbeiten, um eine Überhitzung zu vermeiden.

Normalerweise arbeiten Schaltnetzteile mit Rechtecksignalen, d.h. man muß die 11% zur "Sinuskorrektur" aus der Formel (4) entfernen. Und dann nutzen viele Schaltnetzteile den magnetischen Kern nur einseitig, sprich er wird nur in eine Richtung magnetisiert, was wiederum einen Faktor zwei aus der Formel entfernt. Für den Rest ist die Rechnung die gleiche wie für Netztafos.

Sei nicht überrascht wenn man mit sehr wenigen Windungen endet. Faktisch ist es ziemlich normal, nur 10 oder 20 Windungen an einer 300V Primärwicklung eines großen Schaltnetzteils zu haben.

== HF-Breitbandübertrager==

Vielleicht hast du diese Ferrittrafos schon am Ausgang von Transistor HF-Verstärkern gesehen. Sie sehen aus wie zwei Ferritröhren nebeneinander, mit zwei Kupferröhren hineingesteckt, welche die Primärwicklung mit einer Windung ergeben. Durch diese Kupferröhren sind einige Windungen isolierter Draht gezogen, welche die Sekundärwicklung bilden. Laßt uns so einen Trafo als Beispiel nutzen.

Unser hypothetischer Fall ist ein 100W Push-Pull Verstärker für 1,8-30MHz, gespeist von 13.8V, wie sie zu Millionen täglich von Funkamateuren und allen möglichen kommerziellen Diensten genutzt werden. Jeder Transistor kann seine Seite der Primärwicklung ziemlich nah an Masse ziehen, aber nicht ganz, wegen der Sättigungsspannung. HF-Transistoren sättigen typisch bei 1V, so daß es vernünftig ist anzunehmen, daß der Transistor um 12,8V schalten kann, was 25,6V Spitzenspannung für die Primärwicklung bedeutet, oder ca. 18V RMS. Auf der anderen Seite soll die Sekundärwicklung die HF-Leistung an 50Ω liefern, und 100W an 50Ω sind 70,7V. Deshalb brauchen wir ein Spannungs(Windungs)verhältnis von ca. 3,9. Mit einer Primärwicklung mit nur einer Windung können wir nur ganzzahlige Verhältnisse realisieren, deshalb entscheiden wir uns für vier Sekundärwindungen. Der Effekt ist, daß bei 100W die Transistoren bei 17,7V RMS laufen, oder 25V Spitze. D.h. sie schwingen über 12,5Vder Stromversorgung und lassen dabei 1,3V übrig für sie Sättigung. So weit so gut.

Bei 1,8MHz, unsere niedrigste Frequenz, kann ein typischer Ferrit sicher bis 12mT belastet werden. Wir haben einen schönen, reinen Sinus, also nutzen wir Gleichung (4).

::<math>1 Windung = \frac{17,7V}{4,44 \cdot A \cdot 1,8MHz \cdot 12mT}</math>

umgestellt nach der Fläche

::<math>A = \frac{17,7V}{4,44 \cdot 1 Windung \cdot 1,8MHz \cdot 12mT} = 1,8 \cdot 10^{-4}m^2</math>

Wir brauchen ein Kernquerschnitt von 1,8cm^2. Ein kleinerer Kern würde bei voller Leistung nach einiger Zeit überhitzen, während ein größerer etwas teuerer wäre, aber den Vorteil der spektralen Reinheit mit sich bringt, denn geringere Flußdichte heißt weniger Verzerrung. Aber für die Übung bleiben wir bei 1,8cm^2

Wir müssen noch etwas arbeiten. Wir könnten einen langen, dünnen Ferrit nutzen, oder einen kurzen dicken. Und wir können unter verschiedenen Ferrittypen wählen! Um die Auswahl einzuschränken, schauen wir uns die Induktivitätsforderung an. Der Ansatz ist, daß der Transformator eine Induktivität haben sollte, die hoch genug ist, um wenig Einfluß zu haben, wenn man ihn parallel zur Last schaltet. Pi mal Daumen sollte der induktive Widerstand 10mal höher sein als die Last. Man kann sich aussuchen, ob man das für die Sekundärspule mit 4 Windungen und 50Ω oder die Primärspule mit 1 Windung und 3,1Ω berechnen will, das Ergebnis ist gleich. Ich wähle die Primärseite. Der induktive Widerstand berechnet sich aus.

::<math>X_L=2 \pi \cdot f \cdot L</math>

Das heißt für uns

::<math> L=\frac{X_L}{2 \pi \cdot f}=\frac{31 \Omega}{2 \pi \cdot 1,8 MHz}=2,7 \mu H</math>

Wir brauchen also 2,7µH, um Pi mal Daumen die Anforderung des zehnfachen induktiven Widerstands zu erfüllen. Jetzt muß man sich die Datenblätter der Kerne anschauen und den passenden raussuchen. Für diese Beispiel werde ich den Katalog von Amidon nutzen.

Versuchen wir den ziemlich verbreiteten Typ FT-50-43. Dieser Ringkern hat 0,133cm^2 Querschnitt. Zwei Stapel zu je sieben Stück würden unsere Anforderung bezüglich Flußdichte erfüllen. Der [http://de.wikipedia.org/wiki/AL-Wert#Bestimmung_der_Induktivit.C3.A4t_mittels_AL-Wert AL-Wert] ist 0,52µH/N^2, d.h. 14 Kerne mit einer Wicklung ergeben 7,3µH, ein Mehrfaches unseres benötigten Wertes. Weil aber Breitbandverstärker zu Schwingungen bei niedrigen Frequenzen tendieren, weil dort die Transistoren die größte Verstärkung haben, ist es keine gute Idee mehr Leistung bei niedrigen Frequenzen anzubieten als notwendig! Versuchen wir einen anderen Typ.

Das Material 43 hat eine [http://de.wikipedia.org/wiki/Permeabilit%C3%A4t_%28Magnetismus%29 Permeabilität] von 850. Ein Kern mit den gleichen Abmessungen aber mit einer Permeabilität von nur 330 wäre nett. Aber Amidon macht keine Kerne dieser Größe in einer Permeabilität auch nur annähernd zu dem. Hey, man kann nicht immer umsonst Achterbahn fahren. Die nächstniedrigere Permeabilität, welche von Amidon verfügbar und für unser Projekt brauchbar ist, ist 125, das ist zu wenig. Also bleiben wir beim 43er Material uns sehen was wir machen können.
Es gibt den FT-82-43 aus dem gleichen Material. Er ist viel dicker, hat 0,25cm^2 Querschnitt und einen AL-Wert ziemlich ähnlich zu unserem anderen Kern, 0,55µH/N^2. Zwei Stapel mit je 4 Stück ergeben mehr als genug Querschnitt mit 4,4µH. Das ist eine brauchbare Lösung und bringt uns mehr Platz für die Wicklungen.

Bei höheren Frequenzen ist die Flußdichte geringer und bleibt damit unterhalb der Grenze des Materials. Das Verhältnis zwischen induktivem Widerstand und Lastwiderstand verbessert sich mit steigender Frequenz, aber bei den höchsten Frequenzen könnten parasitäre Kapazitäten starken Einfluß gewinnen, so daß man sie bei der Entwicklung berücksichtigen sollte.

== Energiespeicherung in Magnetkernen ==

Weiß du wieviel Energie eine Spule speichert? Das ist definiert durch die gleiche, alte Formel, die oft in der klassischen Physik auftaucht.

:<math>(5)\quad E = \frac{1}{2} \cdot L \cdot I^2</math>
::<math> [J] = \frac{1}{2} \cdot [H] \cdot [A]^2</math>

Die Einheit der Energie ist Joule (J). Die Induktivität L in Henry (H) sowie der Strom I durch die Spule in Ampere (A). Im Falle eines Transformators muß dieser Strom netto berechnet werden, nachdem man die (transformierten) Primär- und Sekundärströme abgezogen hat unter Berücksichtigung des Windungsverhältnisses. Kurz, das ist der Magnetisierungsstrom.

In den meisten Anwendungen als Transformator ist dieser Strom nicht wirklich gewünscht, aber ein unvermeidbarer Nebeneffekt. Aber es gibt Anwendungen, welche diese Energiespeicherung gut nutzen! Ein sehr wichtiges Beispiel ist der Sperrwandler. Im Prinzip speichert dieser Wandler die Energie von der Primärseite und entlädt sie in die Sekundärseite, oft mit einer Spannung, welche '''nicht''' dem Windungsverhältnis entspricht! Weil Primär- und Sekundärstrom nicht zur gleichen Zeit fließen ist es nicht mehr gültig, daß die Spannungen im gleichen Verhältnis wie die Windungszahlen stehen!

Nehmen wir an, wir entwickeln ein Schaltnetzteil auf dieser Basis. Wir wollen 13,8V Ausgangsspannung, während die Eingangsspannung 110 oder 220V ist. Der logische Ansatz in diesem Fall ist die Nutzung eines Gleichrichters, welcher als Brücke für 220V oder als Verdoppler für 110V geschaltet werden kann. Am Ende haben wir 300VDC in beiden Fällen, der Rest des Schaltnetzteils ist identisch, unabhängig von der Netzspannung. Nehmen wir weiter an, wir haben einen Ferritkern mit 2cm^2 Querschnitt, 12cm magnetische Pfadlänge mit einer Anfangspermeabilität von 2000 und 350mT Sättingsflußdichte. Der Wandler soll bei 100 kHz laufen. Für die Entwicklung brauchen wir noch ein paar Informationen. Den AL-Wert, welcher das Verhältnis zwischen Anzahl der Windungen und Induktivität beschreibt. Wenn er nicht im Datenblatt angegeben ist, kann man ihn aus den physikalischen Abmessungen und Ferriteigenschaften berechnen. Oder man wickelt eine Meßspule und mißt den Wert nach, aber es ist ganz sicher einfacher ihn aus dem Katalog zu bekommen! Nehmen wir an unser Kern hat 6µH/N^2, d.h. 1 Windung ergibt 6µH, 10 Windungen ergeben 600µH und so weiter. Diese angenommenen Werte sind typisch für praktische Fälle.

Um die Spannungsbelastung des Transistors der Primärseite zu verringern, wählen wir 30% der Zykluszeit für die Aufladung des Transformators und 60% für die Entladung. Das erlaubt die Entladung mit der halben Eingangsspannung, d.h. der Schalttransistor sieht nur 450V statt 600V. Das reduziert auch die Stromspitze des sekundären Gleichrichters, während dadurch aber die Stromstärke der Primärseite sowie Spannungsfestigkeit der Sekundärseite erhöht werden, was hier aber kein Problem ist. Die verbleibenden 10% der Schaltzeit sind reserviert für Schaltzeit des Transistors, Totzeitsteuerung des Steuer-ICs etc. Bei 100kHz ist die Ladezeit 3µs, die Entladezeit 6µs. Ein Blick ins Datenblatt sagt uns, daß bei 100kHz und einseitiger Magnetisierung die Flußdichte auf 100mT begrenzt werden sollte. Durch Anwendung von Formel (1) und (2) können wir schnell ausrechnen.

::<math> B = \frac{U \cdot t}{N \cdot A}</math>

::<math> N = \frac{U \cdot t}{B \cdot A} = \frac{300V \cdot 3\mu s}{0,1T \cdot 2 \cdot 10^{-4}m^2}=45</math>

45 Windungen laden diesen Kern auf 0,1T in 3µs, wenn man 300V anlegt. Schön und einfach. Auf der Sekundärseite brauchen wir 13,8V, plus ca. 1V für die Gleichrichterdiode, macht in Summe ca. 15V. Wir können die gleiche Formel einsetzen, nur mit anderen Werten für Spannung und Zeit.

::<math> N = \frac{U \cdot t}{B \cdot A} = \frac{15V \cdot 6\mu s}{0,1T \cdot 2 \cdot 10^{-4}m^2}=4,5</math>

Gefällt dir das? Das Windungsverhältnis ist 10:1, während das Spannungsverhältnis 20:1 ist, weil das Zeitverhältnis 1:2 ist!

Entscheide frei ob du lieber 4 oder 5 Windungen haben willst, das bewirkt nur eine geringfügige Änderung der Lade- und Entladezeiten.

Nun, wieviel Leistung kann dieses Netzteil liefern? Nein, rechne jetzt nicht wie bei einem Netztrafo! Wir haben hier zwei Grenzen. Eine ist die begrenzte Wärmeerzeugung im Transformator, aber es gibt auch eine funktionale Grenze, welche viel wichtiger ist. Unser Schaltnetzteil arbeitet mit Energiespeicherung und bei jedem Zyklus wird nur eine kleine Menge an Energie gespeichert, wodurch die am Ausgang verfügbare Leistung streng begrenzt ist!

Durch unseren oben angenommenen AL-Wert hat unsere Primärwicklung mit 45 Windungen eine Induktivität von 12mH. Über die Definition der Induktivität können wir den Spitzenstrom am Ende des Ladezyklus ausrechnen.

::<math> I = \frac{U \cdot t}{L} = \frac{300V \cdot 3 \mu s}{12mH}= 75mA</math>

Nur 75mA! Sieht nicht viel aus. Berechnen wir die gespeicherte Energie.

::<math>E = \frac{1}{2} \cdot L \cdot I^2= \frac{1}{2} \cdot 12mH \cdot (75mA)^2=34\mu J</math>

Man kann das auch über einen anderen Ansatz berechnen. Da der Strom linear von Null bis 75mA ansteigt, ergibt das im Mittel 37,5mA. Bei 300V und 3µs sind das

::<math>E = U \cdot I \cdot t = 300V \cdot 37,5mA \cdot 3\mu s =34\mu J</math>

Schön wenn die Dinge übereinstimmen...? ;-)

Wenn man bedenkt, daß man bei 100kHz 100.000 dieser kleinen Brocken von Energie pro Sekunde hat, und Leistung schlicht Energie pro Zeit ist, dann kommen wir auf traurige 3,4W für unser glorreiches Netzteil! Sieht nach einer ziemlich schlechten Nutzung für einen Kern dieser Größe aus, nicht wahr? Dieser Kern ist mit "250W typisch" durch den Hersteller gekennzeichnet!!!

Wir müssen herausfinden, wie wir mehr Energie in dem Kern speichern können. Wenn wir die Induktivität erhöhen, wird der Strom kleiner, aber der Strom geht quadratisch in die Energie ein! Keine gute Idee. Es ist besser die Induktivität zu verringern, dadurch steigt der Strom. Da die gespeicherte Energie linear von der Induktivität, aber quadratisch vom Strom abhängt, ist es offensichtlich daß die gespeicherte Energie proportional steigt.

Wie machen wir das? Wir können nicht einfach die Windungszahl verringern! Das bringt uns in Widerspruch mit Gleichung (1), erhöht die Flußdichte mehr als der Ferrit verträgt. Erkennst du das Problem? Wir müssen die Induktivität verringern, ohne die Windungszahl zu verringern, um die Flußdichte zu erhalten.

Es gibt ein einfaches Werkzeug um das zu erreichen. Luft! Man muß nur den Magnetfluß über einen Luftspalt laufen lassen, indem man die beiden Kernhälften geringfügig auseinander zieht. Der Effekt dieses Luftspalts ist die Verringerung der effektiven Permeabilität des Kerns und damit die Reduzierung des AL-Werts, ohne Einfluß auf andere Parameter. Schauen wir was passiert wenn wir einen Luftspalt von insgesamt 1mm einfügen, was durch das Entfernen der Kernhälften um 0,5mm erreicht wird.

Der magnetische Fluß läuft nun 120mm durch Ferrit mit einer Permeabilität von 2000 und 1mm durch Luft mit einer Permeabilität von Eins. 2000mm Ferrit haben den gleichen magnetischen Widerstand wie 1mm Luft! D.h. unser Kern hat nun nur noch eine effektive Permeabilität von 120 anstatt der 2000! Das heißt auch, unser AL-Wert ist nun 0,36µH/N^2 und unsere Primärwicklung mit 45 Windungen hat nun nur noch 720µH. Das wiederum heißt, daß sie in 3µs auf 1,25A aufgeladen wird und 0,56mJ pro Zyklus speichert, woraus 56W Ausgangsleistung entstehen. Das sieht deutlich besser aus als unsere mageren 3,4W ohne Luftspalt! Und all das bei der gleichen Flußdichte im Kern!

Hast du jemals gedacht, daß eine 1mm dicke Luftschicht so schrecklich wichtig sein kann?

Die nächste Frage wäre, ob es eine Grenze für den Luftspalt gibt. Sicher, es gibt zwei Grenzen. Eine ist einfach, wenn man die gespeicherte und übertragene Energie erhöht, erhöht sich auch der Verlust in der Wicklung. An einem Punkt erreicht man die Grenze der thermischen Verluste im Kupfer, genauso wie im Netztransformator. Die Größe des Luftspalts ist meist ein Kompromiß des Entwicklers. Aber es gibt ein anderes Problem. Mit fallender effektiver Permeabilität fällt auch die Kopplung zwischen den Wicklungen. Der Transformator entwickelt ein starkes Streufeld und zeigt starke ungekoppelte Induktivität, welche zur Zerstörung des Leistungstransistors und der Diode führen kann und in den meisten Fällen einen [[Snubber]] notwendig macht. Der Entwickler muß manchmal mit weniger Luftspalt auskommen als was die Wicklungen thermisch verkraften könnten. In jedem Fall kann das Koppelproblem durch richtige Konstruktion des Transformators minimiert werden. Die Primär- und Sekundärwicklung kann gemischt sein, eine bifilare Wicklung ist manchmal möglich. Und es ist oft eine gute Idee, eine dicke Kupferfolie um den kompletten Transformator zu wickeln, welche eine Kurzschlußwindung darstellt. Diese bewirkt, daß der Fluß außerhalb zu Null wird, was bedeutet, daß der Fluß durch den Spulenaufbau gleich dem um die Spule (Seitenschenkel des Kerns) ist und damit die Kopplung verbessert.

In vielen Fällen ist es besser ein Material mit weniger Permeabilität zu verwenden, wie z. B. Eisenpulver. Der Transformator wäre nahezu identisch, wenn wir ihn mit einem Material mit einer Permeabilität von 120 ohne Luftspalt bauen würden. Er hätte eine bessere Kopplung und weniger Streufeld. Andererseits ist der große Vorteil des Luftspalts, daß der Entwickler genau festlegen kann, wieviel effektive Permeabilität er will, ohne einen neuen Kern bestellen zu müssen!

== Drosseln ==

Eines der schlimmsten Dinge, die ich je in einem elektrischen Sachbuch sah, daß man verschiedene Formeln für das Gleichstrom- und Wechselstromverhalten von Spulen angegeben hat. Das ist kompletter Unsinn!!! Es gibt keinen grundlegenden Unterschied zwischen Gleich- und Wechselstrom. Zu jedem Zeitpunkt des Wechselstroms fließt ein "Gleichstrom", und in Gleichstromanwendungen fließt auch ein Wechselstrom, wenigsten beim Ein- und Ausschalten. Deshalb können und sollten wir die gleichen Entwicklungsansätze für Drosseln nutzen.

Schauen wir uns das in der Praxis an. Eine verbreitete Aufgabe ist die Entwicklung einer Drossel mit einer bestimmten Induktivität, welche einen bestimmten Strom aushält ohne in die Sättigung zu gehen. Beachte, daß für Gleichstromanwendungen die Grenze immer durch die Flußdichte gesetzt wird. Erinnerst du dich daran, was ich weiter oben geschrieben habe? Bei hohen Frequenzen ist die Grenze durch die Kernverluste bestimmt, und bei niedrigen durch die Sättigung. Und Gleichstrom ist einfach eine sehr, sehr niedrige Frequenz. ;-)

Nehmen wir an, wir brauchen eine Drossel mit 100µH, die wenigstens 10A aushält, bevor sie in die Sättigung geht. Nehmen wir an, wir nutzen einen Ringkern aus Eisenpulver dafür mit einem Querschnitt von 1cm^2 und einer Pfadlänge von 10cm. Die Permeabilität ist 75 und die Sättigung beginnt bei 0,5T, Der AL-Wert ist 80nH/N^2. Allein aus dem AL-Wert können wir leicht ausrechnen, daß wir 35 Windungen brauchen. Nun, wie können wir den Fluß ausrechnen? Letztendlich wird keine Spannung an die Wicklung angelegt! Denk noch mal nach! Es '''muß''' eine Spannung angelegt worden sein, um den Strom fließen lassen zu können. Wenn wir 1V anlegen, würde es bei 100µH 1ms dauern, ehe 10A erreicht werden, wie man aus Gleichung (3) leicht errechnen kann. Zusammen mit Hilfe von Gleichung (2) können wir die Flußdichte direkt berechnen

::<math>B = \frac{L \cdot I}{A \cdot N}= \frac{100 \mu H \cdot 10A}{1 \cdot 10^{-4}m^2 \cdot 35}=0,28T</math>

welche in einer Flußdichte von 0,28T endet in unserem Kern mit 1cm^2 Querschnitt. Bingo! Diese Drossel könnte fast das Doppelte an Strom leiten, bevor sie in die Sättigung geht. Ein kostenbewußter Entwickler würde die selbe Übung mit dem nächstkleineren Kern durchführen, welcher gerade groß genug ist, um die Drossel mit 100µH bei 10A zu erreichen.

== Kernauswahl ==

Es gibt unzählige Formen und Größen von magnetischen Kernen, und alle sind mit verschiedenen Materialien verfügbar. Es ist eine gute Idee, wenn man wenigsten prinzipiell weiß, was es gibt.

===Materialien===

Das älteste Material für Transformatoren ist '''Eisen''', bekannt als [http://de.wikipedia.org/wiki/Dynamoblech Dynamoblech]. Es ist in dünnen Blechen verfügbar, welche voneinander isoliert werden müssen, um die Wirbelströme gering zu halten. Nur in reinen Gleichstromanwendungen kann man massives Eisen oder unisolierte Bleche nehmen. Transformatoreisen verträgt mindestens 1T bevor es in die Sättigung geht, während 1,2T für die meisten Typen OK ist, 1,5T für einige und 1,7T sind mit den Besten möglich. Die Permeabilität dieses Materials ist ca. 2000 bis 5000. Die Eisenlegierungen mit höherer Sättigungsgrenze haben die geringeren Werte. Die Verluste sind so hoch, daß sie für Frequenzen kurz über 100Hz der begrenzende Faktor sind, anstatt die Sättigung.

'''Eisenstaub''' wird auch genutzt, gemischt mit Epoxidharz und in Magnetkerne geformt. Die Permeabilität hängt vom Eisengehalt der Mischung ab. Da selbst eine kleine Menge Harz deutlich weniger Permeabilität als das Eisen hat, ist die effektive Permeabilität ziemlich niedrig, zwischen 2..100 sind typisch. Für höhere Permeabilitäten wird die Korngröße und Form des Eisen sehr wichtig, da man sehr enge Kornpackungen erzielen kann.
Sättigung setzt eher als bei massivem Eisen ein, weil der Fluß tendenziell aus den Eisenpartikeln gedrängt wird, 0,5T ist ein typischer Wert. Auf jeden Fall ist die Sättigung sehr "weich", es gibt keinen gut definierten Punkt an dem die Sättigung einsetzt. Die Verluste sind niedrig, so daß die Typen mit geringer Permeabilität bis in den HF-Bereich verwendet werden können. Diese Pulverkerne gibt es auch mit anderen Legierungen, wie z. B. Permalloy, in einigen Fällen mit attraktiven Eigenschaften.

'''Ferrite''' sind die vielseitigsten aller verfügbaren Materialien. Während sie bei niedrigeren Werten sättigen, typisch 0,3T, gibt es sie in einer riesigen Breite von Permeabilitäten. Es ist nicht schwer Ferrite mit einer Permeabilität von 20 oder 25.000 zu finden! Der unerfahren Anwender kann den Unterschied von Außen nicht erkennen. Selbst wenn zwei Ferritkerne identisch aussehen, kann der eine 1000fach verschieden zum anderen sein! Also sollte man sicherstellen, daß man '''weiß''', welches Material man hat, bevor man mit der Rechnung anfängt.

In jedem Fall gibt es zwei große Kategorien von Ferriten. Leistungsferrite, genutzt in Schaltnetzteilen etc., sie haben eine Permeabilität von etwa 2000 und geringe Verluste zwischen 20..100kHz. HF-Ferrite mit Permeabilitäten zwischen 100...1000 und geringen Verlusten machen sie brauchbar bis 30MHz. Aber es gibt viele Ferrittypen, die bei weit höheren Frequenzen noch arbeiten und weniger Permeabilität haben. Die Permeabilitäten über 2000 sind reserviert für spezielle Kerne wie Breitbandübertrager, Transductoren und Rauschfilter.

=== Formen ===

Bei den Formen will ich nur einige nennen.

*Ringkerne: Sie sind einfach, billig und leicht zu nutzen, haben geringe Dispersion (wenig Streufeld), gute Selbstabschirmung, können aber keinen Luftspalt enthalten, und 10.000 Windungen auf einen Ringkern wickeln ist nichts was ich gern tun würde.
*Für Speicherdrosseln gibt es Ringkerne mit "verteiltem" Luftspalt. Sie bestehen aus Eisenpulver mit Bindemittel, der Luftspalt verteilt sich über den gesamten Ring
*E-Kerne: Sehr zweckmäßig für die meisten Anwendungen, aber die scharfen Ecken sorgen für mehr Streuverluste
* U-Kerne: Etwas billiger und leicht ineffizienter als E-Kerne (wegen der größeren Pfadlänge)
*Schalenkerne: Vereint die Zweckmäßigkeit des E-Kerns mit der guten Schirmung des Ringkerns (er ist sogar besser!), aber sie kosten mehr. Manche haben einen einstellbaren Luftspalt.
*Stäbe: Nutzbar für Drosseln. Sie haben wirklich große Luftspalte! ;-) Aus genau diesem Grund sind sie unbrauchbar für Transformatoren, die Kopplung wäre zu schlecht.
*E-I Laminate: Das ist so ziemlich die einzige Form, in der man Transformatoreisen kaufen kann.

Ich empfehle man bestellt sich einige Kataloge der Hersteller von magnetischen Materialien und kann so mehr über die anderen 994 Formen lernen . . . Ich empfehle Amidon, Ferroxcube , Ferrinox (Thomson Composants), SiFerrit (Siemens), TDK, Philips, um einige zu nennen. Ich habe meist mit Amidon, Ferrinox und Mülleimerkernen gearbeitet. Die besten Leistungsdaten scheinen von einigen japanischen Ferriten zu kommen.

Diese kleine Abhandlung des Elektromagnetismus kann natürlich nicht als vollständig betrachtet werden, aber ich bevorzuge es, mich auf die wichtigsten Dinge für den Entwickler bzw. Hobbybastler zu konzentrieren. Ich habe alle Dinge übersprungen, welche in meinen Augen weniger wichtig sind für die praktische Anwendung. Ich habe auch viele praktische Hinweise übersprungen, welche zwar nützlich wären, aber diesen Artikel zu sehr in ein Kochbuch verwandelt hätten. Wer Fragen hat soll nicht zögern. Meine Adresse ist auf der ersten [http://ludens.cl/index.html Seite]. Wenn genug Fragen auftauchen, werde ich ein F.A.Q. anfügen.

== Siehe auch ==

*[[Spule]]
*[[Platinen-Induktivität]]
*[[MC34063]]
*[[Spartransformator]]
*[http://www.mikrocontroller.net/topic/181036 Forumsbeitrag]: Kurzschlußwindung bei Ringkernmontage vermeiden
*[http://www.mikrocontroller.net/topic/172992?goto=2586118#2586118 Forumsbeitrag]: galvanisch getrennter DC/DC 5V/17mA mit Ethernettrafo
*[http://www.mikrocontroller.net/topic/172992?goto=2586118#2600216 Forumsbeitrag]: galvanisch getrennter DC/DC 8V/170mA mit Ethernettrafo

== Weblinks ==

* [http://www.amidon.de/ Amidon], Hersteller von Kernen aller Art
* [http://www.ferroxcube.com/ Ferroxcube], Hersteller von Kernen aller Art
* [http://www.micrometals.com/ Micrometals], Hersteller von Kernen aller Art
* [http://www.epcos.de Epcos], ehemals Siemens, Hersteller von Kernen aller Art
* [http://www.ferrite.de ferrite.de], Händler für Kerne aller Art
* [http://www.tridelta-weichferrite.de/ TRIDELTA Weichferrite]
* [http://www.spulen.com/ MM Spulen für Elektronik] - Der Shop rund um die Spule - Drähte, Litzen, Ferrite, Spulen aller Art
* Sehr gute Erklärung der [[media:verlustarme_trafos.pdf | Wirkungsweise eines Trafos (PDF)]], [http://www.emeko.de/ Homepage] des Autors
* [http://www.wolfgang-wippermann.de/koppelfa.htm Koppelfaktor messen], mit Beispielen von realen Spulenanordnungen auf dem Amateurfunkbereich
* [http://www.dos4ever.com/flyback/flyback.html Flyback Converter for dummies], engl. Gute Seite über Sperrwandler und Drosselspulen für Nixieröhren mit einfacher Messung des Sättigungsstroms
* [http://www.joretronik.de/Web_NT_Buch/Kap1/Kapitel1.html Weitere Informationen zu 50-Hz-Trafos und Drosseln]
[[Category:Grundlagen]]
[[Category:Spannungsversorgung und Energiequellen]]

Konstantstromquelle

2012-08-15T14:42:55Z

Jackfritt: /* Beschreibung */

Eine '''Konstantstromquelle''' ist eine Schaltung, deren Zweck es ist, den Strom durch eine Last (z. B. eine [[LED]]) möglichst konstant zu halten, das heißt Änderungen des Stroms durch Variationen der Betriebsspannung und/oder des Lastwiderstands entgegen zu wirken.

Es gibt viele verschiedene Schaltungen, die zu diesem Zweck eingesetzt werden. Sie unterscheiden sich in ihrer Präzision, der minimalen und maximalen Betriebsspannung, und dem Bauteilaufwand. Es sollen hier nur einige besonders einfache Schaltungen vorgestellt werden.
<div class="toclimit-2">
__TOC__
</div>

== Konstantstromquelle mit J-FET ==

=== Beschreibung ===

Eine sehr einfache Konstantstromquelle lässt sich mit einem [[FET|JFET]] realisieren. Der resultierende Strom ist durch den verwendeten FET bestimmt, dabei wird die Eigenschaft genutzt, dass der JFET selbstleitend ist, also bei einer Gate-Source-Spannung von 0V seinen maximal möglichen Strom leitet und bei ansteigender negativer Gate-Source-Spannung U_GS den Drain-Source-Kanal zunehmend abschnürt. Es werden Bauteile angeboten, bei denen die Verbindung zwischen Gate und Source des FET schon intern vorgenommen wurde (Konstantstromdiode, engl. current regulator diode). Diese werden mit engeren Toleranzen gefertigt und erlauben daher eine genauere Definition des Stroms. Außerdem benötigen diese keinen Widerstand in der Sourceleitung und brauchen damit weniger Spannungsabfall zum Betrieb.

=== Vorteile ===

* Großer Betriebsspannungsbereich, nach oben nur durch die maximale Drain-Source-Spannung (V_DS) des FETs und seine maximale Verlustleistung begrenzt.
* Einfachster Aufbau

=== Nachteile ===

* Beeinflussung durch Toleranzen der Fertigungsparameter des FET, typ. +/- 10%
* hohe Sättigungsspannung über dem FET, typ. 1-3V
* nur mäßig temperaturstabil
* selbstleitende FETs für Ströme größer als 30mA sind selten und entsprechend teuer<ref>Es gibt aber einige Depletion-Mode Mosfets mit sehr hohen Sperrspannungen und z.T. auch grösseren Strömen.</ref>

=== Schaltung ===

[[Bild:Konstantstrom.gif]]

=== Weblinks ===
* [http://www.vishay.com/docs/70596/70596.pdf Vishay AN103 - The FET Constant-Current Source/Limiter]
* [http://www.elektronik-kompendium.de/sites/slt/0207011.htm ELKO: FET als Konstantstromquelle]
* [http://www.elektronik-kompendium.de/public/schaerer/curr2pol.htm ELKO: Der Transistor-LED-und der FET-Konstantstromzweipol]
* [http://home.arcor.de/slotracingtechnik/homepage/bd256b.htm Konstantstromquelle für Leuchtdioden mit dem BF256B]
* [[Mosfet-Übersicht#N-Kanal J-FET | Liste von J-FETs]]
* [http://search.datasheetcatalog.net/key/LM334 LM334] betagter, aber guter IC, programmierbare Konstantstromquelle mit 1µA-10mA, 0,8-1V Spannungsabfall

== Konstantstromquelle mit bipolaren Transistoren ==

[[Datei:Ksq.png|thumb|right|231px|UBE-Konstantstromquelle]]
Die auch als UBE-Konstantstromquelle bekannte Stromquelle funktioniert folgendermassen:

Wenn die Spannung über R1 die Basis-Emitter-Flussspannung (verwendeter BC546: 0,6V) von T2 überschreitet, schaltet T2 durch. Dadurch wird die Basis von T1 geräumt und damit gesperrt. Der Strom durch T1 und damit die Spannung über R1 sinkt, wodurch T2 wieder zu sperren beginnt, was T1 wieder leiten lässt. So pendelt diese Schaltung auf die konstante BE-Spannung von ca. 0,6..0,7V – je nach verwendetem Transistor – über R1 ein. Weil R1 konstant ist hat dies einen konstanten Strom durch T2 zur Folge.
R1 berechnet sich daher wie folgt:

:<math>
\begin{align}
R & = \frac{U}{I}\\
R1 & = \frac{U_{BE,T2}}{I_{\text{soll}}} = \frac{0.6\text{V}}{I_{\text{soll}}}
\end{align}
</math>

R2 wird so ausgelegt, dass T1 grundsätzlich sättigen kann. Siehe dazu [[Basiswiderstand]]. Ein guter Richtwert bei 5V Vcc ist 4,7kΩ.

Anstatt '''T2''' kann auch eine Leuchtdiode verwendet werden, dazu den Basisanschluss weglassen. Die LED leuchtet auf, wenn die Stromquelle regelt, und verlischt bei Leerlauf. So lassen sich einfache Konstantstrom-Ladegeräte mit Kontrollanzeige aufbauen.

Eine temperaturstabile Präzisions-Stromquelle entsteht durch Ersetzen von '''T2''' durch einen TL431[http://www.mikrocontroller.net/part/TL431].

=== Vorteile ===
* gut bei niedriger Betriebsspannung, da Schaltung bereits mit kleiner Restspannung von
:: <math>U_{BE,T2}+U_{CE,T1} \approx 0{,}65\,\text{V}+0{,}15\,\text{V}</math>
: am Transistor läuft und die Regelung auch dann erfolgt, wenn nur noch wenige hundert mV zwischen Kollektor und Emitter des Transistors T1 anliegen.
* Ausschließlich "Allerweltsteile", d.h. kann aus Resten aus der Bastelkiste aufgebaut werden

=== Nachteile ===
* nicht temperaturkompensiert. Strom schwankt um
:: <math>\frac{\Delta U_{BE}}{R1} \quad\text{ mit }\quad \Delta U_{BE} \left(\Delta\vartheta\right) \approx -1{,}7 \,\frac{\text{mV}}{\text{K}} \cdot \Delta\vartheta</math>
: Das sind etwa 2,6% pro 10°C

[[Datei:Ksq_2T_sim.svg|thumb|right|300px|Analyse bei steigender Versorgungsspannung]]

=== Weblinks ===
* [http://www.elektronik-kompendium.de/sites/slt/0210253.htm ELKO: Transistor als Konstantstromquelle]
* [http://www.elektronik-kompendium.de/public/schaerer/currled.htm ELKO: Die Transistor-LED-Konstantstromquelle mit ein oder zwei Transistoren und Konstantstromquelle mit Bandgap und Opamp]
* [http://www.elektronik-kompendium.de/public/schaerer/curr2pol.htm ELKO: Der Transistor-LED-und der FET-Konstantstromzweipol]
* [http://www.ferromel.de/tronic_6.htm Verschiedene Konstantstromquellen mit Beschreibung]
* [http://www.elexs.de/kap5_9.htm Konstantstromquelle bei ELEXS]
{{Absatz}}

== Konstantstromquelle mit Operationsverstärker und Transistor ==

[[Datei:Ksq_opv.png|thumb|right|231px|Konstantstromquelle mit OPV und Bipolartransistor]]

Der Strom, welcher konstant gehalten werden soll, wird durch R2 gemessen (Shunt). Der OPV arbeitet als Spannungsfolger und versucht, die Spannung am - Eingang so groß wie am + Eingang zu halten. Ist z.B. die Spanunng am - Eingang etwas kleiner als am + Eingang (Bruchteile von mV!), dann steigt die Ausgangsspannung des OPV um einige mV und erhöht damit die Basis-Emitter-Spannung von T1 und damit den Basisstrom. Dadurch fließt ein höherer Kollerktorstom, welcher wiederum einen höheren Spannungsabfall über R2 verursacht, bis die Spannungen am - und + Eingang des OPV wieder absolut gleich sind (die Offsetspannung wird hier zunächst vernachlässigt). Die Beispielschaltung hier ist bei ausreichender [[Kühlkörper|Kühlung]] für T1 für ca. 1A brauchbar. Der Strom wird mit 0-100mV eingestellt.

Nachteilig ist, dass der Basisstrom von T1 nicht durch die Last fließt, aber durch R2 und somit die Konstantstromregelung verfälscht. Als Gegenmaßnahme nutzt man einen Darlingtontransistor mit sehr hoher Stromverstärkung von 1000 und mehr, was bedeutet, dass der verfälschende Basisstrom nur noch 1 Promille Fehler verursacht. Oder noch besser einen MOSFET, dieser hat Gateströme (Leckströme) im Bereich von unter einem Mikroampere. Dieser Fehler fällt bei 99,9% der Anwendungen nicht ins Gewicht. Prüfen sollte man dabei, dass der MOSFET für [[FET#Linearbetrieb_von_MOSFETs | Linearbetrieb]] geeignet ist, denn das sind viele Hochleistungs-MOSFETs nicht! Hier wird noch ein zusätzlicher Widerstand vor dem Gate des MOSFETs geschaltet, um die hohe Kapazität des Gates vom OPV-Ausgang zu entkoppeln, welche viele OPVs wieder instabil machen würde.

[[Datei:Ksq_opv_mosfet.png|thumb|right|231px|Konstantstromquelle mit OPV und MOSFET]]

Wichtig sind R1 und C1. In vielen Schaltungen im Internet fehlen sie, die Spannung über R2 geht direkt an den - Eingang des OPV. Das ist aber falsch und funktioniert oft nur durch Zufall. Denn R1 und C1 sind wichtig zu Frequenzgangkompensation des OPV. Die Schaltung ist ein Regelkreis und diese sind für notorische Instabilitäten bekannt, d.h. sie schwingen. Durch Rechnung oder Probieren muss der richtige Wert für R1 und C1 gefunden werden, bei der die Stromquelle ausreichend schnell regiert ohne zu schwingen. Testen kann man das u.a. dadurch, dass man einen Sprung auf den Eingang gibt, z.B. mit einem Funktionsgenerator oder einfach einem NE555 als Taktgeber. Dabei beobachtet man die Spannung über R2 mit dem Oszilloskop, ggf. auch am Ausgang des OPV. Hier sieht man wie schnell die Stromquelle reagiert und ob sie schwingt.

=== Vorteile ===
* Größe Ströme können sehr genau und schnell geregelt werden, nur durch T1 und dessen Kühlung begrenzt
* einfacher Aufbau mit Standardkomponenten
* wird oft als Stromregler in elektronischen Lasten benutzt

=== Nachteile ===
* bei sehr hohen Stömen muss man eine Vierdrahtmessung an R2 vornehmen
* hohe Verlustleistung bei kleinen Lastwiderständen und hoher Betriebsspannung (lineare Stromquelle)
* nur Einquadrantenbetrieb möglich

=== Weblinks ===
*Analog by Design Show - Hosted by Bob Pease
** [http://www.youtube.com/watch?v=411f0DvXu18 Konstantstromquellen]
** [http://www.youtube.com/watch?v=2N6cjGS7lUE Präzise 1A Konstantstromquelle ]

== Stromspiegel als Konstantstromquelle ==

[[Datei:Stromspiegel als Konstantstromquelle.svg|miniatur|Stromspiegel mit Widerstand]]
Bei stabiler Versorgungsspannung eignet sich ein Stromspiegel mit Widerstand als Spannungs-Stromwandler und findet sich beispielsweise in älteren Operationsverstärkern wie dem LM741. Das Konzept des Stromspiegels wird an dieser Stelle nicht weiter erläutert.

Die Widerstände R2 und R3 reduzieren die Auswirkungen von Bauteiltoleranzen und der Temperaturdrift. Als grober Richtwert sollte deren Spannungsabfall 0,2 V oder mehr betragen. T1 und T2 sind identische Transistortypen (z.B. BC557B), die idealerweise von einer Bauteilrolle stammen.

Bei geeigneter Wahl von R2 und R3 oder Parallelschaltung von Transistoren wird aus dem Stromspiegel ein Stromvervielfacher. Bei gleichen Transistoren und gleichen Widerständen entsteht ein 1:1 Stromspiegel.

Berechnung:

UB und der gewünschte Strom I sind bekannt

:<math>I_{ref} = \frac{U_B - 0{,}65 V}{R1+R2}</math> (Ausgangsformel)
:<math>R3 = R2</math> (1:1 Stromspiegel)
:<math>I = I_{ref}</math>
:<math>R1 + R2 = R_g = \frac{U_B - 0{,}65 V}{I}</math>
:<math>U_{R2} \approx 0{,}2 V</math>
:<math>R2 = \frac{U_{R2}}{I}=\frac{0{,}2 V}{I}</math>
:<math>R1 = R_g - R2</math>

=== Vorteile ===

* wenige, günstige Bauteile
* sehr einfache Konstruktion
* mäßiger Spannungsabfall (ca. 1V)
* schnell da keine ausgeprägte Rückkopplung vorhanden
* zur Stromsenke umformbar (Überkopf stellen und npn-Typen verwenden)

=== Nachteile ===

* geringer Wirkungsgrad, doppelt wegen Referenzstrom
* mäßig hoher Quellenwiderstand (einfacher Stromspiegel)

== PTAT-Konstantstromquelle ==

:→ siehe [[PTAT-Stromquelle]]

== Konstantstromquelle mit Linearreglern ==

=== Grundschaltung mit LM317 ===

[[Bild:LM317_constant_current.png|thumb|right|280px|Konstantstromquelle mit LM317]]

Eine sehr einfache, günstige und doch genaue Konstantstromquelle kann mittels LM317 aufgebaut werden. Für einen LED Strom von 20mA ist ein R1 von 62,5 Ω erforderlich, praktisch wird man 68Ω wählen. Dabei ist zu beachten, daß die Eingangsspannung ''V''in mindestens 3,5V + ''U''f,LED (Flußspannung der LED) betragen muss.
{{Absatz}}

==== Vorteile ====

* temperaturstabil
* sehr wenige, billige Bauteile

==== Nachteile ====

* Überschwinger beim Einschalten können vorkommen, so dass sensible Lasten zerstört werden können.
* Hohe Spannungsabfall über der Schaltung von mind. 3,5V
* Verlustleistung
:: <math>PV_\text{LM317} = I_\text{out}\cdot (V_\text{in}- U_\text{f,LED} -1,25\,\mathrm V)</math>
* Abhängig vom Gehäuse ist bei höheren Eingangsspannungen ein Kühlkörper am LM317 nötig:
** TO220: 1W
** TO92: 500mW
** SO-8: 600mW
* Bei niedrigen Strömen unter 3.5 mA ungenau (min. Load Current 3.5 mA laut Datenblatt)

==== Schrittweise einstellbare Variante ====

Eine schrittweise voreinstellbare Variante der Grundschaltung wurde 2008 von einem Mitarbeiter von National Semiconductor (Hersteller des LM317) im EDN-Magazin vorgestellt: [http://www.edn.com/contents/images/6566536.pdf Programmable current source requires no power supply]. Dabei ist hier mit ''programmable'' manuell voreinstellbar gemeint, nicht Mikrocontroller-gesteuert. Auch der Teil des Titles ''requires no power supply'' ist irreführend. Die Konstantstromquelle benötigt sehr wohl eine externe Stromversorgung. Die Schaltung benötigt lediglich keine zusätzlichen Hilfsspannungen, entspricht sie doch der oben genannten Grundschaltung.

Mittels dreier 0−9 BCD-Schalter werden geschickt gewählte Widerstände zwischen ADJ und OUT parallel geschaltet. Die Widerstände sind so gewählt, dass der erste Schalter mit seinen zehn Stellungen und Widerständen zwischen 0 mA und 9 mA in 1 mA Schritten zum Gesamtstrom beiträgt, der zweite 0 mA bis 90 mA in 10 mA Schritten und der dritte 0 mA bis 900 mA in 100 mA Schritten.

In dieser Kombination ergibt das eine einstellbare Konstantstromquelle bis 999 mA in 1mA-Schritten bei rund 2% Genauigkeit.

Insgesamt werden

* 45 Widerstände, alle 1%, 1/4 W
** 15 × 1,24 kΩ
** 15 × 124 Ω
** 15 × 12,4 Ω
* ein LM317
* drei 0−9 BCD-Schaltern und
* Gehäusematerial (Gehäuse, Kühlkörper für den LM317, Polklemmen, ...)
benötigt.

Der LM317 wird bei dieser einstellbaren Stromquelle gerade noch innerhalb seiner Spezifikation betrieben - wenn man den Spannungsabfall über ihn gering hält. Im Stromquellen-Beispiel im Datenblatt wird ein maximaler Widerstand von 120 Ω genannt, wohingegen die einstellbare Stromquelle bis zu 1,24 kΩ (nominell 1 mA Ausgangsstrom) und ∞ Ω (offen, nominell 0 mA Ausgangsstrom) verwendet. Mit etwas Geduld kann man aus dem Datenblatt herauslesen, dass 1,24 kΩ gerade noch ausreichen, damit die Regelung des LM317 nicht aussetzt. Dies findet man im Datenblatt in der Graphik ''Minimum Operating Current'' und im Beispiel ''1.2V-20V Regulator with Minimum Program Current''. Mit ∞ Ω ist man definitiv außerhalb des Arbeitsbereiches.

Der Strom bei der Einstellung 000 mA (Widerstand → ∞ Ω, d.h. offen) entspricht nicht 0,0 mA, sondern dem Strom aus dem ADJ-Anschluss für den nicht spezifizierten Fall, dass der LM317 außerhalb seines Arbeitsbereiches betrieben wird. Die im Datenblatt angegebenen 50 µA (typ.), 100 µA (max.) für den Arbeitsbereich können dabei je nach Exemplar überschnitten werden und sind nicht konstant.

Die Messung an neueren Chargen (gefertigt nach 2006) des LM317 diverser Hersteller zeigt, dass auch 1mA nicht sicher erreichbar sind. Es ist vielmehr so, das diese KSQ erst korrekt ab 003 mA bis hoch zu den 999 mA funktioniert. Das heißt konkret, die Einstellungen 000 mA, 001 mA und 002 mA sind nicht mehr stromstabilsiert. Das sollte man beachten, sofern man unbedingt den LM317 bei sehr kleinen Strömen einsetzen möchte.

In der Praxis lohnt es sich besonders bei kleinen Strömen ein Strommessgerät in Reihe zu schalten. Dabei ist Vorsicht bei billigen Multimetern geboten<ref>Bei billigen Multimetern ist auch aus anderen Gründen immer Vorsicht geboten. Siehe [http://gps.sozialnetz.de/global/show_document.asp?id=aaaaaaaaaaaajxn Schwerpunktaktion „Handmultimeter“ der hessischen Marktüberwachung ...]</ref>. Deren niedrige Strommessbereichen sind häufig mit einer 200 mA oder 250 mA Schmelzsicherung abgesichert. Schaltet man die Stromquelle versehentlich über 200 mA, beziehungsweise 250 mA, ist ein Sicherungswechsel fällig.

==== Weblinks ====

* National Semiconductor Datenblatt [http://www.national.com/ds/LM/LM117.pdf LM117/LM317A/LM317 3-Terminal Adjustable Regulator]
* [http://www.roboternetz.de/phpBB2/konstantstrom.php Passenden Widerstand für Konstantstromschaltung mit LM317 berechnen]
* [http://www.lumitronixforum.de/viewtopic.php?t=2611&highlight=lm317 Einfachste Konstantstromquelle mit dem LM317]
* [http://www.umnicom.de/Elektronik/Schaltungssammlung/Strom/Quelle/Stromquelle.html Konstantstromquelle bis 3A mit LM2576]
*[http://www.edn.com/contents/images/6566536.pdf Programmable current source requires no power supply]

==== Preise ====

; LM317:
* TO3: 1,90 €
* TO-220: < 0,25 €
* TO-92: < 0,15 €
* SO-8: < 0,20 €

=== Andere Linearregler ===

Der zuvor beschriebene LM317 eignet sich besonders gut als Stromquelle, da er seine Regelspannung auf der 'high-side' erwartet (1,25 V zwischen Vout und ADJ) und man den Regelpfad als Konstantstrompfad missbrauchen kann (ADJ als Ausgang nach GND, wobei der Strom über den Widerstand und nicht von ADJ geliefert wird)).

==== Mittels Shunt und Messverstärker ====

Die meisten anderen Linearregler messen ihre Regelspannung im Bezug auf GND. Um einen solchen Regler als Konstantstromquelle zu benutzen, kann man einen Stromsensor und einen Messverstärker verwenden. Letzterer steuert dann die Regelung des Linearreglers. Maxim hat in [http://www.maxim-ic.com/app-notes/index.mvp/id/921] ein Beispiel veröffentlicht, das so oder so ähnlich auch mit anderen Linearreglern funktioniert. Maxim misst den Strom auf der Eingangsseite. Vorteil: der Innenwiderstand des Ausgangs des Linearreglers wird durch den Messwiderstand nicht erhöht. Nachteil: Der Eigenverbrauch des Linearreglers wird mitgemessen.

Man kann den Strom auch auf der Ausgangsseite messen.

Das gleiche Prinzip funktioniert für Schaltregler, siehe zum Beispiel [[#LM2576_Step_Down| LM2576 Step Down]] auf dieser Seite.

==== Im Regelpfad - High-Side ====

.-----------.
VCC IN | | OUT
------------o o------>----.
| | I | |
| | | |
| | .-. |
| | | | |
| | | | Rload, R1 |
| | '-' |
| | | |
| | FB | |
| o------<----o |Vout
| | Iref | | |
| | | | |
| | .-. | |
| | | | | Vref |
| | | | R2 | |
'-----o-----' '-' | |
| GND | | |
| | | |
=== === v v
GND GND

Iref <1, R2) zwischen Ausgangsspannung (Vout) und Masse (GND) eingestellt. Der Spannungsteiler wird dabei so dimensioniert, dass eine vorgegebene Spannung Vref (meist 1,25 V) gegen GND an der Anzapfung des Spannungsteilers abfällt, die dann zum Regeleingang des Linearreglers geführt wird. Dabei wird üblicherweise angenommen, dass der Strom Iref in den Regler hinein vernachlässigbar ist.

Dann gilt für den Strom I im Spannungsteiler:

:<math>I = I_{R_1} = I_{R_2} = \frac{V_\text{out}}{R_1 + R_2}</math>

und

:<math>I_{R_2} = \frac{V_\text{ref}}{R_2}</math>

Der Strom I im Spannungsteiler ist somit alleine durch Wahl von R2 bestimmt und unabhängig von R1 bei vorgegebenem R2.

Ersetzt man daher R1 durch die Last, so erzeugt der Linearregler durch Steuerung von Vout einen konstanten Strom

:{|cellpadding="2" style="border:2px solid #ccccff"
|<math>I = \frac{V_\text{ref}}{R_2}</math>
|}

durch die Last.

Dabei muss man die Grenzen des Linearreglers beachten:

Der maximale Strom ''I''max des Reglers darf nicht überschritten werden. Damit die Annahme gilt, dass der Reglerstrom ''I''ref gegenüber dem Strom ''I'' im Spannungsteiler vernachlässigbar ist muss R2 klein gegenüber dem Innenwiderstand des Regeleingangs sein. Dass bedeutet, dass R2 so zu wählen ist, dass immer gilt:

:{|cellpadding="2" style="border:2px solid #ccccff"
|<math>\frac{V_\text{ref}}{I_\text{max}} \leqq R_2 \ll R_\text{in,ref} = \frac{V_\text{ref}}{I_\text{ref}}</math>
|}

Es muss ein Minimalstrom ''I''min durch den Spannungsteiler fließen, damit die Regelung nicht aussetzt. Für diesen Strom gilt gegenüber dem Regelstrom ''I''ref:

:<math>I_\text{min} = \frac{V_\text{out,min}}{R_1 + R_2} \gg I_\text{ref}</math>

Mit

:<math>V_\text{out,min} = V_\text{ref}\,</math>

folgt

:<math>R_1 \ll \frac{V_\text{ref}}{I_\text{ref}} - R_2 = R_\text{in,ref} - R_2</math>

Angenähert:

:{|cellpadding="2" style="border:2px solid #ccccff"
|<math>R_\text{load} \approx R_1 \ll \frac{V_\text{ref}}{I_\text{ref}}</math>
|}

Neben diesen Einschränkungen ist auch zu beachten, dass Die Last R1 auf der High-Side hängt und nicht gegen GND.

== Konstantstromquelle mit Schaltregler ==
Am günstigsten erscheinen Tiefsetzsteller (StepDown-Schaltregler), die mit einer großen Drossel im nichtlückenden Bereich arbeiten. Dann ist der Strom-Ripple (Wechselspannungsanteil) durch die Induktivität und Schaltfrequenz vorgegeben. Ein weiters Glätten des Stromes ist dann gar nicht mehr erforderlich. Es sind nahezu beliebig große Gleichströme bereitstellbar.
=== MC34063, Step Up ===
==== Beschreibung ====
Der Ausgangsstrom beträgt 1,25V/Rx. Die Stromquelle ist '''nicht''' kurzschlussfest. Der Widerstand Rsc dient der Strombegrenzung der einzelnen Strompulse (Schaltregler), was u.a. einen gewissen Überlastschutz für den MC34063 darstellt. Rsc = 0.3/I_max, wobei I_max der maximale Pulsstrom ist und dieser kleiner 1.5A sein muss, weil der IC nicht mehr hergibt. In den meisten Anwendung nimmt man hier 0,22Ω oder mehr.
Das Ganze kann man z. B. für mehrere LEDs in Reihe verwenden um diese mit
5V oder mit 4x 1,5V Batterien zu betreiben. Weiterhin ist zu beachten,
dass die Schaltung nicht leerlauffest ist: Im Leerlauf läuft die
Spannung auf >40V, und dann geht der MC34063 kaputt. Daher sollte man
zur Sicherheit eine Z-Diode parallel zum Ausgang legen, deren Z-Spannung 2..3V über der maximal zu erwartenden Ausgangsspannung liegt, wenn es
passieren kann, dass die Last abgeklemmt wird.
Aufgrund des Elkos am Ausgang ist die Stromquelle recht träge. R1 dient dazu den MC34063 vor dem Stromstoß zu schützen, wenn sich der Elko in eine zu kleine Last entlädt und der Strom kurzzeitig höher als der eingestellte Wert wird.
Die Bauteilwerte sind alle relativ unkritisch. Je nach Betriebsspannung sind die Bauteilwerte etwas anzupassen um den optimalen Wirkungsgrad und die beste Performance zu erzielen. Die eingezeichneten Bauteilwerte sind für geringe Ströme (<100mA) und Eingangsspannungen zwischen 5 und 15V ausgelegt. R2 sollte bei hohen Spannungen vergrößert werden. Wie man die Werte genau berechnet, steht in der Application Note AN920/D.
http://www.onsemi.com/pub/Collateral/AN920-D.PDF

Stromquellen sollten grundsätzlich ''keinen'' Ausgangselko aufweisen! Wie die Schaltregler-Schaltung dann stabil arbeitet muss gesondert herausgefunden werden.

==== Schaltung ====

[[Bild:mc34063_constant_current.gif]]

==== Vorteile ====
* überschüssige Spannung wird nicht verheizt

==== Nachteile ====
* nicht kurzschlussfest
* ohne Z-Diode D2 nicht leerlauffest
* träge beim Einschalten

=== MC34063, Step Down ===
==== Beschreibung ====

Die Step-Down Version funktioniert im Prinzip genauso wie die normale, lineare Konstantstromquelle, nur dass die ungenutzte Spannung nicht sinnlos verheizt wird. Die Eingangsspannung muss mindestens 2V größer sein als die Ausgangsspannung.

Diese Version ist auch ohne die Z-Diode leerlauffest. Kurzschlussfest wird sie durch Rsc. Allerdings entlädt sich der Elko erstmal in die Last, wenn man diese im Betrieb anklemmt. Dadurch kann die Last und der MC34063 beschädigt werden, der Widerstand R1 verhindert aber letzteres.

Bei der Step-Down Version kann man die Elkos etwas kleiner machen, als bei der Step-Up Version, da der Stromfluss durch die Spule in die Last nahezu konstant ist. Wenn man die Spule vergrößert, wird der Strom gleichmäßiger und man kann die Elkos verkleinern. Allerdings wird der Wirkungsgrad aufgrund des höheren Gleichstromwiderstands der Spule schlechter und die Schaltung reagiert langsamer auf Laständerungen. Wie immer ist es also ein Kompromiss zwischen Wirkungsgrad, Kosten und Bauteilgröße.

Konstantstromregler sollten grundsätzlich ''keinen'' Ausgangskondensator haben, weil dieser den gewünschten Regeleffekt zunichte macht. Wie die Rückführung zum Regelverstärker im Schaltregler regelschwingungsfrei gemacht wird muss dann gesondert herausgefunden werden.

==== Schaltung ====

[[Bild:mc34063_constant_current_2.gif]]

==== Vorteile ====
* überschüssige Spannung wird nicht verheizt
* leerlauf
* kurzschlussfest

==== Nachteile ====
* träge beim Ausschalten

Besser ist hier eine [[Konstantstromquelle fuer Power LED]].

=== LM2576 Step Down ===
In einem Thread im Forum (http://www.mikrocontroller.net/topic/97838#new) wird folgende Schaltung genannt: http://www.mikrocontroller.net/attachment/34179/current_source.pdf
Vollständiger Artikel: http://www.ednasia.com/article-621-switchingregularformsconstantcurrentsource-Asia.html

== Konstantstromquelle mit Komparatoren ==
=== Einfache Abwärtswandlung (Vout < Vin)===

==== Beschreibung ====

Diese Schaltung wurde eigentlich für 1W LEDs entworfen, kann aber sicherlich auch anderweitig verwendet werden. Sie ähnelt sehr der eines vollintegrierten Schaltreglers wie MC34063 oder LM2576, ohne jedoch einen solchen zu verwenden.
Der Komparator vergleicht den Spannungsabfall über einem Shunt mit dem einer Referenzspannungsquelle. Ist die Spannung über dem Shunt zu groß, so schaltet er ab und der P-Kanal MOSFET sperrt. Umgekehrt, ist die Spannung über dem Shunt kleiner als die Referenzspannung, leitet der P-FET. Q4 arbeitet als [[Konstantstromquelle]] und sorgt dafür, dass die Gateansteuerung auch bei unterschiedlichen Versorgungsspannungen immer gleich bleibt. Die Referenzspannung von 100mV wird hier einfach durch eine Z-Diode und einen Spannungsteiler eingestellt. Für D4 muss eine schnelle Diode eingesetzt werden, entweder eine Schottkydiode oder schnelle Siliziumdiode! Q2 und Q3 dienen als sehr einfacher [[FET|MOSFET]]-[[Treiber]]. D3 ist nur aus Sicherheitsgründen vorhanden, um die Gate-Source Spannung des MOSFETs zu begrenzen, sie kann ggf. auch weggelassen werden. Über den Anschluß PWM kann ein invertiertes [[PWM]]-Signal zur Dimmung eingespeist werden. Hierbei muss das PWM-Signal im HIGH-Zustand größer als ca. 1V sein, ein einfaches 3,3V oder 5V Logiksignal ist also voll OK.

Der Ausgangsstrom kann durch Veränderung von R1 eingestellt werden. Der Wert kann einfach über die Formel

<math>I_{aus}=\frac{V_{Ref}}{R1} = \frac{100mV}{R1}</math>

bestimmt werden.

==== Schaltung ====

Platinendatei im Eagle-Format gibt es [http://www.mikrocontroller.net/wikifiles/3/38/LED_Stromregler.sch hier].

[[Bild:LED_Stromregler.png|thumb|left|600px| Einfacher Stromregler aus Standardbauteilen]]

[[Bild:LED_Stromregler_brd.png|thumb|left|600px| Beispiel eines Platinenlayouts]]

{{clear}}

==== Vorteile ====

* Kurzschlussfest
* guter Wirkungsgrad bei hohen Eingangsspannungen, Energie wird nicht wie bei einem Linearregler in Wärme umgesetzt
* einfachste Komponenten
* sehr preiswert, max. 2 EUR
* Dimmung per [[PWM]] möglich
* Eingangsspannungsbereich sehr groß, ca. 6-30V
* sehr einfach auch auf anderen Strom einstellbar



== Threads im Forum ==
* [http://www.mikrocontroller.net/topic/75355#new Philosophiestunde Konstantstromquelle]
* [http://www.mikrocontroller.net/topic/71573#new Suche regelbare Konstantstromquelle für ACULED]
* [http://www.mikrocontroller.net/topic/67593#new Konstantstrom für Windmessung]
* [http://www.mikrocontroller.net/topic/66825#new Konstantstromdiode]
* [http://www.mikrocontroller.net/topic/66033#new Konstantstromquelle als IC und einstellbar]
* [http://www.mikrocontroller.net/topic/59467#new Konstantstromquelle für einen Haufen LEDs]
* [http://www.mikrocontroller.net/topic/58036#new Konstantstromquelle]
* [http://www.mikrocontroller.net/topic/61778#new temperaturunabhängige Konstantstromquelle]
* [http://www.mikrocontroller.net/topic/45039#new Konstanter Strom für LED bei 2,5V bis 5,5V]

== Weblinks ==
* [http://de.wikipedia.org/wiki/Konstantstromquelle Konstantstromquelle bei Wikipedia]
* [http://www.dse-faq.elektronik-kompendium.de/dse-faq.htm DSE FAQ]
* [http://www.led-treiber.de Seite zu LED Treibern]
* [http://www.christiankoch.de/archiv/led-ksq/ Diskrete LED-Konstantstromquelle auf Schaltregler-Basis]
* [http://www.national.com/an/AN/AN-1392.pdf NATIONAL Application Note 1392: LM3485 LED Demo Board]
* [http://www.circuit-fantasia.com/circuit_stories/understanding_circuits/current_source/howland_current_source/howland_current_source.htm Howland Current Source]
* [http://www.national.com/an/AN/AN-1515.pdf "A Comprehensive Study of the Howland Current Pump", Application Note von National Semiconductior, engl.]
* [http://www.nomad.ee/micros/mc34063a/index.shtml MC34063A Design Tool (engl.)]
* [http://www.onsemi.com/pub_link/Collateral/MC34063A-D.PDF Datenblatt des MC34063 bei ON Semi]
* [http://www.stromflo.de/dokuwiki/doku.php?id=led_tutorial LED_Tutorial]
* [[Konstantstromquelle fuer Power LED]]
* [http://www.joretronik.de/Web_NT_Buch/Kap3/Kapitel3_2.html weitere Beispiele von Konstantstromquellen]

== Fußnoten ==

<references />

[[Kategorie:Spannungsversorgung und Energiequellen]]

AVR-Tutorial: ADC

2012-06-26T09:32:42Z

Jackfritt: Rechnung falsch da auf 1024 gerechnet wurde.

== Was macht der ADC? ==

Wenn es darum geht, Spannungen zu messen, wird der Analog-/Digital-Wandler (kurz: A/D-Wandler) oder englisch [[ADC | '''A'''nalog '''D'''igital '''C'''onverter]] (ADC) benutzt. Er konvertiert eine elektrische Spannung in eine Digitalzahl. Prinzipiell wird dabei die Messspannung mit einer Referenzspannung verglichen. Die Zahl drückt daher das Verhältnis der Messspannung zu dieser Referenzspannung aus. Sie kann in gewohnter Weise von einem [[Mikrocontroller]] weiterverarbeitet werden.

== Elektronische Grundlagen ==

Die ADC-Versorgungsspannung (AVCC) darf maximal um +/-0,3V von der Versorgung des Digitalteils (VCC) abweichen, jedoch nicht 5,5V überschreiten. Die externe Referenzspannung VREF darf nicht kleiner als die im Datenblatt unter ADC Characteristics als VREFmin angegebene Spannung (z. B. ATmega8: 2V, ATmega644P: 1V) und nicht größer als AVCC sein. Die Spannungen an den Wandlereingängen müssen im Intervall GND ≤ VIN ≤ VREF liegen.

Im Extremfall bedeutet dies: Sei VCC = 5,5V, folgt AVCC_max = VREF_max = VIN_max = 5,5V.

Der Eingangswiderstand des ADC liegt in der Größenordnung von einigen Megaohm, so dass der ADC die Signalquelle praktisch nicht belastet. Desweiteren enthält der Mikrocontroller eine sog. '''Sample&Hold''' Schaltung. Dies ist wichtig, wenn sich während des Wandlungsvorgangs die Eingangsspannung verändert, da die AD-Wandlung eine bestimmte Zeit dauert. Die Sample&Hold-Stufe speichert zum Beginn der Wandlung die anliegende Spannung und hält sie während des Wandlungsvorgangs konstant.

=== Beschaltung des ADC-Eingangs ===

Um den ADC im Folgenden zu testen wird eine einfache Schaltung an den PC0-Pin des ATmega8 angeschlossen. Dies ist der ADC-Kanal 0. Bei anderen AVR-Typen liegt der entsprechende Eingang auf einem andern Pin, hier ist ein Blick ins Datenblatt angesagt.

[[Bild:Tut_ADC_01.gif|framed|center|Testschaltung]]

Der Wert des [[Potentiometer]]s ist Dank des hohen Eingangswiderstandes des ADC ziemlich unkritisch. Es kann jedes Potentiometer von 1kΩ bis 1MΩ benutzt werden.

Wenn andere Messgrößen gemessen werden sollen, so bedient man sich oft und gern des Prinzips des [[Spannungsteiler]]s. Der [http://www.mikrocontroller.net/articles/Kategorie:Sensorik Sensor] ist ein veränderlicher Widerstand. Zusammen mit einem zweiten, konstanten Widerstand bekannter Größe wird ein Spannungsteiler aufgebaut. Aus der Variation der durch den variablen Spannungsteiler entstehenden Spannung kann auf den Messwert zurückgerechnet werden.

Vcc ----------+ Vcc ---------+
| |
--- Sensor,
| | der seinen Widerstand
| | in Abhängigkeit der
--- Messgröße ändert
| |
+------- PC0 +-------- PC0
| |
Sensor, ---
der seinen Widerstand | |
in Abhängigkeit der | |
Messgröße ändert ---
| |
GND ---------+ GND --------+

Die Größe des zweiten Widerstandes im Spannungsteiler richtet sich nach dem Wertebereich, in welchem der Sensor seinen Wert ändert. Als Daumenregel kann man sagen, dass der Widerstand so gross sein sollte wie der Widerstand des Sensors in der Mitte des Messbereichs.

Beispiel: Wenn ein [[Temperatursensor]] seinen Widerstand von 0..100 Grad von 2kΩ auf 5kΩ ändert, sollte der zweite Widerstand eine Grösse von etwa (2+5)/2 = 3,5kΩ haben.

===Referenzspannung AREF===
[[bild:adc_connection.png|thumb|right|300px|Beschaltung von AREF]]
Der ADC benötigt für seine Arbeit eine Referenzspannung. Dabei gibt es 2 Möglichkeiten:
* interne Referenzspannung
* externe Referenzspannung

Bei der Umstellung der Referenzspannung sind Wartezeiten zu beachten, bis die ADC-Hardware einsatzfähig ist (Datenblatt und [http://www.mikrocontroller.net/topic/165513]).

==== Interne Referenzspannung ====

Mittels Konfigurationsregister können beim ATmega8 verschiedene Referenzspannungen eingestellt werden. Dies umfasst die Versorgungsspannung AVcc sowie eine vom AVR bereitgestellte Spannung von 2,56V (bzw. bei den neueren AVRs 1,1V, wie z. B. beim ATtiny13, ATmega48, 88, 168, ...). In beiden Fällen wird an den AREF-Pin des Prozessors ein Kondensator von 100nF als Minimalbeschaltung nach Masse angeschlossen, um die Spannung zu puffern/glätten. Es ist jedoch zu beachten, dass die interne Referenzspannung ca. +/-10% vom Nominalwert abweichen kann, vgl. dazu das Datenblatt Abschnitt ADC Characteristics VINT (z. B. ATmega8: 2,3-2,9V, ATmega324P: 2,33-2,79V bzw. 1,0-1,2V "Values are guidelines only."). Die typische Abweichung der internen Referenzspannung vom Sollwert bei einigen AVR-Controllern wird in [http://www.schramm-software.de/tipps/adc-referenzspannung/ dieser Testschaltung] exemplarisch untersucht.

==== Externe Referenzspannung ====

Wird eine externe Referenz verwendet, so wird diese an AREF angeschlossen. Aber aufgepasst! Wenn eine Referenz in Höhe der Versorgungsspannung benutzt werden soll, so ist es besser, dies über die interne Referenz zu tun. Außer bei anderen Spannungen als 5V bzw. 2,56V gibt es eigentlich keinen Grund, an AREF eine Spannungsquelle anzuschließen. In Standardanwendungen fährt man immer besser, wenn die interne Referenzspannung mit einem Kondensator an AREF benutzt wird. Die 10µH-Spule L1 kann man meist auch durch einen 47Ω-Widerstand ersetzen.

== Ein paar ADC-Grundlagen ==

Der ADC ist ein 10-Bit ADC, d.h. er liefert Messwerte im Bereich 0 bis 1023. Liegt am Eingangskanal 0V an, so liefert der ADC einen Wert von 0. Hat die Spannung am Eingangskanal die Referenzspannung erreicht (stimmt nicht ganz), so liefert der ADC einen Wert von 1023. Unterschreitet oder überschreitet die zu messende Spannung diese Grenzen, so liefert der ADC 0 bzw. 1023. Wird die Auflösung von 10 Bit nicht benötigt, so ist es möglich die Ausgabe durch ein Konfigurationsregister so einzuschränken, dass ein leichter Zugriff auf die 8 höchstwertigen Bits möglich ist.

Wie bei vielen analogen Schaltungen, unterliegt auch der ADC einem Rauschen. Das bedeutet, dass man nicht davon ausgehen sollte, dass der ADC bei konstanter Eingangsspannung auch immer denselben konstanten Wert ausgibt. Ein "Zittern" der niederwertigsten 2 Bits ist durchaus nicht ungewöhnlich. Besonders hervorgehoben werden soll an dieser Stelle nochmals die Qualität der Referenzspannung. Diese Qualität geht in erheblichem Maße in die Qualität der Wandelergebnisse ein. Die Beschaltung von AREF mit einem Kondensator ist die absolut notwendige Mindestbeschaltung, um eine einigermaßen akzeptable Referenzspannung zu erhalten. Reicht dies nicht aus, so kann die Qualität einer Messung durch Oversampling erhöht werden. Dazu werden mehrere Messungen gemacht und deren Mittelwert gebildet.

[[Bild:Tut_ADC_03.gif|right|framed]]
Oft interessiert auch der absolute Spannungspegel nicht. Im Beschaltungsbeispiel oben ist man normalerweise nicht direkt an der am Poti entstehenden Spannung interessiert. Viel mehr ist diese Spannung nur ein notwendiges Übel, um die Stellung des Potis zu bestimmen. In solchen Fällen kann die Poti-Beschaltung wie folgt abgewandelt werden:

Hier wird AREF (bei interner Referenz) als vom µC gelieferte Spannung benutzt und vom Spannungsteiler bearbeitet wieder an den µC zur Messung zurückgegeben. Dies hat den Vorteil, dass der Spannungsteiler automatisch Spannungen bis zur Höhe der Referenzspannung ausgibt, ohne dass eine externe Spannung mit AREF abgeglichen werden müsste. Selbst Schwankungen in AREF wirken sich hier nicht mehr aus, da ja das Verhältnis der Spannungsteilerspannung zu AREF immer konstant bleibt (ratiometrische Messung). Und im Grunde bestimmt der ADC ja nur dieses Verhältnis. Wird diese Variante gewählt, so muss berücksichtigt werden, dass die Ausgangsspannung an AREF nicht allzusehr belastet wird. Der Spannungsteiler muss einen Gesamtwiderstand von deutlich über 10kΩ besitzen. Werte von 100kΩ oder höher sind anzustreben. Verwendet man anstatt AREF AVCC und schaltet auch die Referenzspannung auf AVCC um, ist die Belastung durch den Poti unkritisch, weil hier die Stromversorgung direkt zur Speisung verwendet wird.

Ist hingegen die absolute Spannung von Interesse, so muss man darauf achten, dass ein ADC in [[Digital | digitalen]] Bereichen arbeitet ([[Quantisierung]]). An einem einfacheren Beispiel soll demonstriert werden was damit gemeint ist.

Angenommen der ADC würde nur 5 Stufen auflösen können und AREF sei 5V:

Volt Wert vom ADC

0 -+
| 0
1 -+
| 1
2 -+
| 2
3 -+
| 3
4 -+
| 4
5 -+

Ein ADC Wert von 0 bedeutet also keineswegs, dass die zu messende Spannung exakt den Wert 0 hat. Es bedeutet lediglich, dass die Messspannung irgendwo im Bereich von 0V bis 1V liegt. Sinngemäß bedeutet daher auch das Auftreten des Maximalwertes nicht, dass die Spannung exakt AREF beträgt, sondern lediglich, dass die Messspannung sich irgendwo im Bereich der letzten Stufe (also von 4V bis 5V) bewegt.

== Umrechnung des ADC Wertes in eine Spannung ==

Die Größe eines "Bereiches" bestimmt sich also zu

<math>
Bereichsbreite = \frac {Referenzspannung}{Maximalwert}
</math>

Der Messwert vom ADC rechnet sich dann wie folgt in eine Spannung um:

<math>
Spannung = ADCwert \cdot \frac {Referenzspannung} {Maximalwert}
</math>

Wird der ADC also mit 10 Bit an 5 V betrieben, so lauten die Umrechnungen:

<math>
Bereichsbreite = \frac{5~\text{V}}{1023} = 0,004888~\text{V} = 4,888~\text{mV}
</math>

<math>
Spannung = ADCwert \cdot 4,888~\text{mV}
</math>

Wenn man genau hinsieht stellt man fest, dass sowohl die Referenzspannung als auch der Maximalwert Konstanten sind. D.h. der Quotient aus Referenzspannung und Maximalwert ist konstant. Somit muss nicht immer eine Addition und Division ausgeführt werden, sondern nur eine Multiplikation! Das spart viel Aufwand und Rechenzeit! Dabei kann sinnvollerweise [[Festkommaarithmetik]] zum Einsatz kommen.

== Kalibrierung ==
Hat man eine externe, genaue Referenzspannung zu Hand, dann kann ein Korrekturfaktor berechnet werden, mit dem die Werte des ADCs im Nachinein korrigiert werden können. Dies geschieht normalerweise über eine sogenannte gain offset Korrektur an einer Geraden oder einer Parabel. In erster Näherung kann man auch die interne Referenzspannung um das Inverse des ermittelten Korrekturwertes verstellen, um einen genaueren bereits digitalisierten Wert zu bekommen.

== Die Steuerregister des ADC ==

=== ADMUX ===

{{Byte|ADMUX| REFS1 | REFS0 | ADLAR | | MUX3 | MUX2 | MUX1 | MUX0}}

* Referenzspannung REFS1, REFS0

{| {{Tabelle}}
|- style="background-color:#ffddcc"
!REFS1||REFS0||Referenz
|-
|align="center"|0
|align="center"|0
||externe Referenz
|-
|align="center"|0
|align="center"|1
|interne Referenz: Avcc
|-
|align="center"|1
|align="center"|0
||wird beim Mega8 nicht benutzt
|-
|align="center"|1
|align="center"|1
||interne Referenz: 2.56 Volt
|}

* Ausrichtung ADLAR
<table border="0">
<tr>
<th align="left">ADLAR</th><th align="left"></th>
</tr>
<tr>
<td>0</td><td>Das Ergebnis wird in den Registern ADCH/ADCL rechtsbündig ausgerichtet. Die 8 niederwertigsten Bits des Ergebnisses werden in ADCL abgelegt. Die verbleibenden 2 Bits des Ergebnisses werden im Register ADCH in den Bits 0 und 1 abgelegt.</td>
</tr>
<tr>
<td>1</td><td>Das Ergebnis wird in den Registern ADCH/ADCL linksbündig ausgerichtet. Die 8 höchstwertigen Bits des Ergebnisses werden in ADCH abgelegt. Die verbleibenden 2 niederwertigen Bits werden im Register ADCL in den Bits 6 und 7 abgelegt.</td>
</tr>
</table>

* Kanalwahl MUX3, MUX2, MUX1, MUX0
{| {{Tabelle}}
|- style="background-color:#ffddcc"
!MUX3||MUX2||MUX1||MUX0||Kanal
|-
|align="center"|0
|align="center"|0
|align="center"|0
|align="center"|0
||Kanal 0, Pin PC0
|-
|align="center"|0
|align="center"|0
|align="center"|0
|align="center"|1
||Kanal 1, Pin PC1
|-
|align="center"|0
|align="center"|0
|align="center"|1
|align="center"|0
||Kanal 2, Pin PC2
|-
|align="center"|0
|align="center"|0
|align="center"|1
|align="center"|1
||Kanal 3, Pin PC3
|-
|align="center"|0
|align="center"|1
|align="center"|0
|align="center"|0
||Kanal 4, Pin PC4
|-
|align="center"|0
|align="center"|1
|align="center"|0
|align="center"|1
||Kanal 5, Pin PC5
|-
|align="center"|0
|align="center"|1
|align="center"|1
|align="center"|0
||Kanal 6 (*)
|-
|align="center"|0
|align="center"|1
|align="center"|1
|align="center"|1
||Kanal 7 (*)
|-
|align="center"|1
|align="center"|1
|align="center"|1
|align="center"|0
||1.23V, Vbg
|-
|align="center"|1
|align="center"|1
|align="center"|1
|align="center"|1
||0V, GND
|}

(*) Bei Atmega8 nur in der Gehäusebauform TQFP und MLF verfügbar, nicht in PDIP

===ADCSRA===
{{Byte|ADCSRA| ADEN | ADSC | ADFR | ADIF | ADIE | ADPS2 | ADPS1 | ADPS0}}

;ADEN: "ADC Enable": Mittels ADEN wird der ADC ein und ausgeschaltet. Eine 1 an dieser Bitposition schaltet den ADC ein.
; ADSC: "ADC Start Conversion": Wird eine 1 an diese Bitposition geschrieben, so beginnt der ADC mit der Wandlung. Das Bit bleibt auf 1, solange die Wandlung im Gange ist. Wenn die Wandlung beendet ist, wird dieses Bit von der ADC Hardware wieder auf 0 gesetzt.
; ADFR: "ADC Free Running": Wird eine 1 an ADFR geschrieben, so wird der ADC im Free Running Modus betrieben. Dabei startet der ADC nach dem Abschluss einer Messung automatisch die nächste Messung. Die erste Messung wird ganz normal über das Setzen des ADSC-Bits gestartet.
; ADIF: "ADC Interrupt Flag": Wenn eine Messung abgeschlossen ist, wird das ADIF Bit gesetzt. Ist zusätzlich noch das ADIE Bit gesetzt, so wird ein Interrupt ausgelöst und der entsprechende Interrupt Handler angesprungen.
; ADIE: "ADC Interrupt Enable": Wird eine 1 an ADIE geschrieben, so löst der ADC nach Beendigung einer Messung einen Interrupt aus.
; ADPS2, ADPS1, ADPS0: "ADC Prescaler": Mit dem Prescaler kann die ADC-Frequenz gewählt werden. Laut Datenblatt sollte diese für die optimale Auflösung zwischen 50kHz und 200kHz liegen. Ist die Wandlerfrequenz langsamer eingestellt, kann es passieren dass die eingebaute Sample & Hold Schaltung die Eingangsspannung nicht lange genug konstant halten kann. Ist die Frequenz aber zu schnell eingestellt, dann kann es passieren dass sich die Sample & Hold Schaltung nicht schnell genug an die Eingangsspannung anpassen kann.

{| {{Tabelle}}
|- style="background-color:#ffddcc"
!ADPS2||ADPS1||ADPS0||Vorteiler
|-
|align="center"|0
|align="center"|0
|align="center"|0
|align="center"|2
|-
|align="center"|0
|align="center"|0
|align="center"|1
|align="center"|2
|-
|align="center"|0
|align="center"|1
|align="center"|0
|align="center"|4
|-
|align="center"|0
|align="center"|1
|align="center"|1
|align="center"|8
|-
|align="center"|1
|align="center"|0
|align="center"|0
|align="center"|16
|-
|align="center"|1
|align="center"|0
|align="center"|1
|align="center"|32
|-
|align="center"|1
|align="center"|1
|align="center"|0
|align="center"|64
|-
|align="center"|1
|align="center"|1
|align="center"|1
|align="center"|128
|}

== Die Ergebnisregister ADCL und ADCH ==

Da das Ergebnis des ADC ein 10 Bit Wert ist, passt dieser Wert naturgemäß nicht in ein einzelnes Register, das ja bekanntlich nur 8 Bit breit ist. Daher wird das Ergebnis in 2 Register '''ADCL''' und '''ADCH''' abgelegt. Von den 10 Ergebnisbits sind die niederwertigsten 8 im Register '''ADCL''' abgelegt und die noch fehlenden 2 Bits werden im Register '''ADCH''' an den niederwertigsten Bitpositionen gespeichert.

ADCH ADCL
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | | | | | | | | | | | | | | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
9 8 7 6 5 4 3 2 1 0

Diese Zuordnung kann aber auch geändert werden: Durch setzen des '''ADLAR''' Bits im '''ADMUX''' Register wird die Ausgabe geändert zu:

ADCH ADCL
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | | | | | | | | | | | | | | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
9 8 7 6 5 4 3 2 1 0

Dies ist besonders dann interessant, wenn das ADC Ergebnis als 8 Bit Zahl weiterverarbeitet werden soll. In diesem Fall stehen die 8 höchstwertigen Bits bereits verarbeitungsfertig im Register '''ADCH''' zur Verfügung.

Beim Auslesen der ADC-Register ist zu beachten:
Immer zuerst '''ADCL''' und erst dann '''ADCH''' auslesen. Beim Zugriff auf '''ADCL''' wird das '''ADCH''' Register gegenüber Veränderungen vom '''ADC''' gesperrt. Erst beim nächsten Auslesen des '''ADCH'''-Registers wird diese Sperre wieder aufgehoben. Dadurch ist sichergestellt, daß die Inhalte von '''ADCL''' und '''ADCH''' immer aus demselben Wandlungsergebnis stammen, selbst wenn der '''ADC''' im Hintergrund selbsttätig weiterwandelt. Das '''ADCH''' Register '''muss''' ausgelesen werden!

== Beispiele ==

=== Ausgabe als ADC-Wert ===

Das folgende Programm liest in einer Schleife ständig den ADC aus und verschickt das Ergebnis im Klartext (ASCII) über die [[AVR-Tutorial: UART|UART]]. Zur Verringerung des unvermeidlichen Rauschens werden 256 Messwerte herangezogen und deren Mittelwert als endgültiges Messergebnis gewertet. Dazu werden die einzelnen Messungen in den Registern temp2, temp3, temp4 als 24 Bit Zahl aufaddiert. Die Division durch 256 erfolgt dann ganz einfach dadurch, dass das Register temp2 verworfen wird und die Register temp3 und temp4 als 16 Bit Zahl aufgefasst werden. Eine Besonderheit ist noch, dass je nach dem Wert in temp2 die 16 Bit Zahl in temp3 und temp4 noch aufgerundet wird: Enthält temp2 einen Wert größer als 128, dann wird zur 16 Bit Zahl in temp3/temp4 noch 1 dazu addiert.

In diesem Programm findet man oft die Konstruktion

<avrasm>
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry
</avrasm>

Dabei handelt es sich um einen kleinen Trick. Um eine Konstante zu einem Register direkt addieren zu können bräuchte man einen Befehl ala addi (Add Immediate, Addiere Konstante), den der AVR aber nicht hat. Ebenso gibt es kein adci (Add with carry Immediate, Addiere Konstante mit Carry Flag). Man müsste also erst eine Konstante in ein Register laden und addieren. Das kostet aber Programmspeicher, Rechenzeit und man muss ein Register zusätzlich frei haben.

<avrasm>
; 16 Bit Addition mit Konstante, ohne Cleverness
ldi temp5, low(1)
add temp3, temp5 ; addieren von 1
ldi temp5, high(1)
adc temp3, temp5 ; addieren des Carry
</avrasm>

Hier greift man einfach zu dem Trick, dass eine Addition gleich der Subtraktion der negativen Werts ist. Also "addiere +1" ist gleich "subtrahiere -1". Dafür hat der AVR zwei Befehle, subi (Substract Immediate, Subtrahiere Konstante) und sbci (Substract Immediate with carry, Subtrahiere Konstante mit Carry Flag).

Das folgende Programm ist für den '''ATmega8''' geschrieben. Für moderne Nachfolgetypen wie den ATmega88 muss der Code angepasst werden ([http://www.mikrocontroller.net/topic/204069#2011175], [http://www.atmel.com/dyn/resources/prod_documents/doc2553.pdf AVR094: Replacing ATmega8 by ATmega88 (PDF)]).

<avrasm>
.include "m8def.inc"

.def temp1 = r16 ; allgemeines temp Register, zur kurzfristigen Verwendung
.def temp2 = r17 ; Register für 24 Bit Addition, Lowest Byte
.def temp3 = r18 ; Register für 24 Bit Addition, Middle Byte
.def temp4 = r19 ; Register für 24 Bit Addition, Highest Byte
.def adlow = r20 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def adhigh = r21 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def messungen = r22 ; Schleifenzähler für die Messungen
.def ztausend = r23 ; Zehntausenderstelle des ADC Wertes
.def tausend = r24 ; Tausenderstelle des ADC Wertes
.def hundert = r25 ; Hunderterstelle des ADC Wertes
.def zehner = r26 ; Zehnerstelle des ADC Wertes
.def zeichen = r27 ; Zeichen zur Ausgabe auf den UART

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

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

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

; hier geht das Programm los

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;UART Initalisierung

ldi temp1, LOW(UBRR_VAL) ; Baudrate einstellen
out UBRRL, temp1
ldi temp1, HIGH(UBRR_VAL)
out UBRRH, temp1

sbi UCSRB, TXEN ; TX einschalten

; ADC initialisieren: ADC0, Vcc als Referenz, Single Conversion, Vorteiler 128

ldi temp1, (1<<REFS0) ; Kanal 0, interne Referenzspannung 5V
out ADMUX, temp1
ldi temp1, (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
out ADCSRA, temp1

Main:
clr temp1
clr temp2
clr temp3
clr temp4

ldi messungen, 0 ; 256 Schleifendurchläufe

; neuen ADC-Wert lesen (Schleife - 256 mal)

sample_adc:
sbi ADCSRA, ADSC ; den ADC starten

wait_adc:
sbic ADCSRA, ADSC ; wenn der ADC fertig ist, wird dieses Bit gelöscht
rjmp wait_adc

; ADC einlesen:

in adlow, ADCL ; immer zuerst LOW Byte lesen
in adhigh, ADCH ; danach das mittlerweile gesperrte High Byte

; alle 256 ADC-Werte addieren
; dazu wird mit den Registern temp4, temp3 und temp2 ein
; 24-Bit breites Akkumulationsregister gebildet, in dem
; die 10 Bit Werte aus adhigh, adlow aufsummiert werden

add temp2, adlow ; addieren
adc temp3, adhigh ; addieren über Carry
adc temp4, temp1 ; addieren über Carry, temp1 enthält 0
dec messungen ; Schleifenzähler MINUS 1
brne sample_adc ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen

; Aus den 256 Werten den Mittelwert berechnen
; Mathematisch eine Division durch 256
; Da aber 2^8 = 256 ist ist da einfach durch das weglassen des niederwertigsten Bytes
; erreicht werden
;
; allerdings wird der Wert noch gerundet

cpi temp2,128 ; "Kommastelle" kleiner als 128 ?
brlo no_round ; ist kleiner ==> Sprung

; Aufrunden
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry

no_round:

; Ergebnis nach adlow und adhigh kopieren
; damit die temp Register frei werden

mov adlow, temp3
mov adhigh, temp4

;in ASCII umwandeln
; Division durch mehrfache Subtraktion

ldi ztausend, '0'-1 ; Ziffernzähler direkt als ASCII Code
; bzgl. '0'-1 siehe http://www.mikrocontroller.net/topic/198681
Z_ztausend:
inc ztausend
subi adlow, low(10000) ; -10,000
sbci adhigh, high(10000) ; 16 Bit
brcc Z_ztausend

subi adlow, low(-10000) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-10000); +10,000

ldi tausend, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_tausend:
inc tausend
subi adlow, low(1000) ; -1,000
sbci adhigh, high(1000) ; 16 Bit
brcc Z_tausend

subi adlow, low(-1000) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-1000) ; +1,000

ldi hundert, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_hundert:
inc hundert
subi adlow, low(100) ; -100
sbci adhigh, high(100) ; 16 Bit
brcc Z_hundert

subi adlow, low(-100) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-100) ; +100

ldi zehner, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_zehner:
inc zehner
subi adlow, low(10) ; -10
sbci adhigh, high(10) ; 16 Bit
brcc Z_zehner

subi adlow, low(-10) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-10) ; +10

subi adlow, -'0' ; adlow enthält die Einer, Umwandlung in ASCII

;an UART Senden

mov zeichen, ztausend ; Zehntausender Stelle
rcall transmit
mov zeichen, tausend ; Tausender Stelle ausgeben
rcall transmit
mov zeichen, hundert ; Hunderter Stelle ausgeben
rcall transmit
mov zeichen, zehner ; Zehner Stelle ausgeben
rcall transmit
mov zeichen, adlow ; Einer Stelle ausgeben
rcall transmit
ldi zeichen, 13 ; CR, Carrige Return (Wagenrücklauf)
rcall transmit
ldi zeichen, 10 ; LF, Line Feed (Neue Zeile)
rcall transmit

rjmp Main

transmit:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp transmit
out UDR, zeichen ; und Zeichen ausgeben
ret
</avrasm>

=== Ausgabe als Spannungswert ===

Das zweite Beispiel ist schon um einiges größer. Hier wird der gemittelte ADC-Wert in eine Spannung umgerechnet. Dazu wird [[Festkommaarithmetik]] verwendet. Die Daten sind in diesem Fall

* Referenzspannung : 5V
* alte Auflösung : 5V / 1024 = 4,8828125mV
* neue Auflösung : 1mV

-> Faktor = 4,8828125mV / 1mV = 4,8828125

Der Faktor wird dreimal mit 10 multipliziert und das Ergebnis auf 4883 gerundet. Die neue Auflösung wird dreimal durch 10 dividiert und beträgt 1μV. Der relative Fehler beträgt

:<math> F_r = \frac {4883}{4882,8125}-1 = 0,00384% = \frac {1}{26042}</math>

Diese Fehler ist absolut vernachlässigbar. Nach der Multiplikation des ADC-Wertes mit 4883 liegt die gemessene Spannung in der Einheit μV vor. Vorsicht! Das ist '''nicht''' die reale [[Auflösung und Genauigkeit]], nur rein mathematisch bedingt. Für maximale Genauigkeit sollte man die Versorgungsspannung AVCC, welche hier gleichzeitig als Referenzspannung dient, exakt messen, die Rechnung nachvollziehen und den Wert im Quelltext eintragen. Damit führt man eine einfach Einpunktkalibrierung durch.

Da das Programm schon um einiges größer und komplexer ist, wurde es im Vergleich zur Vorgängerversion geändert. Die Multiplikation sowie die Umwandung der Zahl in einen ASCII-String sind als Unterprogramme geschrieben, dadurch erhält man wesentlich mehr Überblick im Hauptprogramm und die Wiederverwendung in anderen Programmen vereinfacht sich. Ausserdem wird der String im RAM gespeichert und nicht mehr in CPU-Registern. Die Berechung der einzelnen Ziffern erfolgt über ein Schleife, das ist kompakter und übersichtlicher.

<avrasm>
.include "m8def.inc"

.def z0 = r1 ; Zahl für Integer -> ASCII Umwandlung
.def z1 = r2
.def z2 = r3
.def z3 = r4
.def temp1 = r16 ; allgemeines Register, zur kurzfristigen Verwendung
.def temp2 = r17 ; Register für 24 Bit Addition, niederwertigstes Byte (LSB)
.def temp3 = r18 ; Register für 24 Bit Addition, mittlerers Byte
.def temp4 = r19 ; Register für 24 Bit Addition, höchstwertigstes Byte (MSB)
.def adlow = r20 ; Ergebnis vom ADC-Mittelwert der 256 Messungen
.def adhigh = r21 ; Ergebnis vom ADC-Mittelwert der 256 Messungen
.def messungen = r22 ; Schleifenzähler für die Messungen
.def zeichen = r23 ; Zeichen zur Ausgabe auf den UART
.def temp5 = r24
.def temp6 = r25

; Faktor für Umrechung des ADC-Wertes in Spannung
; = (Referenzspannung / 1024 ) * 100000
; = 5V / 1024 * 1.000.000
.equ Faktor = 4883

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

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

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

; RAM
.dseg
.org 0x60
Puffer: .byte 10

; hier geht das Programm los
.cseg
.org 0

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;UART Initalisierung

ldi temp1, LOW(UBRR_VAL) ; Baudrate einstellen
out UBRRL, temp1
ldi temp1, HIGH(UBRR_VAL)
out UBRRH, temp1

sbi UCSRB, TXEN ; TX einschalten

; ADC initialisieren: Single Conversion, Vorteiler 128
; Kanal 0, interne Referenzspannung AVCC

ldi temp1, (1<<REFS0)
out ADMUX, temp1
ldi temp1, (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
out ADCSRA, temp1

Hauptschleife:
clr temp1
clr temp2
clr temp3
clr temp4

ldi messungen, 0 ; 256 Schleifendurchläufe

; neuen ADC-Wert lesen (Schleife - 256 mal)

adc_messung:
sbi ADCSRA, ADSC ; den ADC starten

adc_warten:
sbic ADCSRA, ADSC ; wenn der ADC fertig ist, wird dieses Bit gelöscht
rjmp adc_warten

; ADC einlesen:

in adlow, ADCL ; immer zuerst LOW Byte lesen
in adhigh, ADCH ; danach das mittlerweile gesperrte High Byte

; alle 256 ADC-Werte addieren
; dazu wird mit den Registern temp4, temp3 und temp2 ein
; 24-Bit breites Akkumulationsregister gebildet, in dem
; die 10 Bit Werte aus adhigh, adlow aufsummiert werden

add temp2, adlow ; addieren
adc temp3, adhigh ; addieren über Carry
adc temp4, temp1 ; addieren über Carry, temp1 enthält 0
dec messungen ; Schleifenzähler MINUS 1
brne adc_messung ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen

; Aus den 256 Werten den Mittelwert berechnen
; Bei 256 Werten ist das ganz einfach: Das niederwertigste Byte
; (im Register temp2) fällt einfach weg
;
; allerdings wird der Wert noch gerundet

cpi temp2,128 ; "Kommastelle" kleiner als 128 ?
brlo nicht_runden ; ist kleiner ==> Sprung

; Aufrunden
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry

nicht_runden:

; Ergebnis nach adlow und adhigh kopieren
; damit die temp Register frei werden

mov adlow, temp3
mov adhigh, temp4

; in Spannung umrechnen

ldi temp5,low(Faktor)
ldi temp6,high(Faktor)
rcall mul_16x16

; in ASCII umwandeln

ldi XL, low(Puffer)
ldi XH, high(Puffer)
rcall Int_to_ASCII

;an UART Senden

ldi ZL, low(Puffer+3)
ldi ZH, high(Puffer+3)
ldi temp1, 1
rcall sende_zeichen ; eine Vorkommastelle ausgeben

ldi zeichen, ',' ; Komma ausgeben
rcall sende_einzelzeichen

ldi temp1, 3 ; Drei Nachkommastellen ausgeben
rcall sende_zeichen

ldi zeichen, 'V' ; Volt Zeichen ausgeben
rcall sende_einzelzeichen

ldi zeichen, 10 ; New Line Steuerzeichen
rcall sende_einzelzeichen

ldi zeichen, 13 ; Carrige Return Steuerzeichen
rcall sende_einzelzeichen

rjmp Hauptschleife

; Ende des Hauptprogramms

; Unterprogramme

; ein Zeichen per UART senden

sende_einzelzeichen:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp sende_einzelzeichen
out UDR, zeichen ; und Zeichen ausgeben
ret

; mehrere Zeichen ausgeben, welche durch Z adressiert werden
; Anzahl in temp1

sende_zeichen:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp sende_zeichen
ld zeichen, Z+ ; Zeichen laden
out UDR, zeichen ; und Zeichen ausgeben
dec temp1
brne sende_zeichen
ret

; 32 Bit Zahl in ASCII umwandeln
; Zahl liegt in temp1..4
; Ergebnis ist ein 10stelliger ASCII String, welcher im SRAM abgelegt wird
; Adressierung über X Pointer
; mehrfache Subtraktion wird als Ersatz für eine Division durchgeführt.

Int_to_ASCII:

push ZL ; Register sichern
push ZH
push temp5
push temp6

ldi ZL,low(Tabelle*2) ; Zeiger auf Tabelle
ldi ZH,high(Tabelle*2)
ldi temp5, 10 ; Schleifenzähler

Int_to_ASCII_schleife:
ldi temp6, -1+'0' ; Ziffernzähler zählt direkt im ASCII Code
lpm z0,Z+ ; Nächste Zahl laden
lpm z1,Z+
lpm z2,Z+
lpm z3,Z+

Int_to_ASCII_ziffer:
inc temp6 ; Ziffer erhöhen
sub temp1, z0 ; Zahl subrahieren
sbc temp2, z1 ; 32 Bit
sbc temp3, z2
sbc temp4, z3
brge Int_to_ASCII_ziffer ; noch kein Unterlauf, nochmal

add temp1, z0 ; Unterlauf, eimal wieder addieren
adc temp2, z1 ; 32 Bit
adc temp3, z2
adc temp4, z3
st X+,temp6 ; Ziffer speichern
dec temp5
brne Int_to_ASCII_schleife ; noch eine Ziffer?

pop temp6
pop temp5
pop ZH
pop ZL ; Register wieder herstellen
ret

; Tabelle mit Zahlen für die Berechung der Ziffern
; 1 Milliarde bis 1
Tabelle:
.dd 1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1

; 16 Bit Wert in Spannung umrechnen
;
; = 16Bitx16Bit=32 Bit Multiplikation
; = vier 8x8 Bit Multiplikationen
;
; adlow/adhigh * temp5/temp6

mul_16x16:
push zeichen
clr temp1 ; 32 Bit Akku löschen
clr temp2
clr temp3
clr temp4
clr zeichen ; Null, für Carry-Addition

mul adlow, temp5 ; erste Multiplikation
add temp1, r0 ; und akkumulieren
adc temp2, r1

mul adhigh, temp5 ; zweite Multiplikation
add temp2, r0 ; und gewichtet akkumlieren
adc temp3, r1

mul adlow, temp6 ; dritte Multiplikation
add temp2, r0 ; und gewichtet akkumlieren
adc temp3, r1
adc temp4, zeichen ; carry addieren

mul adhigh, temp6 ; vierte Multiplikation
add temp3, r0 ; und gewichtet akkumlieren
adc temp4, r1

pop zeichen
ret
</avrasm>

Für alle, die es besonders eilig haben gibt es hier eine geschwindigkeitsoptimierte Version der Integer in ASCII Umwandlung. Zunächst wird keine Schleife verwendet sondern alle Stufen der Schleife direkt hingeschrieben. Das braucht zwar mehr Programmspeicher, ist aber schneller. Ausserdem wird abwechselnd subtrahiert und addiert, dadurch entfällt das immer wieder notwendige addieren nach dem Unterlauf. Zu guter Letzt werden die Berechnungen nur mit der minimal notwenigen Wortbreite durchgeführt. Am Anfang mit 32 Bit, dann nur noch mit 16 bzw. 8 Bit.

<avrasm>
; 32 Bit Zahl in ASCII umwandeln
; geschwindigkeitsoptimierte Version
; Zahl liegt in temp1..4
; Ergebnis ist ein 10stelliger ASCII String, welcher im SRAM abgelegt wird
; Adressierung über X Pointer

Int_to_ASCII:
ldi temp5, -1 + '0'
_a1ser:
inc temp5
subi temp1,BYTE1(1000000000) ; - 1.000.000.000
sbci temp2,BYTE2(1000000000)
sbci temp3,BYTE3(1000000000)
sbci temp4,BYTE4(1000000000)
brcc _a1ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a2ser:
dec temp5
subi temp1,BYTE1(-100000000) ; + 100.000.000
sbci temp2,BYTE2(-100000000)
sbci temp3,BYTE3(-100000000)
sbci temp4,BYTE4(-100000000)
brcs _a2ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a3ser:
inc temp5
subi temp1,low(10000000) ; - 10.000.000
sbci temp2,high(10000000)
sbci temp3,BYTE3(10000000)
sbci temp4,BYTE4(10000000)
brcc _a3ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a4ser:
dec temp5
subi temp1,low(-1000000) ; + 1.000.000
sbci temp2,high(-1000000)
sbci temp3,BYTE3(-1000000)
sbci temp4,BYTE4(-1000000)
brcs _a4ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a5ser:
inc temp5
subi temp1,low(100000) ; -100.000
sbci temp2,high(100000)
sbci temp3,BYTE3(100000)
brcc _a5ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a6ser:
dec temp5
subi temp1,low(-10000) ; +10,000
sbci temp2,high(-10000)
sbci temp3,BYTE3(-10000)
brcs _a6ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a7ser:
inc temp5
subi temp1,low(1000) ; -1000
sbci temp2,high(1000)
brcc _a7ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a8ser:
dec temp5
subi temp1,low(-100) ; +100
sbci temp2,high(-100)
brcs _a8ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a9ser:
inc temp5
subi temp1, 10 ; -10
brcc _a9ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a10ser:
dec temp5
subi temp1, -1 ; +1
brcs _a10ser

st X+,temp5 ; im Puffer speichern
ret
</avrasm>

----

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

[[Category:AVR-Tutorial|ADC]]

AVR-Tutorial: ADC

2012-06-25T15:06:01Z

Jackfritt: Satzstellung zum Verständnis korrigiert.

== Was macht der ADC? ==

Wenn es darum geht, Spannungen zu messen, wird der Analog-/Digital-Wandler (kurz: A/D-Wandler) oder englisch [[ADC | '''A'''nalog '''D'''igital '''C'''onverter]] (ADC) benutzt. Er konvertiert eine elektrische Spannung in eine Digitalzahl. Prinzipiell wird dabei die Messspannung mit einer Referenzspannung verglichen. Die Zahl drückt daher das Verhältnis der Messspannung zu dieser Referenzspannung aus. Sie kann in gewohnter Weise von einem [[Mikrocontroller]] weiterverarbeitet werden.

== Elektronische Grundlagen ==

Die ADC-Versorgungsspannung (AVCC) darf maximal um +/-0,3V von der Versorgung des Digitalteils (VCC) abweichen, jedoch nicht 5,5V überschreiten. Die externe Referenzspannung VREF darf nicht kleiner als die im Datenblatt unter ADC Characteristics als VREFmin angegebene Spannung (z. B. ATmega8: 2V, ATmega644P: 1V) und nicht größer als AVCC sein. Die Spannungen an den Wandlereingängen müssen im Intervall GND ≤ VIN ≤ VREF liegen.

Im Extremfall bedeutet dies: Sei VCC = 5,5V, folgt AVCC_max = VREF_max = VIN_max = 5,5V.

Der Eingangswiderstand des ADC liegt in der Größenordnung von einigen Megaohm, so dass der ADC die Signalquelle praktisch nicht belastet. Desweiteren enthält der Mikrocontroller eine sog. '''Sample&Hold''' Schaltung. Dies ist wichtig, wenn sich während des Wandlungsvorgangs die Eingangsspannung verändert, da die AD-Wandlung eine bestimmte Zeit dauert. Die Sample&Hold-Stufe speichert zum Beginn der Wandlung die anliegende Spannung und hält sie während des Wandlungsvorgangs konstant.

=== Beschaltung des ADC-Eingangs ===

Um den ADC im Folgenden zu testen wird eine einfache Schaltung an den PC0-Pin des ATmega8 angeschlossen. Dies ist der ADC-Kanal 0. Bei anderen AVR-Typen liegt der entsprechende Eingang auf einem andern Pin, hier ist ein Blick ins Datenblatt angesagt.

[[Bild:Tut_ADC_01.gif|framed|center|Testschaltung]]

Der Wert des [[Potentiometer]]s ist Dank des hohen Eingangswiderstandes des ADC ziemlich unkritisch. Es kann jedes Potentiometer von 1kΩ bis 1MΩ benutzt werden.

Wenn andere Messgrößen gemessen werden sollen, so bedient man sich oft und gern des Prinzips des [[Spannungsteiler]]s. Der [http://www.mikrocontroller.net/articles/Kategorie:Sensorik Sensor] ist ein veränderlicher Widerstand. Zusammen mit einem zweiten, konstanten Widerstand bekannter Größe wird ein Spannungsteiler aufgebaut. Aus der Variation der durch den variablen Spannungsteiler entstehenden Spannung kann auf den Messwert zurückgerechnet werden.

Vcc ----------+ Vcc ---------+
| |
--- Sensor,
| | der seinen Widerstand
| | in Abhängigkeit der
--- Messgröße ändert
| |
+------- PC0 +-------- PC0
| |
Sensor, ---
der seinen Widerstand | |
in Abhängigkeit der | |
Messgröße ändert ---
| |
GND ---------+ GND --------+

Die Größe des zweiten Widerstandes im Spannungsteiler richtet sich nach dem Wertebereich, in welchem der Sensor seinen Wert ändert. Als Daumenregel kann man sagen, dass der Widerstand so gross sein sollte wie der Widerstand des Sensors in der Mitte des Messbereichs.

Beispiel: Wenn ein [[Temperatursensor]] seinen Widerstand von 0..100 Grad von 2kΩ auf 5kΩ ändert, sollte der zweite Widerstand eine Grösse von etwa (2+5)/2 = 3,5kΩ haben.

===Referenzspannung AREF===
[[bild:adc_connection.png|thumb|right|300px|Beschaltung von AREF]]
Der ADC benötigt für seine Arbeit eine Referenzspannung. Dabei gibt es 2 Möglichkeiten:
* interne Referenzspannung
* externe Referenzspannung

Bei der Umstellung der Referenzspannung sind Wartezeiten zu beachten, bis die ADC-Hardware einsatzfähig ist (Datenblatt und [http://www.mikrocontroller.net/topic/165513]).

==== Interne Referenzspannung ====

Mittels Konfigurationsregister können beim ATmega8 verschiedene Referenzspannungen eingestellt werden. Dies umfasst die Versorgungsspannung AVcc sowie eine vom AVR bereitgestellte Spannung von 2,56V (bzw. bei den neueren AVRs 1,1V, wie z. B. beim ATtiny13, ATmega48, 88, 168, ...). In beiden Fällen wird an den AREF-Pin des Prozessors ein Kondensator von 100nF als Minimalbeschaltung nach Masse angeschlossen, um die Spannung zu puffern/glätten. Es ist jedoch zu beachten, dass die interne Referenzspannung ca. +/-10% vom Nominalwert abweichen kann, vgl. dazu das Datenblatt Abschnitt ADC Characteristics VINT (z. B. ATmega8: 2,3-2,9V, ATmega324P: 2,33-2,79V bzw. 1,0-1,2V "Values are guidelines only."). Die typische Abweichung der internen Referenzspannung vom Sollwert bei einigen AVR-Controllern wird in [http://www.schramm-software.de/tipps/adc-referenzspannung/ dieser Testschaltung] exemplarisch untersucht.

==== Externe Referenzspannung ====

Wird eine externe Referenz verwendet, so wird diese an AREF angeschlossen. Aber aufgepasst! Wenn eine Referenz in Höhe der Versorgungsspannung benutzt werden soll, so ist es besser, dies über die interne Referenz zu tun. Außer bei anderen Spannungen als 5V bzw. 2,56V gibt es eigentlich keinen Grund, an AREF eine Spannungsquelle anzuschließen. In Standardanwendungen fährt man immer besser, wenn die interne Referenzspannung mit einem Kondensator an AREF benutzt wird. Die 10µH-Spule L1 kann man meist auch durch einen 47Ω-Widerstand ersetzen.

== Ein paar ADC-Grundlagen ==

Der ADC ist ein 10-Bit ADC, d.h. er liefert Messwerte im Bereich 0 bis 1023. Liegt am Eingangskanal 0V an, so liefert der ADC einen Wert von 0. Hat die Spannung am Eingangskanal die Referenzspannung erreicht (stimmt nicht ganz), so liefert der ADC einen Wert von 1023. Unterschreitet oder überschreitet die zu messende Spannung diese Grenzen, so liefert der ADC 0 bzw. 1023. Wird die Auflösung von 10 Bit nicht benötigt, so ist es möglich die Ausgabe durch ein Konfigurationsregister so einzuschränken, dass ein leichter Zugriff auf die 8 höchstwertigen Bits möglich ist.

Wie bei vielen analogen Schaltungen, unterliegt auch der ADC einem Rauschen. Das bedeutet, dass man nicht davon ausgehen sollte, dass der ADC bei konstanter Eingangsspannung auch immer denselben konstanten Wert ausgibt. Ein "Zittern" der niederwertigsten 2 Bits ist durchaus nicht ungewöhnlich. Besonders hervorgehoben werden soll an dieser Stelle nochmals die Qualität der Referenzspannung. Diese Qualität geht in erheblichem Maße in die Qualität der Wandelergebnisse ein. Die Beschaltung von AREF mit einem Kondensator ist die absolut notwendige Mindestbeschaltung, um eine einigermaßen akzeptable Referenzspannung zu erhalten. Reicht dies nicht aus, so kann die Qualität einer Messung durch Oversampling erhöht werden. Dazu werden mehrere Messungen gemacht und deren Mittelwert gebildet.

[[Bild:Tut_ADC_03.gif|right|framed]]
Oft interessiert auch der absolute Spannungspegel nicht. Im Beschaltungsbeispiel oben ist man normalerweise nicht direkt an der am Poti entstehenden Spannung interessiert. Viel mehr ist diese Spannung nur ein notwendiges Übel, um die Stellung des Potis zu bestimmen. In solchen Fällen kann die Poti-Beschaltung wie folgt abgewandelt werden:

Hier wird AREF (bei interner Referenz) als vom µC gelieferte Spannung benutzt und vom Spannungsteiler bearbeitet wieder an den µC zur Messung zurückgegeben. Dies hat den Vorteil, dass der Spannungsteiler automatisch Spannungen bis zur Höhe der Referenzspannung ausgibt, ohne dass eine externe Spannung mit AREF abgeglichen werden müsste. Selbst Schwankungen in AREF wirken sich hier nicht mehr aus, da ja das Verhältnis der Spannungsteilerspannung zu AREF immer konstant bleibt (ratiometrische Messung). Und im Grunde bestimmt der ADC ja nur dieses Verhältnis. Wird diese Variante gewählt, so muss berücksichtigt werden, dass die Ausgangsspannung an AREF nicht allzusehr belastet wird. Der Spannungsteiler muss einen Gesamtwiderstand von deutlich über 10kΩ besitzen. Werte von 100kΩ oder höher sind anzustreben. Verwendet man anstatt AREF AVCC und schaltet auch die Referenzspannung auf AVCC um, ist die Belastung durch den Poti unkritisch, weil hier die Stromversorgung direkt zur Speisung verwendet wird.

Ist hingegen die absolute Spannung von Interesse, so muss man darauf achten, dass ein ADC in [[Digital | digitalen]] Bereichen arbeitet ([[Quantisierung]]). An einem einfacheren Beispiel soll demonstriert werden was damit gemeint ist.

Angenommen der ADC würde nur 5 Stufen auflösen können und AREF sei 5V:

Volt Wert vom ADC

0 -+
| 0
1 -+
| 1
2 -+
| 2
3 -+
| 3
4 -+
| 4
5 -+

Ein ADC Wert von 0 bedeutet also keineswegs, dass die zu messende Spannung exakt den Wert 0 hat. Es bedeutet lediglich, dass die Messspannung irgendwo im Bereich von 0V bis 1V liegt. Sinngemäß bedeutet daher auch das Auftreten des Maximalwertes nicht, dass die Spannung exakt AREF beträgt, sondern lediglich, dass die Messspannung sich irgendwo im Bereich der letzten Stufe (also von 4V bis 5V) bewegt.

== Umrechnung des ADC Wertes in eine Spannung ==

Die Größe eines "Bereiches" bestimmt sich also zu

<math>
Bereichsbreite = \frac {Referenzspannung}{Maximalwert}
</math>

Der Messwert vom ADC rechnet sich dann wie folgt in eine Spannung um:

<math>
Spannung = ADCwert \cdot \frac {Referenzspannung} {Maximalwert}
</math>

Wird der ADC also mit 10 Bit an 5 V betrieben, so lauten die Umrechnungen:

<math>
Bereichsbreite = \frac{5~\text{V}}{1023} = 0,004883~\text{V} = 4,883~\text{mV}
</math>

<math>
Spannung = ADCwert \cdot 4,883~\text{mV}
</math>

Wenn man genau hinsieht stellt man fest, dass sowohl die Referenzspannung als auch der Maximalwert Konstanten sind. D.h. der Quotient aus Referenzspannung und Maximalwert ist konstant. Somit muss nicht immer eine Addition und Division ausgeführt werden, sondern nur eine Multiplikation! Das spart viel Aufwand und Rechenzeit! Dabei kann sinnvollerweise [[Festkommaarithmetik]] zum Einsatz kommen.

== Kalibrierung ==
Hat man eine externe, genaue Referenzspannung zu Hand, dann kann ein Korrekturfaktor berechnet werden, mit dem die Werte des ADCs im Nachinein korrigiert werden können. Dies geschieht normalerweise über eine sogenannte gain offset Korrektur an einer Geraden oder einer Parabel. In erster Näherung kann man auch die interne Referenzspannung um das Inverse des ermittelten Korrekturwertes verstellen, um einen genaueren bereits digitalisierten Wert zu bekommen.

== Die Steuerregister des ADC ==

=== ADMUX ===

{{Byte|ADMUX| REFS1 | REFS0 | ADLAR | | MUX3 | MUX2 | MUX1 | MUX0}}

* Referenzspannung REFS1, REFS0

{| {{Tabelle}}
|- style="background-color:#ffddcc"
!REFS1||REFS0||Referenz
|-
|align="center"|0
|align="center"|0
||externe Referenz
|-
|align="center"|0
|align="center"|1
|interne Referenz: Avcc
|-
|align="center"|1
|align="center"|0
||wird beim Mega8 nicht benutzt
|-
|align="center"|1
|align="center"|1
||interne Referenz: 2.56 Volt
|}

* Ausrichtung ADLAR
<table border="0">
<tr>
<th align="left">ADLAR</th><th align="left"></th>
</tr>
<tr>
<td>0</td><td>Das Ergebnis wird in den Registern ADCH/ADCL rechtsbündig ausgerichtet. Die 8 niederwertigsten Bits des Ergebnisses werden in ADCL abgelegt. Die verbleibenden 2 Bits des Ergebnisses werden im Register ADCH in den Bits 0 und 1 abgelegt.</td>
</tr>
<tr>
<td>1</td><td>Das Ergebnis wird in den Registern ADCH/ADCL linksbündig ausgerichtet. Die 8 höchstwertigen Bits des Ergebnisses werden in ADCH abgelegt. Die verbleibenden 2 niederwertigen Bits werden im Register ADCL in den Bits 6 und 7 abgelegt.</td>
</tr>
</table>

* Kanalwahl MUX3, MUX2, MUX1, MUX0
{| {{Tabelle}}
|- style="background-color:#ffddcc"
!MUX3||MUX2||MUX1||MUX0||Kanal
|-
|align="center"|0
|align="center"|0
|align="center"|0
|align="center"|0
||Kanal 0, Pin PC0
|-
|align="center"|0
|align="center"|0
|align="center"|0
|align="center"|1
||Kanal 1, Pin PC1
|-
|align="center"|0
|align="center"|0
|align="center"|1
|align="center"|0
||Kanal 2, Pin PC2
|-
|align="center"|0
|align="center"|0
|align="center"|1
|align="center"|1
||Kanal 3, Pin PC3
|-
|align="center"|0
|align="center"|1
|align="center"|0
|align="center"|0
||Kanal 4, Pin PC4
|-
|align="center"|0
|align="center"|1
|align="center"|0
|align="center"|1
||Kanal 5, Pin PC5
|-
|align="center"|0
|align="center"|1
|align="center"|1
|align="center"|0
||Kanal 6 (*)
|-
|align="center"|0
|align="center"|1
|align="center"|1
|align="center"|1
||Kanal 7 (*)
|-
|align="center"|1
|align="center"|1
|align="center"|1
|align="center"|0
||1.23V, Vbg
|-
|align="center"|1
|align="center"|1
|align="center"|1
|align="center"|1
||0V, GND
|}

(*) Bei Atmega8 nur in der Gehäusebauform TQFP und MLF verfügbar, nicht in PDIP

===ADCSRA===
{{Byte|ADCSRA| ADEN | ADSC | ADFR | ADIF | ADIE | ADPS2 | ADPS1 | ADPS0}}

;ADEN: "ADC Enable": Mittels ADEN wird der ADC ein und ausgeschaltet. Eine 1 an dieser Bitposition schaltet den ADC ein.
; ADSC: "ADC Start Conversion": Wird eine 1 an diese Bitposition geschrieben, so beginnt der ADC mit der Wandlung. Das Bit bleibt auf 1, solange die Wandlung im Gange ist. Wenn die Wandlung beendet ist, wird dieses Bit von der ADC Hardware wieder auf 0 gesetzt.
; ADFR: "ADC Free Running": Wird eine 1 an ADFR geschrieben, so wird der ADC im Free Running Modus betrieben. Dabei startet der ADC nach dem Abschluss einer Messung automatisch die nächste Messung. Die erste Messung wird ganz normal über das Setzen des ADSC-Bits gestartet.
; ADIF: "ADC Interrupt Flag": Wenn eine Messung abgeschlossen ist, wird das ADIF Bit gesetzt. Ist zusätzlich noch das ADIE Bit gesetzt, so wird ein Interrupt ausgelöst und der entsprechende Interrupt Handler angesprungen.
; ADIE: "ADC Interrupt Enable": Wird eine 1 an ADIE geschrieben, so löst der ADC nach Beendigung einer Messung einen Interrupt aus.
; ADPS2, ADPS1, ADPS0: "ADC Prescaler": Mit dem Prescaler kann die ADC-Frequenz gewählt werden. Laut Datenblatt sollte diese für die optimale Auflösung zwischen 50kHz und 200kHz liegen. Ist die Wandlerfrequenz langsamer eingestellt, kann es passieren dass die eingebaute Sample & Hold Schaltung die Eingangsspannung nicht lange genug konstant halten kann. Ist die Frequenz aber zu schnell eingestellt, dann kann es passieren dass sich die Sample & Hold Schaltung nicht schnell genug an die Eingangsspannung anpassen kann.

{| {{Tabelle}}
|- style="background-color:#ffddcc"
!ADPS2||ADPS1||ADPS0||Vorteiler
|-
|align="center"|0
|align="center"|0
|align="center"|0
|align="center"|2
|-
|align="center"|0
|align="center"|0
|align="center"|1
|align="center"|2
|-
|align="center"|0
|align="center"|1
|align="center"|0
|align="center"|4
|-
|align="center"|0
|align="center"|1
|align="center"|1
|align="center"|8
|-
|align="center"|1
|align="center"|0
|align="center"|0
|align="center"|16
|-
|align="center"|1
|align="center"|0
|align="center"|1
|align="center"|32
|-
|align="center"|1
|align="center"|1
|align="center"|0
|align="center"|64
|-
|align="center"|1
|align="center"|1
|align="center"|1
|align="center"|128
|}

== Die Ergebnisregister ADCL und ADCH ==

Da das Ergebnis des ADC ein 10 Bit Wert ist, passt dieser Wert naturgemäß nicht in ein einzelnes Register, das ja bekanntlich nur 8 Bit breit ist. Daher wird das Ergebnis in 2 Register '''ADCL''' und '''ADCH''' abgelegt. Von den 10 Ergebnisbits sind die niederwertigsten 8 im Register '''ADCL''' abgelegt und die noch fehlenden 2 Bits werden im Register '''ADCH''' an den niederwertigsten Bitpositionen gespeichert.

ADCH ADCL
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | | | | | | | | | | | | | | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
9 8 7 6 5 4 3 2 1 0

Diese Zuordnung kann aber auch geändert werden: Durch setzen des '''ADLAR''' Bits im '''ADMUX''' Register wird die Ausgabe geändert zu:

ADCH ADCL
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
| | | | | | | | | | | | | | | | | |
+---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
9 8 7 6 5 4 3 2 1 0

Dies ist besonders dann interessant, wenn das ADC Ergebnis als 8 Bit Zahl weiterverarbeitet werden soll. In diesem Fall stehen die 8 höchstwertigen Bits bereits verarbeitungsfertig im Register '''ADCH''' zur Verfügung.

Beim Auslesen der ADC-Register ist zu beachten:
Immer zuerst '''ADCL''' und erst dann '''ADCH''' auslesen. Beim Zugriff auf '''ADCL''' wird das '''ADCH''' Register gegenüber Veränderungen vom '''ADC''' gesperrt. Erst beim nächsten Auslesen des '''ADCH'''-Registers wird diese Sperre wieder aufgehoben. Dadurch ist sichergestellt, daß die Inhalte von '''ADCL''' und '''ADCH''' immer aus demselben Wandlungsergebnis stammen, selbst wenn der '''ADC''' im Hintergrund selbsttätig weiterwandelt. Das '''ADCH''' Register '''muss''' ausgelesen werden!

== Beispiele ==

=== Ausgabe als ADC-Wert ===

Das folgende Programm liest in einer Schleife ständig den ADC aus und verschickt das Ergebnis im Klartext (ASCII) über die [[AVR-Tutorial: UART|UART]]. Zur Verringerung des unvermeidlichen Rauschens werden 256 Messwerte herangezogen und deren Mittelwert als endgültiges Messergebnis gewertet. Dazu werden die einzelnen Messungen in den Registern temp2, temp3, temp4 als 24 Bit Zahl aufaddiert. Die Division durch 256 erfolgt dann ganz einfach dadurch, dass das Register temp2 verworfen wird und die Register temp3 und temp4 als 16 Bit Zahl aufgefasst werden. Eine Besonderheit ist noch, dass je nach dem Wert in temp2 die 16 Bit Zahl in temp3 und temp4 noch aufgerundet wird: Enthält temp2 einen Wert größer als 128, dann wird zur 16 Bit Zahl in temp3/temp4 noch 1 dazu addiert.

In diesem Programm findet man oft die Konstruktion

<avrasm>
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry
</avrasm>

Dabei handelt es sich um einen kleinen Trick. Um eine Konstante zu einem Register direkt addieren zu können bräuchte man einen Befehl ala addi (Add Immediate, Addiere Konstante), den der AVR aber nicht hat. Ebenso gibt es kein adci (Add with carry Immediate, Addiere Konstante mit Carry Flag). Man müsste also erst eine Konstante in ein Register laden und addieren. Das kostet aber Programmspeicher, Rechenzeit und man muss ein Register zusätzlich frei haben.

<avrasm>
; 16 Bit Addition mit Konstante, ohne Cleverness
ldi temp5, low(1)
add temp3, temp5 ; addieren von 1
ldi temp5, high(1)
adc temp3, temp5 ; addieren des Carry
</avrasm>

Hier greift man einfach zu dem Trick, dass eine Addition gleich der Subtraktion der negativen Werts ist. Also "addiere +1" ist gleich "subtrahiere -1". Dafür hat der AVR zwei Befehle, subi (Substract Immediate, Subtrahiere Konstante) und sbci (Substract Immediate with carry, Subtrahiere Konstante mit Carry Flag).

Das folgende Programm ist für den '''ATmega8''' geschrieben. Für moderne Nachfolgetypen wie den ATmega88 muss der Code angepasst werden ([http://www.mikrocontroller.net/topic/204069#2011175], [http://www.atmel.com/dyn/resources/prod_documents/doc2553.pdf AVR094: Replacing ATmega8 by ATmega88 (PDF)]).

<avrasm>
.include "m8def.inc"

.def temp1 = r16 ; allgemeines temp Register, zur kurzfristigen Verwendung
.def temp2 = r17 ; Register für 24 Bit Addition, Lowest Byte
.def temp3 = r18 ; Register für 24 Bit Addition, Middle Byte
.def temp4 = r19 ; Register für 24 Bit Addition, Highest Byte
.def adlow = r20 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def adhigh = r21 ; Ergebnis vom ADC / Mittelwert der 256 Messungen
.def messungen = r22 ; Schleifenzähler für die Messungen
.def ztausend = r23 ; Zehntausenderstelle des ADC Wertes
.def tausend = r24 ; Tausenderstelle des ADC Wertes
.def hundert = r25 ; Hunderterstelle des ADC Wertes
.def zehner = r26 ; Zehnerstelle des ADC Wertes
.def zeichen = r27 ; Zeichen zur Ausgabe auf den UART

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

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

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

; hier geht das Programm los

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;UART Initalisierung

ldi temp1, LOW(UBRR_VAL) ; Baudrate einstellen
out UBRRL, temp1
ldi temp1, HIGH(UBRR_VAL)
out UBRRH, temp1

sbi UCSRB, TXEN ; TX einschalten

; ADC initialisieren: ADC0, Vcc als Referenz, Single Conversion, Vorteiler 128

ldi temp1, (1<<REFS0) ; Kanal 0, interne Referenzspannung 5V
out ADMUX, temp1
ldi temp1, (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
out ADCSRA, temp1

Main:
clr temp1
clr temp2
clr temp3
clr temp4

ldi messungen, 0 ; 256 Schleifendurchläufe

; neuen ADC-Wert lesen (Schleife - 256 mal)

sample_adc:
sbi ADCSRA, ADSC ; den ADC starten

wait_adc:
sbic ADCSRA, ADSC ; wenn der ADC fertig ist, wird dieses Bit gelöscht
rjmp wait_adc

; ADC einlesen:

in adlow, ADCL ; immer zuerst LOW Byte lesen
in adhigh, ADCH ; danach das mittlerweile gesperrte High Byte

; alle 256 ADC-Werte addieren
; dazu wird mit den Registern temp4, temp3 und temp2 ein
; 24-Bit breites Akkumulationsregister gebildet, in dem
; die 10 Bit Werte aus adhigh, adlow aufsummiert werden

add temp2, adlow ; addieren
adc temp3, adhigh ; addieren über Carry
adc temp4, temp1 ; addieren über Carry, temp1 enthält 0
dec messungen ; Schleifenzähler MINUS 1
brne sample_adc ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen

; Aus den 256 Werten den Mittelwert berechnen
; Mathematisch eine Division durch 256
; Da aber 2^8 = 256 ist ist da einfach durch das weglassen des niederwertigsten Bytes
; erreicht werden
;
; allerdings wird der Wert noch gerundet

cpi temp2,128 ; "Kommastelle" kleiner als 128 ?
brlo no_round ; ist kleiner ==> Sprung

; Aufrunden
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry

no_round:

; Ergebnis nach adlow und adhigh kopieren
; damit die temp Register frei werden

mov adlow, temp3
mov adhigh, temp4

;in ASCII umwandeln
; Division durch mehrfache Subtraktion

ldi ztausend, '0'-1 ; Ziffernzähler direkt als ASCII Code
; bzgl. '0'-1 siehe http://www.mikrocontroller.net/topic/198681
Z_ztausend:
inc ztausend
subi adlow, low(10000) ; -10,000
sbci adhigh, high(10000) ; 16 Bit
brcc Z_ztausend

subi adlow, low(-10000) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-10000); +10,000

ldi tausend, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_tausend:
inc tausend
subi adlow, low(1000) ; -1,000
sbci adhigh, high(1000) ; 16 Bit
brcc Z_tausend

subi adlow, low(-1000) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-1000) ; +1,000

ldi hundert, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_hundert:
inc hundert
subi adlow, low(100) ; -100
sbci adhigh, high(100) ; 16 Bit
brcc Z_hundert

subi adlow, low(-100) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-100) ; +100

ldi zehner, '0'-1 ; Ziffernzähler direkt als ASCII Code
Z_zehner:
inc zehner
subi adlow, low(10) ; -10
sbci adhigh, high(10) ; 16 Bit
brcc Z_zehner

subi adlow, low(-10) ; nach Unterlauf wieder einmal addieren
sbci adhigh, high(-10) ; +10

subi adlow, -'0' ; adlow enthält die Einer, Umwandlung in ASCII

;an UART Senden

mov zeichen, ztausend ; Zehntausender Stelle
rcall transmit
mov zeichen, tausend ; Tausender Stelle ausgeben
rcall transmit
mov zeichen, hundert ; Hunderter Stelle ausgeben
rcall transmit
mov zeichen, zehner ; Zehner Stelle ausgeben
rcall transmit
mov zeichen, adlow ; Einer Stelle ausgeben
rcall transmit
ldi zeichen, 13 ; CR, Carrige Return (Wagenrücklauf)
rcall transmit
ldi zeichen, 10 ; LF, Line Feed (Neue Zeile)
rcall transmit

rjmp Main

transmit:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp transmit
out UDR, zeichen ; und Zeichen ausgeben
ret
</avrasm>

=== Ausgabe als Spannungswert ===

Das zweite Beispiel ist schon um einiges größer. Hier wird der gemittelte ADC-Wert in eine Spannung umgerechnet. Dazu wird [[Festkommaarithmetik]] verwendet. Die Daten sind in diesem Fall

* Referenzspannung : 5V
* alte Auflösung : 5V / 1024 = 4,8828125mV
* neue Auflösung : 1mV

-> Faktor = 4,8828125mV / 1mV = 4,8828125

Der Faktor wird dreimal mit 10 multipliziert und das Ergebnis auf 4883 gerundet. Die neue Auflösung wird dreimal durch 10 dividiert und beträgt 1μV. Der relative Fehler beträgt

:<math> F_r = \frac {4883}{4882,8125}-1 = 0,00384% = \frac {1}{26042}</math>

Diese Fehler ist absolut vernachlässigbar. Nach der Multiplikation des ADC-Wertes mit 4883 liegt die gemessene Spannung in der Einheit μV vor. Vorsicht! Das ist '''nicht''' die reale [[Auflösung und Genauigkeit]], nur rein mathematisch bedingt. Für maximale Genauigkeit sollte man die Versorgungsspannung AVCC, welche hier gleichzeitig als Referenzspannung dient, exakt messen, die Rechnung nachvollziehen und den Wert im Quelltext eintragen. Damit führt man eine einfach Einpunktkalibrierung durch.

Da das Programm schon um einiges größer und komplexer ist, wurde es im Vergleich zur Vorgängerversion geändert. Die Multiplikation sowie die Umwandung der Zahl in einen ASCII-String sind als Unterprogramme geschrieben, dadurch erhält man wesentlich mehr Überblick im Hauptprogramm und die Wiederverwendung in anderen Programmen vereinfacht sich. Ausserdem wird der String im RAM gespeichert und nicht mehr in CPU-Registern. Die Berechung der einzelnen Ziffern erfolgt über ein Schleife, das ist kompakter und übersichtlicher.

<avrasm>
.include "m8def.inc"

.def z0 = r1 ; Zahl für Integer -> ASCII Umwandlung
.def z1 = r2
.def z2 = r3
.def z3 = r4
.def temp1 = r16 ; allgemeines Register, zur kurzfristigen Verwendung
.def temp2 = r17 ; Register für 24 Bit Addition, niederwertigstes Byte (LSB)
.def temp3 = r18 ; Register für 24 Bit Addition, mittlerers Byte
.def temp4 = r19 ; Register für 24 Bit Addition, höchstwertigstes Byte (MSB)
.def adlow = r20 ; Ergebnis vom ADC-Mittelwert der 256 Messungen
.def adhigh = r21 ; Ergebnis vom ADC-Mittelwert der 256 Messungen
.def messungen = r22 ; Schleifenzähler für die Messungen
.def zeichen = r23 ; Zeichen zur Ausgabe auf den UART
.def temp5 = r24
.def temp6 = r25

; Faktor für Umrechung des ADC-Wertes in Spannung
; = (Referenzspannung / 1024 ) * 100000
; = 5V / 1024 * 1.000.000
.equ Faktor = 4883

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

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

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

; RAM
.dseg
.org 0x60
Puffer: .byte 10

; hier geht das Programm los
.cseg
.org 0

ldi temp1, LOW(RAMEND) ; Stackpointer initialisieren
out SPL, temp1
ldi temp1, HIGH(RAMEND)
out SPH, temp1

;UART Initalisierung

ldi temp1, LOW(UBRR_VAL) ; Baudrate einstellen
out UBRRL, temp1
ldi temp1, HIGH(UBRR_VAL)
out UBRRH, temp1

sbi UCSRB, TXEN ; TX einschalten

; ADC initialisieren: Single Conversion, Vorteiler 128
; Kanal 0, interne Referenzspannung AVCC

ldi temp1, (1<<REFS0)
out ADMUX, temp1
ldi temp1, (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)
out ADCSRA, temp1

Hauptschleife:
clr temp1
clr temp2
clr temp3
clr temp4

ldi messungen, 0 ; 256 Schleifendurchläufe

; neuen ADC-Wert lesen (Schleife - 256 mal)

adc_messung:
sbi ADCSRA, ADSC ; den ADC starten

adc_warten:
sbic ADCSRA, ADSC ; wenn der ADC fertig ist, wird dieses Bit gelöscht
rjmp adc_warten

; ADC einlesen:

in adlow, ADCL ; immer zuerst LOW Byte lesen
in adhigh, ADCH ; danach das mittlerweile gesperrte High Byte

; alle 256 ADC-Werte addieren
; dazu wird mit den Registern temp4, temp3 und temp2 ein
; 24-Bit breites Akkumulationsregister gebildet, in dem
; die 10 Bit Werte aus adhigh, adlow aufsummiert werden

add temp2, adlow ; addieren
adc temp3, adhigh ; addieren über Carry
adc temp4, temp1 ; addieren über Carry, temp1 enthält 0
dec messungen ; Schleifenzähler MINUS 1
brne adc_messung ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen

; Aus den 256 Werten den Mittelwert berechnen
; Bei 256 Werten ist das ganz einfach: Das niederwertigste Byte
; (im Register temp2) fällt einfach weg
;
; allerdings wird der Wert noch gerundet

cpi temp2,128 ; "Kommastelle" kleiner als 128 ?
brlo nicht_runden ; ist kleiner ==> Sprung

; Aufrunden
subi temp3, low(-1) ; addieren von 1
sbci temp4, high(-1) ; addieren des Carry

nicht_runden:

; Ergebnis nach adlow und adhigh kopieren
; damit die temp Register frei werden

mov adlow, temp3
mov adhigh, temp4

; in Spannung umrechnen

ldi temp5,low(Faktor)
ldi temp6,high(Faktor)
rcall mul_16x16

; in ASCII umwandeln

ldi XL, low(Puffer)
ldi XH, high(Puffer)
rcall Int_to_ASCII

;an UART Senden

ldi ZL, low(Puffer+3)
ldi ZH, high(Puffer+3)
ldi temp1, 1
rcall sende_zeichen ; eine Vorkommastelle ausgeben

ldi zeichen, ',' ; Komma ausgeben
rcall sende_einzelzeichen

ldi temp1, 3 ; Drei Nachkommastellen ausgeben
rcall sende_zeichen

ldi zeichen, 'V' ; Volt Zeichen ausgeben
rcall sende_einzelzeichen

ldi zeichen, 10 ; New Line Steuerzeichen
rcall sende_einzelzeichen

ldi zeichen, 13 ; Carrige Return Steuerzeichen
rcall sende_einzelzeichen

rjmp Hauptschleife

; Ende des Hauptprogramms

; Unterprogramme

; ein Zeichen per UART senden

sende_einzelzeichen:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp sende_einzelzeichen
out UDR, zeichen ; und Zeichen ausgeben
ret

; mehrere Zeichen ausgeben, welche durch Z adressiert werden
; Anzahl in temp1

sende_zeichen:
sbis UCSRA,UDRE ; Warten, bis UDR bereit ist ...
rjmp sende_zeichen
ld zeichen, Z+ ; Zeichen laden
out UDR, zeichen ; und Zeichen ausgeben
dec temp1
brne sende_zeichen
ret

; 32 Bit Zahl in ASCII umwandeln
; Zahl liegt in temp1..4
; Ergebnis ist ein 10stelliger ASCII String, welcher im SRAM abgelegt wird
; Adressierung über X Pointer
; mehrfache Subtraktion wird als Ersatz für eine Division durchgeführt.

Int_to_ASCII:

push ZL ; Register sichern
push ZH
push temp5
push temp6

ldi ZL,low(Tabelle*2) ; Zeiger auf Tabelle
ldi ZH,high(Tabelle*2)
ldi temp5, 10 ; Schleifenzähler

Int_to_ASCII_schleife:
ldi temp6, -1+'0' ; Ziffernzähler zählt direkt im ASCII Code
lpm z0,Z+ ; Nächste Zahl laden
lpm z1,Z+
lpm z2,Z+
lpm z3,Z+

Int_to_ASCII_ziffer:
inc temp6 ; Ziffer erhöhen
sub temp1, z0 ; Zahl subrahieren
sbc temp2, z1 ; 32 Bit
sbc temp3, z2
sbc temp4, z3
brge Int_to_ASCII_ziffer ; noch kein Unterlauf, nochmal

add temp1, z0 ; Unterlauf, eimal wieder addieren
adc temp2, z1 ; 32 Bit
adc temp3, z2
adc temp4, z3
st X+,temp6 ; Ziffer speichern
dec temp5
brne Int_to_ASCII_schleife ; noch eine Ziffer?

pop temp6
pop temp5
pop ZH
pop ZL ; Register wieder herstellen
ret

; Tabelle mit Zahlen für die Berechung der Ziffern
; 1 Milliarde bis 1
Tabelle:
.dd 1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1

; 16 Bit Wert in Spannung umrechnen
;
; = 16Bitx16Bit=32 Bit Multiplikation
; = vier 8x8 Bit Multiplikationen
;
; adlow/adhigh * temp5/temp6

mul_16x16:
push zeichen
clr temp1 ; 32 Bit Akku löschen
clr temp2
clr temp3
clr temp4
clr zeichen ; Null, für Carry-Addition

mul adlow, temp5 ; erste Multiplikation
add temp1, r0 ; und akkumulieren
adc temp2, r1

mul adhigh, temp5 ; zweite Multiplikation
add temp2, r0 ; und gewichtet akkumlieren
adc temp3, r1

mul adlow, temp6 ; dritte Multiplikation
add temp2, r0 ; und gewichtet akkumlieren
adc temp3, r1
adc temp4, zeichen ; carry addieren

mul adhigh, temp6 ; vierte Multiplikation
add temp3, r0 ; und gewichtet akkumlieren
adc temp4, r1

pop zeichen
ret
</avrasm>

Für alle, die es besonders eilig haben gibt es hier eine geschwindigkeitsoptimierte Version der Integer in ASCII Umwandlung. Zunächst wird keine Schleife verwendet sondern alle Stufen der Schleife direkt hingeschrieben. Das braucht zwar mehr Programmspeicher, ist aber schneller. Ausserdem wird abwechselnd subtrahiert und addiert, dadurch entfällt das immer wieder notwendige addieren nach dem Unterlauf. Zu guter Letzt werden die Berechnungen nur mit der minimal notwenigen Wortbreite durchgeführt. Am Anfang mit 32 Bit, dann nur noch mit 16 bzw. 8 Bit.

<avrasm>
; 32 Bit Zahl in ASCII umwandeln
; geschwindigkeitsoptimierte Version
; Zahl liegt in temp1..4
; Ergebnis ist ein 10stelliger ASCII String, welcher im SRAM abgelegt wird
; Adressierung über X Pointer

Int_to_ASCII:
ldi temp5, -1 + '0'
_a1ser:
inc temp5
subi temp1,BYTE1(1000000000) ; - 1.000.000.000
sbci temp2,BYTE2(1000000000)
sbci temp3,BYTE3(1000000000)
sbci temp4,BYTE4(1000000000)
brcc _a1ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a2ser:
dec temp5
subi temp1,BYTE1(-100000000) ; + 100.000.000
sbci temp2,BYTE2(-100000000)
sbci temp3,BYTE3(-100000000)
sbci temp4,BYTE4(-100000000)
brcs _a2ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a3ser:
inc temp5
subi temp1,low(10000000) ; - 10.000.000
sbci temp2,high(10000000)
sbci temp3,BYTE3(10000000)
sbci temp4,BYTE4(10000000)
brcc _a3ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a4ser:
dec temp5
subi temp1,low(-1000000) ; + 1.000.000
sbci temp2,high(-1000000)
sbci temp3,BYTE3(-1000000)
sbci temp4,BYTE4(-1000000)
brcs _a4ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a5ser:
inc temp5
subi temp1,low(100000) ; -100.000
sbci temp2,high(100000)
sbci temp3,BYTE3(100000)
brcc _a5ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a6ser:
dec temp5
subi temp1,low(-10000) ; +10,000
sbci temp2,high(-10000)
sbci temp3,BYTE3(-10000)
brcs _a6ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a7ser:
inc temp5
subi temp1,low(1000) ; -1000
sbci temp2,high(1000)
brcc _a7ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a8ser:
dec temp5
subi temp1,low(-100) ; +100
sbci temp2,high(-100)
brcs _a8ser

st X+,temp5 ; im Puffer speichern
ldi temp5, -1 + '0'
_a9ser:
inc temp5
subi temp1, 10 ; -10
brcc _a9ser

st X+,temp5 ; im Puffer speichern
ldi temp5, 10 + '0'
_a10ser:
dec temp5
subi temp1, -1 ; +1
brcs _a10ser

st X+,temp5 ; im Puffer speichern
ret
</avrasm>

----

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

[[Category:AVR-Tutorial|ADC]]

Eagle-Bibliotheken

2011-12-16T14:38:40Z

Jackfritt: /* Halbleiterschalter */

== Funktionsweise ==

User laden im Forum eine Bibliothek mit einem oder mehreren zusammengehörigen Bauteilen hoch (beispielsweise ATXmegas) und tragen ein, welche Bauteile mit welchen Packages in der Bibliothek zu finden sind. Andere User können sie sich ansehen und auf Fehlerfreiheit prüfen. Dies wird in der Tabelle unten vermerkt.

== Bibliotheken ==

=== Bus-Isolatoren ===

Von User: Kevin K.
Link: [[Datei:Bus-isolators.lbr]]

{| {{Tabelle}} class="sortable" id="Errata"
|- bgcolor="#eeeeee"
! Version
! Änderungen
! ausstehend
|-

| 2
| SO28/8-Package bei ISO124 hinzugefügt, Prefixe zugefügt, Name- und Value-Label korrigiert
| Pindirections eintragen
|-

|3
| Pindirections eingefügt, ADUM1200, ADUM1201 und ADUM1400 zugefügt
|}

{| {{Tabelle}} class="sortable" id="Bus-isolators.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler
|-

| Analog Devices
| [http://www.mikrocontroller.net/part/ADM3251 ADM3251]
| SO-20L
| UART/RS232-Treiber, isoliert
| keine
| nein
|
|-

| Analog Devices
| [http://www.mikrocontroller.net/part/ADUM1200 ADUM1200]
| SO-8
| Digital-Isolator 2->
| keine
| nein
|
|-

| Analog Devices
| [http://www.mikrocontroller.net/part/ADUM1201 ADUM1201]
| SO-8
| Digital-Isolator 1-> 1<-
| keine
| nein
|
|-

| Analog Devices
| [http://www.mikrocontroller.net/part/ADUM1250 ADUM1250]
| SO-8
| I²C-Isolator
| keine
| nein
|
|-

| Analog Devices
| [http://www.mikrocontroller.net/part/ADUM1400 ADUM1400]
| SO-16W
| Digital-Isolator 4->
| keine
| nein
|
|-

| Analog Devices
| [http://www.mikrocontroller.net/part/ADUM4160 ADUM4160]
| SO-16L
| USB1.1-Isolator
| keine
| nein
|
|-

| Texas Instruments
| [http://www.mikrocontroller.net/part/ISO124 ISO124]
| DIL-16/8
| Analog-Isolator
| keine
| nein
|
|-

| Silicon Laboratories
| [http://www.mikrocontroller.net/part/SI8405 SI8405]
| SO-16
| I²C + TTL-Isolator
| keine
| nein
|
|}

=== Kristalle und Oszillatoren ===

Von User: Kevin K.
Link: [[Datei:crystals-new.lbr]]

{| {{Tabelle}} class="sortable" id="crystals-new.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler
|-

| EuroQuartz
| [http://www.euroquartz.co.uk/Portals/0/mq.pdf]
| MQ
| Quartz
| keine
| nein
|
|-

| EuroQuartz
| [http://www.euroquartz.co.uk/Portals/0/mj.pdf]
| MJ
| Quartz
| keine
| nein
|
|-

| EuroQuartz
| [http://www.euroquartz.co.uk/Portals/0/mt.pdf]
| MT
| Quartz
| keine
| nein
|
|-

| EuroQuartz
| [http://www.euroquartz.co.uk/Portals/0/x22.pdf]
| X22
| Quartz
| keine
| nein
|
|-

| EuroQuartz
| [http://www.euroquartz.co.uk/Portals/0/xo91.pdf]
| XO91
| Oszillator
| keine
| nein
|
|-

| EuroQuartz
| [http://www.euroquartz.co.uk/Portals/0/xo53.pdf]
| XO53
| Oszillator
| keine
| nein
|
|-

| EuroQuartz
| [http://www.euroquartz.co.uk/Portals/0/xo32.pdf]
| XO32
| Oszillator
| keine
| nein
|
|}

=== Shuntwiderstände Vishay CSM-Serie ===

Von User: Kevin K.
Link: [[Datei:R-Vishay.lbr]]

{| {{Tabelle}} class="sortable" id="R-Vishay.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler
|-

| Vishay
| [http://www.vishaypg.com/docs/63089/csm.pdf]
| CSM2512
| Widerstand
| alle drei Varianten
| nein
|
|-

| Vishay
| [http://www.vishaypg.com/docs/63089/csm.pdf]
| CSM3637
| Widerstand
| alle zwei Varianten
| nein
|
|}

=== Spulen Fastron ===

Von User: Kevin K.
Link: [[Datei:inductor-Fastron.lbr]]

{| {{Tabelle}} class="sortable" id="inductor-Fastron.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler
|-

| Fastron
| [http://www.fastrongroup.com/image-show/54/PISG.pdf?type=Complete-DataSheet&productType=series]
| PISG
| Spule
| keine
| nein
|
|-

| Fastron
| [http://www.fastrongroup.com/image-show/58/PISR.pdf?type=Complete-DataSheet&productType=series]
| PISR
| Spule
| keine
| nein
|
|-

| Fastron
| [http://www.fastrongroup.com/image-show/56/PISM.pdf?type=Complete-DataSheet&productType=series]
| PISM
| Spule
| keine
| nein
|
|-

| Fastron
| [http://www.fastrongroup.com/image-show/47/PIS2408.pdf?type=Complete-DataSheet&productType=series]
| PIS 24XX
| Spule
| keine
| nein
|
|-

| Fastron
| [http://www.fastrongroup.com/image-show/49/PIS2812.pdf?type=Complete-DataSheet&productType=series]
| PIS 28XX
| Spule
| keine
| nein
|
|-

| Fastron
| [http://www.fastrongroup.com/image-show/52/PIS4720.pdf?type=Complete-DataSheet&productType=series]
| PIS 47XX
| Spule
| keine
| nein
|
|}

=== Micromatch THT und SMD ===

Von User: Kevin K.
Link: [[Datei:con-amp-micromatch.lbr]]

{| {{Tabelle}} class="sortable" id="con-amp-micromatch.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler
|-

| Tyco Electronics
| [http://www.tycoelectronics.com/commerce/DocumentDelivery/DDEController?Action=srchrtrv&DocNm=215464&DocType=CD&DocLang=EN]
| Micromatch
| SMD und THT
| 6-20 polig
| nein
|
|}

=== Halbleiterschalter ===

Von User: Kevin K.
Link: [[Datei:linear-switch.lbr]]

{| {{Tabelle}} class="sortable" id="linear-switch.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler
|-

| Linear Technology
| [http://www.linear.com/pc/downloadDocument.do?navId=H0,C1,C1010,C1203,P1248,D3572 LTC1043]
| DIL18 / SO18
| SMD und THT
| keine
| nein
|
|}

=== TLC5951 ===

Von User: Frank Link
Link: [[Datei:ti_tlc.lbr]]

{| {{Tabelle}} class="sortable" id="ti_tlc.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler 
|-

| Texas Instruments
| [http://www.mikrocontroller.net/part/TLC5951 TLC5951]
| HTSSOP-38
| 24 Channel, 12 Bit PWM LED-Driver
| keine
| nein
| kein Pad-Überstand offen da noch nicht geklärt
|}

=== PCI-Express Mini-Karte ===

von User: hownottobeseen
Link [[Datei:Con-heo.mini pci express.lbr]]

Enthält Konnektor und Formfaktor für Full- und Halfsize-PCIe-Mini-Karten

siehe auch [http://www.mikrocontroller.net/topic/214222 Diskussion im Forum]

=== Maxim MAX1811 USB Li+ Lader ===

von User: [http://www.mikrocontroller.net/user/show/muetze1 Muetze1] Link [[Datei:MAX1811.lbr]]

Enthält den Maxim MAX1811 USB Li+ Lader im SO08 Gehäuse

{| {{Tabelle}} class="sortable" id="MAX1811.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler 
|-

| Maxim IC
| [http://www.mikrocontroller.net/part/MAX1811 MAX1811]
| SO08
| USB Li+ Loader (100mA/500mA)
| keine
| nein
| -
|}

=== International Rectifier IRLML6402 ===

von User: [http://www.mikrocontroller.net/user/show/muetze1 Muetze1] Link [[Datei:IRLML6402.lbr]]

Der IR IRLML6402 p-Channel MOSFET wird u.a. von FTDI in ihren Unterlagen zum FT232RL vorgeschlagen für die Schaltung der Versorgung nach dem Init des USB Gerätes.

{| {{Tabelle}} class="sortable" id="IRLML6402.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler 
|-

| [http://www.irf.com International Rectifier]
| [http://www.mikrocontroller.net/part/IRLML6402 IRLML6402]
| Micro 3/SOT23
| -20 V p-Channel MOSFET
| keine
| nein
| -
|}

=== USB 2 UART ===

von User: [http://www.mikrocontroller.net/user/show/chrisw84 Chris W.] Link [[Datei:FT2232D.lbr]]

Anwendungen: USB to Dual Port RS232 Converters, USB to Dual Port RS422 / RS485, USB JTAG Programming, USB to SPI Bus Interfaces
{| {{Tabelle}} class="sortable" id="FT2232D.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler 
|-

| [http://www.ftdichip.com FTDI]
| [http://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT2232D.pdf FT2232D]
| LQFP 48
| - USB zu Dual UART
| Pin-Directions müssen nach Anwendungsfall angepasst werden!
| nein
| -
|}

=== Ethernet-Controller von ASIX Electronics Corporation ===

Von User: Steffen H.
Link: [[Datei:asix-v3.lbr]]

Ethernet Controller, die man auch mit kleineren MCU's betreiben kann. Der neue AX88796C kann auch mit max. 40MHz SPI betrieben werden. Besonderes Feature: IPv4/IPv6 packet Checksum Offload Engine to reduce CPU loading,
including IPv4 IP/TCP/UDP/ICMP/IGMP & IPv6 TCP/UDP/ICM Pv6 checksum generation & check

{| {{Tabelle}} class="sortable" id="asix-v3.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler
|-

| ASIX
| [http://www.asix.com.tw/products.php?op=ProductList&PLine=65&PSeries=86 AX88796B]
| LQFP-64
| 8/16-bit 10/100M Fast Ethernet Controller
| keine
| nein
|
|-

| ASIX
| [http://www.asix.com.tw/products.php?op=ProductList&PLine=65&PSeries=86 AX88796C]
| LQFP-64
| SPI(40MHz)/8/16-bit 10/100M Fast Ethernet Controller
| keine
| nein
|
|-

| ASIX
| [http://www.asix.com.tw/products.php?op=ProductList&PLine=65&PSeries=86 AX88796L]
| LQFP-128
| 8/16-bit 10/100M Fast Ethernet Controller, Print Port for printer server
| keine
| nein
|
|}

=== ISSI High-speed CMOS STATIC RAM ===

Von User: Steffen H.
Link: [[Datei:issi.lbr]]

{| {{Tabelle}} class="sortable" id="asix-v3.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler
|-

| ISSI
| [http://www.icsi.com.tw IS62LV256L]
| 28-Pin TSOP-1
| High-speed 32K x 8 Low Power SRAM with 3.3V
| Footprint n. IPC7351A
| nein
|
|}

=== RFT-Opto Bauelemente ===

von User: [http://www.mikrocontroller.net/user/show/muetze1 Muetze1] Link [[Datei:rft-opto.lbr]]

Enthält (bisher) die gängisten RFT LED Segment-Anzeigen

{| {{Tabelle}} class="sortable" id="rft-opto.lbr"
|- bgcolor="#eeeeee"
! Hersteller
! Bezeichnung
! Gehäuse
! Beschreibung
! Anmerkungen
! Reviewed?
! Fehler 
|-

| RFT
| VQB 37
| TGL 32989
| 7-Segment-Miniatur-Anzeige mit gemeinsamer Katode und Linse, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 71
| TGL 31245
| 7-Segment-Anzeige mit gemeinsamer Anode und Dezimalpunkt, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 73
| TGL 31245
| 4-Segment Vorzeichen Anzeige mit gemeinsamer Anode, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 76, VQB 76/1
| TGL ???
| 7-Segment-Anzeige in DIL Format mit Dezimalpunkt, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 16
| TGL 55111
| Vorzeichen + 1, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 17
| TGL 55111
| 7 Segmentanzeige mit DP, gemeinsame Katode, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 18
| TGL 55111
| 7 Segmentanzeige mit DP, gemeinsame Anode, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 26
| TGL 55111
| Vorzeichen + 1, grünstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 27
| TGL 55111
| 7 Segmentanzeige mit DP, gemeinsame Katode, grünstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 28
| TGL 55111
| 7 Segmentanzeige mit DP, gemeinsame Anode, grünstrahlend
| keine
| nein
| -
|-

| RFT
| VQB 200
| TGL 42170
| 16-Segment-Anzeige mit Dezimalpunkt, grünstrahlend, gemeinsame Katode
| keine
| nein
| -
|-

| RFT
| VQB 201
| TGL 42170
| 16-Segment-Anzeige mit Dezimalpunkt, grünstrahlend, gemeinsame Anode
| keine
| nein
| -
|-

| RFT
| VQC 10
| TGL ???
| 4-stellige 5x7 Puntmatrix, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQE 11
| TGL 55110
| 1 1/2 stellige 7-Segment-Anzeige mit Vorzeichen und gemeinsamer Katode, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQE 12
| TGL 55110
| 1 1/2 stellige 7-Segment-Anzeige mit Vorzeichen und gemeinsamer Anode, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQE 13
| TGL 55110
| 2 stellige 7-Segment-Anzeige mit gemeinsamer Katode, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQE 14
| TGL 55110
| 2 stellige 7-Segment-Anzeige mit gemeinsamer Anode, rotstrahlend
| keine
| nein
| -
|-

| RFT
| VQE 21
| TGL 39352
| 1 1/2 stellige 7-Segment-Anzeige mit Vorzeichen und gemeinsamer Katode, grünstrahlend
| keine
| nein
| -
|-

| RFT
| VQE 22
| TGL 39352
| 1 1/2 stellige 7-Segment-Anzeige mit Vorzeichen und gemeinsamer Anode, grünstrahlend
| keine
| nein
| -
|-

| RFT
| VQE 23
| TGL 39352
| 2 stellige 7-Segment-Anzeige mit gemeinsamer Katode, grünstrahlend
| keine
| nein
| -
|-

| RFT
| VQE 24
| TGL 39352
| 2 stellige 7-Segment-Anzeige mit gemeinsamer Anode, grünstrahlend
| keine
| nein
| -
|-

| RFT
| MQE 10
| TGL ???
| 3-fach 7-Segment-Anzeige mit integrierten A/D Wandler (C 520)
| keine
| nein
| -
|}

[[Kategorie:Eagle]]

Pegelwandler

2011-12-05T07:17:03Z

Jackfritt: /* 5V -> 9..15V */

== Vorwort ==

Dies ist die erste aufgeräumte Version. Sicher nicht die letzte.

* [http://www.mikrocontroller.net/forum/read-1-375051.html "Stein des Anstosses"]
* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=pegelwand*+levelsh*&x=0&y=0 Suche in den Forenartikel]

== Einleitung ==

Pegelwandeln (engl. level shifting) wird oft notwendig, wenn Systeme mit unterschiedlicher Ausgangs- und Eingangsspannungen (z. B. Versorgungs- oder Logikspannungen) miteinander verbunden werden sollen. Das vielleicht bekannteste Beispiel ist die Umsetzung von 0V/5V [[TTL]] Logikpegeln auf die -12V/12V Pegel einer seriellen [[RS232]] Schnittstelle. Die Probleme beim Pegelwandeln können sein:

# Überlastung einer oder beider Seiten
# Inkompatible Logikpegel und daraus resultierendes Nichtfunktionieren der Schaltung, oder noch schlimmer, sporadische Fehlfunktionen
# Verzögerungen der Signale durch die Pegelwandlung und daraus resultierende maximale Signalfrequenzen

=== Überlastung ===

Das Erzeugen von verschiedenen Versorgungsspannungen ist ziemlich einfach, aber man muss sicher gehen, daß man die Signalleitungen zwischen den Bauteilen überprüft. Wenn ein 5V Bauteil ein Signal an ein 3V Bauteil schickt, können beide Bauteile beschädigt werden. Vor allem für neue ICs ist es ein Problem mit "hohen" Spannungen wie 5V zu arbeiten. Auf Grund der immer kleineren Schaltkreisstrukturen (der aktuelle Pentium wird mit 45nm Technologie hergestellt!) werden auch die Abstände und Schichtdicken immer geringer. Das reduziert natürlich auch die Spannungsfestigkeit der Transistoren auf dem IC. Neue ICs vertragen deshalb meist nur noch 3.3V, teilweise sogar weniger! Die Überlastung erfolgt durch zu hohe Spannung und dadurch mehr oder weniger langsame Zerstörung des ICs.

=== Schutzdioden ===

Hauptursache Nummer zwei für Überlastung von ICs mit verschiedenen Betriebsspannungen sind die in nahezu allen ICs integrierten Schutzdioden. Deren Aufgabe ist es in Normalfall, elektrostatische Entladungen auf eine sichere, niedrige Spannung zu begrenzen. Die Entladungen geschehen durch unsachgemässe Handhabung und Transport von ICs, z. B. wenn jemand über einen Kunstfaserteppich läuft, sich dabei elektrostatisch auflädt und einen IC anfasst. Oder wenn Bauteile in einem Gerät eingebaut sind und der Anwender berührt offen liegende Kontakte (RS232 Eingang, USB-Stick, PCI-Steckkarten beim Einbau etc.). Die Schutzdioden beginnen Strom zu leiten, wenn die Eingangsspannung ca. 500mV über VCC ansteigt oder mehr als 500mV unter GND absinkt. Im Normalbetrieb sollten die Schutzdioden keinen Strom leiten. Manchmal kann man sie aber zur Spannungsbegrenzung missbrauchen, siehe [[#STEP-DOWN:_5V_-.3E_3.3V | Step Down mit Vorwiderstand]].

[[bild:pw_schutzdioden.png]]

=== 5 V tolerante Eingänge ===

5 Volt tolerant bedeutet, daß 3 Volt Bausteine ohne Probleme von einem 5 Volt Baustein angesteuert werden können.

Viele Bauteile mit einer Betriebsspannung von 3 V verfügen über 5 V tolerante Eingänge. Man sollte aber grundsätzlich im Datenblatt darüber nachlesen, bevor die Schaltung aufgebaut wird. Sind sie es nicht, so ist ein Pegelwandler auf den Verbindungsleitungen zwischen den Bauteilen notwendig. Ein Pegelwandler kann eine einfache Zener-Diode mit einem Widerstand sein, es kann aber auch ein eigens dafür vorgesehener IC sein. Sind die Signalwege bidirektional, so wird man meist die Lösung mit einem eigenen IC bevorzugen.

[[AVR]]s sind generell '''nicht''' 5V tolerant, wenn sie mit 3.3V betrieben werden! Die absolute obere Grenze für Eingangsspannungen liegt bei Vcc + 0.5V. Zu finden in den elektrischen Spezifikationen im Datenblatt.

Ob ein Bauteil 5V-tolerant ist und unter welchen Betriebsbedingungen das gilt steht im Datenblatt des betreffenden Bauteils vom betreffenden Hersteller. Wenn es auf diese Eigenschaft ankommt, lieber genau bei Lieferanten nachsehen, von welchem Hersteller die Bauteile kommen.

Vorsicht bei:

* 74'''LVX'''xxxx und 74'''LCX'''xxxx (245, 244, 240 ...) an Vcc=3,3V. Achtung: Nicht alle 74LVX sind für 5V -> 3,3V geeignet, da jeder Hersteller die ICs anders baut!

=== Kompatibilität von Logikpegeln ===

Siehe auch http://www.interfacebus.com/Design_Translation.html

Verschiedene Mikroprozessoren haben eigene elektrische Kenndaten für HIGH und LOW Pegel, die abhängig von der Versorgungsspannung sind z. B. der [[R8C]]:

* HIGH grösser 0.8 * Vcc
* LOW kleiner 0.2 * Vcc

Man muss die Spannungen der Aus-und Eingänge vergleichen. Wenn es um ein Hobbyprojekt geht kann man einfach messen. Wenn es um eine kommerzielle Anwendung geht die man verkaufen will, sollte man besser die Spezifikationen der ICs studieren.

== UNIDIREKTIONAL ==

=== 1.8V -> 5V ===

* Die besondere Eigenschaft der alten TTL Schaltkreise, nämlich daß Strom bei LOW '''aus''' dem Eingang in den treibenden Ausgang fliesst kann man sich zu nutze machen wie die nachfolgende Schaltung zeigt. Dabei wird der HIGH-Pegel des 1,8V Signals durch eine Schottkydiode um ca. 0,3V auf 2,1V erhöht. Damit ist man fast offiziell im HIGH-Berich für TTL (Schaltschwelle 1,4V, HIGH>2.0V). Der LOW-Pegel wird auf ca. 0,3V erhöht, was voll den TTL-Richtlinien entspricht. Als Schaltkreisfamilie '''muss''' ein [[74xx|TTL-Typ]] eingesetzt werdem, also LS, F, AS oder ähnlich. CMOS-Typen wie HC, LVC etc. funktionieren '''nicht'''!

[[bild:pw_LS.png]]

'''Achtung:''' Diese Schaltung entspricht bei HIGH ungefähr einem offenen TTL-Eingang, was zwar meistens funktioniert, aber etwas störempfindlich sein kann. Davon wurde in der TTL-Ära stets abgeraten. Zudem ist der Pegelwechsel LOW nach HIGH durch den niedrigen Strom eher langsam. Man kann das jedoch mit einem Pullup-Widerstand absichern. Dann sind auch Gatter der 74HCT-Reihe einsetzbar.

=== 3.3V -> 5V ===

* 3.3V Pegel werden bei TTL kompatiblen Eingängen richtig erkannt (Schaltschwelle 1,4V). Es ist kein Pegelwandler erforderlich. Direkte Verbindung.

* 5V CMOS Eingänge haben typisch eine minimale Eingangsspannug für HIGH (<math>V_{IH}</math>) von 0.6 * VCC = 0.6 * 5V = 3V. Das kann ein 3.3V CMOS Ausgang direkt treiben, allerdings kann sich das Zeitverhalten dadurch etwas ändern weil der HIGH Pegel später erkannt wird. Vorsicht! Viele 5V CMOS ICs wollen für HIGH offiziell mindestens 0.7V * VCC = 3.5V oder manche auch 0.8 * VCC = 4.0V! Das geht dann offiziell nicht mehr mit einem 3.3V Ausgang! Für Hobbyzwecke kann man das aber ggf. probieren.

* 3.3V [[Ausgangsstufen_Logik-ICs | Open Collector]] nach 5V (TTL oder CMOS): Einfach einen Pull-Up Widerstand hinzufügen und gut. Allerdings verbraucht der Pull-Up Widerstand bei LOW relativ viel Strom und kann bei HIGH nicht allzuviel Strom liefern. Die Schaltgeschwindigkeit von LOW nach HIGH wird durch die Grösse des Pull-Ups bestimmt.

[[bild:pw_oc_3-5.png]]

* 3,3V auf echte 5V (CMOS) geht am einfachsten mit einem Baustein der HCT Familie (NICHT HC !). Diese haben TTL-compatible Eingänge und echte CMOS Ausgänge

* Man kann einen Komparator in nichtinvertierender Schaltung benutzen (LM339/393). Allerdings ist diese Lösung meist relativ langsam, abhängig vom verwendeten Komparator.

[[bild:pw_comp_3-5.png]]

'''Bauteile'''

* 74HCTxxx (245, 244, 240 ...)
* 74HCT125: OE Pins auf Masse und dann das Signal einfach anschließen.
* SN74LVC07AD

=== 5V -> 9..15V ===

* Am einfachsten geht das mit einem Open Collector Ausgang, einfach einen Pull-Up hinzufügen (an die hohe Spannung) und fertig.

[[bild:pw_oc_5-12.png]]

* Man kann einen Komparator benutzen. Allerdings ist diese Lösung meist relativ langsam, abhängig vom verwendeten Komparator. Wenn nur zwei Signale pegelgewandlet werden müssen bietet sich der LM393 an, ein Doppelkomparator mit Open Collector Ausgang, mit dem man auf einen beliebigen Pegel ausgeben kann. Der LM339 ist ein Vierfachkomparator mit den gleichen Eigenschaften. Wenn wenig Platz vorhanden ist, dann ist der TL311 im winzigen SOT-23 Gehäuse sehr empfehlenswert. Bei jedem Komparator kann auch einfach eine Invertierung gemacht werden, einfach die Eingänge + und - vertauschen. Diese Komparatoren eignen sich bis ca. 1 MHz.

* [http://www.elektronik-kompendium.de/sites/praxis/bausatz_pegelwandler-mit-transistoren.htm Pegelwandler mit Transistor, invertierend]

[[bild:pw_trans_inv.png]]

* Pegelwandler mit Transistor, nicht invertierend

[[bild:pw_trans_ni.png]]

Die Idee ist einfach. Wenn der Ausgang des 5V Gatters auf HIGH ist dann ist der Transistor ausgeschaltet, der Pull-Up Widerstand R7 zieht den Ausgang auf +12V. Ist der Ausgang des 5V Gatters auf LOW ist, dann ist er vollkommen durchgesteuert und der Ausgang nahe 0V (je nach Typ ca. 300mV). Der Vorteil ist hier erhöhte Störsicherheit im Gegensatz zur einfachen Ansteuerung der Basis über einen Vorwiderstand. Ausserdem wird dadurch nicht die Logik invertiert. Nachteilig ist der geringe Strom, der bei HIGH zur Verfügung steht (typisch 100μA). Diese Schaltung ist die seltene Anwendung einer Basisschaltung für digitale Signale.

* Wenn mehr Geschwindigkeit, Ausgangsstrom und weniger Stromverbrauch nötig ist, dann muss ein spezieller Baustein her, wie z. B. 
** [[Mosfet-Übersicht#Mosfet-Treiber|MOSFET-Treiber]] z.B. ICL7667
** [[H-Brücken Übersicht | Motortreiber]] ICs: (z. B. L293, L298, UCC27325 und deren Verwandte), wenns nicht zu schnell ist (einige Dutzend kHz)
** CD40109, bei Reichelt verfügbar
** HEF4104, 4fach LOW-HIGH Pegelwandler mit normalen und invertierten Augängen sowie Tristate. Um ggf. sicherzustellen, dass wie im Datenblatt beschrieben immer VDDI <= VDDO ist, kann man einfach eine Diode von VDDO nach VDDI schalten (z. B. Schottky SB120, aber auch 1N4148 & Co sollte problemlos funktionieren)
** CMOS 4504, 6fach LOW-HIGH/HIGH-LOW 3-20V Pegelwandler, TTL/CMOS (umschaltbar) => CMOS, kein Reihenfolge von Vcc/Vee erforderlich (Bezugsquelle: CSD)
** MAX232, der braucht nur 5V Versorgungsspannung. Allerdings ist der Ausgangswiderstand relativ hoch (ca. 300Ω) und man kann nur ca. 5mA Ausgangstrom liefern. Die Ausgangsspannung beträgt maximal 10V.

=== 5V -> 3.3V ===

* Zuerst sollte man prüfen, ob die Eingänge 5V tolerant sind. Dann kann man die ICs direkt verbinden. Sehr schnell und billig!

* Wenn die Eingänge nicht 5V tolerant sind und es trotzdem schnell sein soll, muss ein Gatter aus der LVC oder AHC Familie dazwischen geschaltet werden. Bei 3V Betriebsspannung kann man problemlos 5V an den Eingang anlegen. Der Baustein 74HC4050 erlaubt per Definition eine Pegelwandlung bis etwa 15V (siehe Datenblatt). Beide Anordungen verbrauchen auch sehr wenig Ruhestrom.

: '''Bauteile'''

:* 74LVC245A ('A' ist wichtig, I/Os 5V-tolerant)
:* 74LVC245DW
:* 74LVT245
:* 74LVXxxx (245, 244, 240 ...) an Vcc=3,3V. Achtung: Nicht alle 74LVX sind für 5V -> 3,3V geeignet, da jeder Hersteller die ICs anders baut!
:** 74LVX04
:** 74LVX244 (Fairchild)
:** 74LVX245 (nicht von Reichelt, nicht 5V tolerant)

:* 74HC4050 (bis 15V Step Down Pegelwandlung laut Datenblatt, bei Reichelt in DIP und SO erhältlich)
:* MAX3373/MAX3375
:* NC7SZ08 oder andere aus derselben Serie. CMOS-Logik mit 5V-toleranten Eingängen, recht flott und braucht dank SOT-23 auch wenig Platz auf dem Print

* 5V Open Collector auf 3.3V Eingang. Einfach einen Pull-Up hinzufügen (Pull-Up liegt auf 3.3V). Nachteilig ist der relativ hohe Stromverbrauch bei LOW, die begrenzte Geschwindigkeit bei hochohmigen Pull-Ups und der relativ geringe Ausgangsstrom bei HIGH (abhängig vom Pull-Up).

[[bild:pw_oc_5-3.png]]

* Spannungsteiler mit 680Ω und 1kOhm. Der Nachteil dieser Lösung ist der relativ hohe Stromverbrauch (~3mA), der relativ geringe Ausgangsstrom (mehr als 200..300uA sollte man da nicht rausziehen) und die relativ geringe Geschwindigkeit (ca. 10 MHz).

[[bild:pw_st_5-3.png]]

* 1 kOhm Vorwiderstand. Dadurch wird der Strom vom 5V Ausgang in die 3.3V Versorgung durch die internen Schutzdioden auf ca. 1mA begrenzt. Diese Lösung ist auch relativ langsam (ca. 5MHz). Ggf. kann man den Vorwiderstand auf 100Ω reduzieren, das erhöht dann wieder die Geschwindigkeit. Aufpassen, einige ICs vertragen nur 1mA oder weniger durch die Schutzdioden! Ausserdem muss man aufpassen, das jetzt von der 5V Seite Strom in die 3.3V Versorgung eingespeist wird. Besonders in Schaltungen mit sehr niedrigem Stromverbrauch kann das zum Problem werden, wenn weniger Strom verbraucht wird als über die Vorwiderstände eingespeist wird. Dann nimmt es meist der Spannungsregler für 3.3V übel wenn jemand "schiebt", sprich, Strom einspeist. Denn die allermeisten Spannungsregler können nur Strom liefern (source), aber keinen Strom aufnehmen (sink). Es gibt 4-fach-Diodennetzwerke, die die internen Schutzdioden entlasten können (Schottkydioden mit kleinerer Flusspannung von ~0,3V als die internen Silizizumdioden mit ~0,7V), außerdem ist teilweise noch eine [[Diode#Z-Diode|Zenerdiode]] enthalten, die ggf. den überschüssig eingespeisten Strom aufnehmen kann.

[[bild:pw_vw_5-3.png]]

Achtung: Mindestens für 74HC(T) Gatter ist dokumentiert (Philips 74HC/T High-Speed CMOS User Guide), dass auch schon geringer Strom durch die internen Schutzdioden zu einer unerwünschten Kopplung von Eingängen führen kann, d.h. der Strom fliesst zu einem anderen Eingang wieder hinaus. Sind also andere Eingänge ebenso hochohmig angeschlossen, kann dieser Querstrom zu Fehlfunktion führen.

== BIDIREKTIONAL ==

Für bidirektionale Busse gibt es spezielle Pegelwandler mit 2 Versorgungsspannungen. Allerdings brauchen die meist ein Signal zur Richtungsumschaltung. Auch muss man die Reihenfolge der Versorgungsspannungen beim Einschalten beachten. Aktive bidirektionale Pegelwandler OHNE Steuereingang zur Richtungsumschaltung sind mit Vorsicht zu geniessen, denn die brauchen teilweise kurzzeitig einen relativ hohen Strom, um die Eingänge zu treiben.

=== 5V <-> 3.3V ===

* Wenn die 5V Seite TTL-kompatible Eingänge hat kann wieder der Spannungsteiler oder Vorwiderstand wie bei der unidirektionalen Anpassung verwendet werden (mit all seinen Vor- und Nachteilen).

'''Bauteile'''

* SN74CB3T3306
* SN74CBTD3861 (10 Bit,flow through, Betrieb mit 5 Volt)
* MAX1741
* MAX3378E
* 74AHC126 s.u.
* ST2378 (bei CSD erhältlich, 3.5 eur, leider TSSOP)
* TXS0104E (TI: 4-BIT BIDIRECTIONAL VOLTAGE-LEVEL TRANSLATOR FOR OPEN-DRAIN AND PUSH-PULL APPLICATIONS)
* SN74LVC07A

=== 1,65V...5,5V <-> 1,65V...5,5V ===

'''Bauteile'''
* SN74LVC1T45
* SN74LVC2T45
* SN74LVC(H)8T245
* SN74LVC(H)16T245

=== 1,2V...3,6V <-> 1,65V...5,5V ===

'''Bauteile'''
* TXB0101
* TXB0102
* TXB0104
* TXB0106
* TXB0108

=== 1,2V...3,6V <-> 1,2V...3,6V ===

'''Bauteile'''
* SN74AVC(H)1T45
* SN74AVC(H)2T45
* SN74AVC(H)4T245
* SN74AVC(H)8T245
* SN74AVC(H)16T245
* SN74AVC(H)20T245
* SN74AVC(H)24T245
* SN74AVC(H)32T245

=== 1,5V...3,6V <-> 1,5V...5,5V ===

'''Bauteile'''
* 74LVC4245A

== Mit galvanischer Trennung ==

* [[Optokoppler]]

[[bild:pw_opto.png]]

* GMR-Koppler von der Firma NVE
* iCoupler Technologie von der Firma Analog Devices
* [[Kapazitiver Koppler]]

Lit.: ''Galvanische Trennung: Optokoppler, GMR-Koppler oder iCoupler?'', Siegfried W. Best, Redaktion elektronik industrie, [http://www.elektronik-industrie.de/ei/11,2003/article/2f0082f824c.html elektronik industrie 11-2003, S. 22ff.]

== Praktische Beispiele ==

=== Einfaches RS232-Interface ===

[http://web.archive.org/web/20050122013618/http://www.henrik-reimers.de/control/rs232interface.gif Erfolgreicher Einsatz bis 19200 Baud und bis zu 10 m Leitungslänge]

Beschränkungen:

* ggf. Platzbedarf
* Geschwindigkeit s.o.

Beispiel: http://www.hagtech.com/pdf/translator.pdf

=== [[I2C]]-Bus: gemeinsam 3.3V und 5V ===

* [[MSP430]] an 3,3V/5V: http://www-s.ti.com/sc/psheets/slaa148/slaa148.pdf

* Philips PCA9515: I2C Puffer mit Pegelwandlung. Der PCA9515 ist ein I2C-Bus Repeater, welcher I2C Busse mit verschiedenen Spannungen isoliert. Verfügbar bei Reichelt und DigiKey.

* [http://www.standardics.philips.com/support/documents/i2c/pdf/an97055.pdf Philips AN97055 Bi-directional level shifter for I²C-bus and other systems]

* Bevor man ein Philips I2C Chip auswählt sollte man prüfen ob er verfügbar ist und auch das verfügbare Gehäuse wählen. Man sollte auch überlegen ob ein Puffer wirklich gebraucht wird. Wenn man echte I2C ICs mit 5V betreibt, dann sind die Eingänge vom Typ Schmitt Trigger CMOS (z. B. PCF8574). Dann müssen 3.3V Pegel auf 5V umgesetzt werden. Wenn man jedoch SMBUS Ics verwendet (z. B. ADT7461, Silabs 8051) dann sind die Schwellspannungen TTL kompatibel und es ist keine Anpassung notwendig. Für neue Pegelwandler sollte man hier nachschauen. http://www.bus-buffer.com

* [http://www.edn.com/article/CA193193.html "Two-transistor circuit replaces IC"]. Für diese Anwendung kann ENABLE direkt mit 3.3V verbunden werden. Es ist eigentlich nur dazu da, den ICs "hot-swappable" zu machen (kann unter Spannung gesteckt und getrennt werden). Es geht sogar mit nur einem [[Transistor]] [http://www.mikrocontroller.net/topic/92447 siehe Forum]. Man sollte beachten, daß die Schaltung sowohl für SCL als auch SDA benötigt wird.
* Noch einfachere Lösungen mit nur einem MOSFET und zwei Pull-Up Widerständen pro Leitung sind in den folgenden Links zu finden. Vielleicht ist es sogar noch billiger Bipolartransistoren zu verwenden.
** http://www.semiconductors.philips.com/markets/mms/protocols/i2c/facts/#levelshifting
** http://www.semiconductors.philips.com/acrobat_download/literature/9398/39340011.pdf

=== Auswählbare Pegel ===

'''Frage:'''
Ein CMOS Logikpegel zwischen 1,8V, 2,5V und 3,3V (abhängig von der Anwendung) muss auf 5V CMOS Logikpegel gewandelt werden. Es geht nur um diese Richtung mit maximal 8MHz. Es gibt die Stromversorgung für alle Pegel. Ein normaler Komparator wie LM311 ist nicht möglich, da er beim Betrieb mit 5V Versorgunsspannung erst ab 1V zu schalten anfängt. Meine Idee ist die Verwendung eines High Speed OPVs mit R2R Eingang, z. B. LMH6645.

'''Antworten:'''
* Man könnte einen ultra-low threshold N-Kanal MOSFET nehmen und als Open Drain mit einem Pull-Up nach 5V betreiben, BSH103 könnte passen (Schwellspannung ~0,4V).
* High-Speed Single Supply Komparator wie z. B. [http://www-s.ti.com/sc/ds/tl712.pdf TL712] .

'''Frage:'''
Ich suchen einen IC, welcher eine Pegelwandlung von 3,3V nach 1,8V, 2,0V oder 5V ermöglicht und während des Betriebs umgeschaltet werden kann.

'''Antworten:'''
* So ein IC ist der Linear [http://www.linear.com/pc/productDetail.jsp?navId=H0,C1,C1007,C1071,P1601 LTC1555L-1.8] .

=== AVR SPI (SDC/MMC)===

Für '''bidirektionalen Betrieb''' zwischen 5V-AVR und 3,3V-Geräten und anders herum gibt es den Level-Translator '''MAX3378E''' von Maxim.

Wenn die Datenrichtung am SPI im Zielsystem festgelegt ist, reichen '''unidirektionale Bausteine''':
* 3x von 5V nach 3,3V und 1x von 3,3V nach 5V: '''MAX3392E'''
* 1x von 5V nach 3,3V und 3x von 3,3V nach 5V: '''MAX3390E'''

Zum Anschließen einer SDC/MMC an einen 5V-AVR eignen sich somit der MAX3978E und der MAX3392E. Beide sind u.A. im winzigen TSSOP-14-Gehäuse verfügbar, nehmen sehr wenig Energie auf und eignen sich auch für andere Spannungen. Mit 3,3 und 5V beträgt die garantierte Übertragungsrate 8Mbps.

* [http://datasheets.maxim-ic.com/en/ds/MAX3372E-MAX3393E.pdf Datenblatt]

Eine weitere Möglichkeit zum Übersetzen zwischen 3,3 und 5V liegt in der Verwendung des '''74LVC245'''.

5V-AVR an eine MMC (ohne Level-Shifter-Baustein):
* [http://www.microsyl.com/index.php/2010/03/24/led-sign-with-mmc-memory-card/ Projektseite]
* [http://www.microsyl.com/projects/ledsign/ledsign1.pdf Schaltplan]

=== µC <-> Parallelport ([[ISP]]-Dongle, [[JTAG]] Wiggler, ...) ===

Dieser Schaltplan funktioniert auch bei 3.3V wenn man einen 74HC244 anstatt eines 74LS244 verwendet: [http://www.epanorama.net/circuits/parallel_output.html Parallel port interfacing made easy: Simple circuits and programs to show how to use PC parallel port output capabilities].

=== 2 Leitungspaare RX/TX 5V/3,3V ===

Der [http://www.hackaday.com/2008/06/19/sparkfuns-logic-level-converter/ SparkFun's Logic Level Converter] ist eine Baugruppe mit MOSFETs [http://www.fairchildsemi.com/pf/BS/BSS138.html BSS138] für die Pegelwandlung von 5V auf 3,3V. 5V/2,8V und 5V/1,8V sind ebenfalls machbar.

= Bauteile =

* '''74ALVC164245''' - ''16bit dual supply translating transceiver''. Eine Seite von 1.5V bis 3.6V, die andere von 1.5 bis 5.5V.
* '''74LVX573''' (unidirektional, Latch, nicht alle Hersteller bauen diesen 5V tolerant!)
* '''74LVX245''' (bidirektional, nicht alle Hersteller bauen diesen 5V tolerant!)
* '''74LVX125''' - ''Low Voltage Quad Buffer with 3-STATE Outputs''. http://www.fairchildsemi.com/pf/74/74LVX125.html
* '''SN74LVC2T45'''
* '''SN74LVC8T245''' - ''8-Bit Dual-Supply Bus Transceiver with Configurable Voltage Translation and Three-State Outputs''. http://focus.ti.com/docs/prod/folders/print/sn74lvc8t245.html
* '''74LCX244MSA''' von Fairchild.
* '''MAX3377'''
* '''MAX3000''' 8-Kanal bidirektioneler Pegelwandler ohne Richtungsumschaltung

Vierfachdioden im kleinen 6-poligen SMD-Gehäuse:
* http://www.st.com/stonline/products/literature/ds/12635/dsilc6-4xx.pdf
* http://www.st.com/stonline/products/literature/ds/11599.pdf
* http://www.st.com/stonline/products/literature/ds/6477/dalc208.pdf
* [http://www.diodes.com/datasheets/ds30195.pdf QSBT40, vierfach Schottky Terminator für Datenleitungen]
* [http://www.littlefuse.com/data/en/Data_Sheets/SP724Lead_Free.pdf SP724, Siliziumschutzarray]

= Weblinks =

* Gaurang Kavaiya, [http://www.edn.com/contents/images/6335309.pdf Don’t pay for level translators in systems using multiple power-supply voltages], EDN, MAY 25, 2006, 81-86 (PDF)
* [http://www.elektronik-kompendium.de/public/schaerer/scf3_lc.htm Einfacher Pegelwandler im ELKO]
* [http://www.prog-link.com/dcf77/dcf77-17.html Pegelwandler für DFC77 Module]
* [http://elektronik.kai-uwe-schmidt.de/index.php?page=mp3_blueschaltung Pegelwandler für [[I2C]] Bus in einem MP3 Palyer]
* [http://www.mikrocontroller.net/attachment.php/256452/levelshifter.pdf Application Note von Philips, I2C Pegelwandler]
* [http://www.semiconductors.philips.com/acrobat_download/literature/9398/39340011.pdf I2C Spezifikation]
* [http://www.mikrocontroller.net/forum/read-1-234277.html#new Forumsbeitrag zum Themas 1,8V-5V Pegelwandler]
* [http://www.st.com/stonline/products/literature/ds/5186/74lcx16245.pdf 74LCX16245, 16 Bit Pegelwandler]
* [http://www.standardics.nxp.com/products/lvc/buffers/ LVC Logikfamilie]
* [http://www.standardics.nxp.com/products/lvc/transceivers/ LVC Tranceiver]
* [http://www.microchip.com/stellent/groups/techpub_sg/documents/devicedoc/en026368.pdf 3V Tips ‘n Tricks] (PDF) von Microchip

[[Category:Bauteile]]
[[Kategorie:Datenübertragung]]

Snippets

2011-12-01T09:18:02Z

Jackfritt: /* AVR: ADC */

Auf dieser Seite können kleine, oft verwendbare Quelltextchen und Designideen (Snippets) abgelegt und abgerufen werden.

Bitte die Snippets universell verwendbar halten und für Dritte ausführlich und verständlich kommentieren.

== Software-Snippets ==

=== AVR: ADC ===

Die folgenden Routinen sind einfachste C-Funktionen zum Auslesen des [[AD-Wandler]]s eines AVR. Die Registernamen bitte an den konkret verwendeten AVR anpassen (Datenblatt).

Anm.: Umfangreichere Routinen mit Mittelwertbildung usw. finden sich im [[AVR-GCC-Tutorial#Analoge_Ein-_und_Ausgabe|AVR-GCC-Tutorial: Analoge Ein- und Ausgabe]].

'''Auslesen eines Analogports'''

<c>
// Führt eine AD Konversion durch und
// liefert den Wert (0-1023) von PORT ADC(src) zurück

uint16_t ReadValue(uint8_t src)
{
ADMUX = src;
ADCSR = _BV(ADEN) | _BV(ADSC) | _BV(ADPS2);
while (bit_is_set (ADCSR, ADSC));
return ADC;
}
</c>

Anmerkungen:
* ADMUX Parameter siehe Datenblatt (nicht gleich "Pinnummer")
* ADSC/ADEN/ADPS2 Parameter siehe Datenblatt
* Einstellung der Referenzspannung beachten (Intern/Extern)
* Wandlerfrequenz an Genauigkeitsansprüche anpassen und nach Empfehlungen des Datenblatts in abh. vom "Haupttakt" einstellen
* ADEN nach erstmaligem Einschalten redundant
* evtl. Dummy Readout durchfuehren

''' Umrechnung Wandlungsergebnis in gemessene Spannung'''

<c>
// Liefert die am ADC anliegende Spannung in mV zurück
#define ADC_CONV_CONST 5000/1024 // Spannung pro LSB (10 bit Wandler)
#define ADC_CORR_VAL (ADC*8)/9 // bei 5V Ref-Spannung erhält man mit dieser korrektur 5001mV bei einem ADC-Wert von 1023!
// Für eine fehlerfreie Umwandlung ist eine Referenz von z.b 4.096V oder 2.56V notwendig...
uint16_t ReadValue(uint8_t src) {
ADMUX = src;
ADCSR = _BV(ADEN) | _BV(ADSC) | _BV(ADPS2);

while (bit_is_set (ADCSR, ADSC))
asm volatile ("nop");

return ADC*ADC_CONV_CONST+ADC_CORR_VAL;
}
</c>

Anmerkungen:
* Das ''asm volatile'' Statement verhindert ein Wegoptimieren der Schleife.

== Hardware-Snippets ==

=== Wie schließe ich ein "LC-Display" an einen Mikrocontroller an? ===

Siehe [[AVR-GCC-Tutorial#Ansteuerung_eines_LCD|AVR-GCC-Tutorial: Ansteuerung eines LCD]] und [[LCD]].

===Wie schließe ich einen MOSFET an einen Mikrocontroller an?===

In folgenden sind keine konkreten Typen für die MOS[[FET]]s genannt. Typen findet man in der [[Mosfet-Übersicht]] und in den parametrischen Suchmaschinen der Hersteller. Die genauen Daten und Belastungsgrenzen sind dann aus den Datenblättern zu entnehmen und für die geplante Schaltung zu prüfen.

==> * [[FET]]
====Direkte Methode: N-Kanal MOSFET (NFET)====

<pre>
(VCC)
|
(Last)
|
|
(Drain )
(Port µC) -----(Gate )
(Source)
|
|
(GND)
</pre>

Ausschlaggebend für die Steuerung ist die Gate-Source-Spannung. In dieser einfachen Schaltung ist das also die Spannung am Port des µC minus die Spannung an Source (= GND = 0V). Diese Spannung ist positiv!
Wenn diese einen Schwellwert überschreitet, dann sinkt der Drain-Source-Widerstand (RDSon)schlagartig auf ein Minimum. Übliche Werte liegen bei 0.1Ω, dieser Widerstand ist aber von dem Drain-Source-Strom und der Gate-Source-Spannung abhängig.
Der Umschaltpunkt (Spannung und Widerstand) kann im Datenblatt in den "RDSon vs. VGS" Diagramm abgelesen werden.

====Direkte Methode: P-Kanal MOSFETs (PFET)====

<pre>
(VCC)
|
|
(Source)
(Port µC) -----(Gate )
(Drain )
|
|
(Last)
|
(GND)
</pre>

Ausschlaggebend für die Steuerung ist die Gate-Source-Spannung. In dieser einfachen Schaltung ist das also die Spannung am Port des µC minus die Spannung an Source (= VCC). Diese Spannung ist negativ!
Wenn diese einen Schwellwert unterschreitet, dann sinkt der Drain-Source-Widerstand (RDSon)schlagartig auf ein Minimum. Übliche Werte liegen bei 0.1Ω, dieser Widerstand ist aber von dem Drain-Source-Strom und der Gate-Source-Spannung abhängig.
Der Umschaltpunkt (Spannung und Widerstand) kann im Datenblatt in den "RDSon vs. VGS" Diagramm abgelesen werden.

'''Anmerkungen'''

Zu beachten ist, dass zwischen Gate und Source und zwischen Gate und Drain eine Kapazität existiert, welche bei jedem Umschalt-Vorgang umgeladen werden muss. Besonders bei höheren Frequenzen (> 10kHz) ist zur Strombegrenzung zwischen Gate und Port-Pin ein Widerstand sinnvoll. Übliche Werte dafür sind 50 - 100Ω. Je höher der Widerstand ist, desto länger dauert das Umladen des Kondensators und desto langsamer schaltet der Transistor um. Daraus ergibt sich eine höhere Verlustleistung im Transistor, was unter Umständen zur Zerstörung des Transistors führen kann.

TODO: Pinbelegung eines typischen MOSFETS

====Indirekte Methode: Ansteuerungen mit Push-Pull-Transistoren====

<pre>
12V------------------------o------o---------------o-------------
| | |
| | |
.-. | |
| |2k2 | |
| |R2 | |
'-' |T2 |
| |BC338 |
| |/ |
o----| |
| |> P-FET |
| | ___ IRF4905|
o---|<-o---|___|----||-+
.---------. | 1N4148 R3 10R ||->
| | | ||-+
| | ___ |/ |
| |---|___|-----| T1 o---------
| | R1 2k2 |> BC338 | |
| µC | | .-. |
| | | | | |
| | | | | Last - 1N5819
| | | '-' ^
'---------' | | |
| | |
GND------------------------o----------------------o---------o---
(created by AACircuit v1.28.6 beta 04/19/05 www.tech-chat.de)
</pre>

Durch die beiden NPN Treibertransistoren T1 & T2 (http://www.mikrocontroller.net/part/BC338) wird das Gate des P-FET auf HIGH oder LOW gezogen.
Wenn die Basis von T1 auf LOW ist dann wird das Gate von T2 auf HIGH gezogen.
der P-FET kann natürlich auch einfach gegen einen N-FET Ausgetauscht werden, wenn man die Last zwischen +12V und Drain Schaltet.
Mit dieser Schaltung kann man einen FET mit 20kHz und mehr (laut Simulation sind auch 50kHz kein Problem) Ansteuern.
Der Strom, welcher in das Gate rein bzw. raus fliesst, kann man mit R3 begrenzt werden.
Die geschaltete Betriebsspannung darf die zulässige Gate-Source Spannung (meist 20V) bei dieser Schaltung nicht überschreiten.

Im µC Bereich können desweiteren folgende Hinweise gegeben werden:

* Es sollten sog. "Logik-Level" MOSFETS verwendet werden (Vth < 2V)
* Die Schaltleistung des FETs muss beachtet werden (Ids, VBrss)
* Beim Schalten von induktiven Lasten wie Relais, Motoren, oder auch Lasten über eine längere Zuleitung, sollten [[Relais_mit_Logik_ansteuern#Freilaufdiode|Freilaufdioden]] verwendet werden (im Schaltplan die Schottkydiode 1N5819 in Sperrrichtung über der Last.) Normale 1N400x Dioden sind zu langsam.

[[Kategorie:Algorithmen und Arithmetik]]

Operationsverstärker-Grundschaltungen

2011-11-07T12:41:39Z

Jackfritt: /* Spannungsfolger (Impedanzwandler) */

== Idealisiertes Modell eines OPV ==

=== Anschlüsse ===
Ein Operationsverstärker hat zwei Eingänge (+) und (-) und einen Ausgang
(UA). Außerdem verfügt er über eine positive und eine negative
Spannungsversorgung (V+) und (V-).

=== Spannungsversorgungen ===
Die Spannungsversorgungen sollen zunächst nicht interessieren. Sie
werden in Schaltungen oft nicht eingezeichnet.
In der Praxis ist es jedoch wichtig zu wissen, dass die Ausgangsspannung immer zwischen (V+) und (V-) liegt. Die Ausgangsspannung des OPV kommt schließlich dadurch zustande, dass der Ausgang über einen Transistor mehr oder weniger hochohmig mit den beiden Versorgungsspannungen verbunden wird.

Wenn man einen OPV also mit +5V versorgt, so kann der OPV im besten Fall am Ausgang +5V erzeugen. Man würde in diesem Fall von einem "Rail-to-Rail" Operationsverstärker sprechen.
Bei vielen Operationsverstärkern ist die maximal mögliche Ausgangsspannung geringer als die Versorgungsspannung. Ein mit +5V Spannungsversorgung beschalteter OPV kann dann beispielsweise nur +4V Ausgangsspannung erzeugen.

| \
| \
-- | - \
| \_______
| /
-- | + /
| /
| /

=== Ausgang ===
Der Ausgang des OPV ist eine ideale Spannungsquelle. Das bedeutet, dass die
Ausgangsspannung unabhängig davon ist, was ausgangsseitig an den OPV
angeschlossen wird.
In der Praxis gilt dieses Modell häufig nur bei "sinnvollen Anwendungen". So ist beispielsweise der Ausgangsstrom des OPV nach oben begrenzt (typischerweise im mA-Bereich), und manche OPV schwingen sehr leicht, wenn man sie kapazitiv belastet.

=== Eingänge ===
Die Eingänge eines OPV sind hochohmig, d. h., es handelt sich nur um "Messfühler", die keinen Strom führen.

=== Funktionsweise ===
Der OPV mißt zu jeder Zeit die Differenz <math>U_D = U(+) - U(-)</math> der
Eingangsspannungen.

Ist die Spannung an (+) größer als an (-), so erhöht der OPV die
Ausgangsspannung.
Ist die Spannung an (+) niedriger als an (-), so vermindert der OPV die
Ausgangsspannung.

Das Ergebnis dieses Vorgangs wird häufig über die Gleichung:

<math>U_a = v \cdot U_D</math>

beschrieben, wobei <math>v</math> eine sehr große Zahl (10^4...10^6) ist.

Mit Hilfe der beschriebenen Funktionsweise lassen sich alle grundlegenden Schaltungen herleiten.

=== Beispiel ===

Betrachtet wird die invertierende Grundschaltung nach Abbildung a) im Abschnitt "Verstärkergrundschaltungen".

Für die Pfeilrichtungen der Spannungen und Ströme gilt:

<math>U_e</math>: von oben nach unten

<math>I_{R3}</math>: von links nach rechts

Die Spannung am (+)Eingang ist gleich Null. Die Spannung am (-)Eingang wird durch die Spannungsquelle <math>U_e</math> und durch die im OPV befindliche und mit dem Ausgang verbundene Spannungsquelle des OPV manipuliert.

* Ist die Spannung am (-)Eingang negativ, so erhöht der Operationsverstärker die Ausgangsspannung. Dadurch wird auch die Spannung am (-)Eingang positiver. Und zwar so lange, bis die Spannung am (-)Eingang gleich groß ist, wie die Spannung am (+)Eingang, also U(-)=0V.
* Ist die Spannung am (-)Eingang positiv, so vermindert der Operationsverstärker die Ausgangsspannung. Dadurch wird auch die Spannung am (-)Eingang negativer. Und zwar so lange, bis die Spannung am (-)Eingang gleich groß ist, wie die Spannung am (+)Eingang, also U(-)=0V.

Der Operationsverstärker wird also die Spannungen an (+) und (-)
angleichen. Das passiert immer dann, wenn der Ausgang mit dem (-)Eingang
verbunden ist. Man nennt das Prinzip "Gegenkopplung". Auf diese Art und
Weise funktionieren alle analogen OPV-Schaltungen.

Da an (+) Massepotential anliegt, liegt an <math>R_3</math> die Spannung <math>U_e</math> an, und es gilt:
<math>I_{R3}=\frac{U_e}{R_3}.</math>

Da der (-)Eingang hochohmig ist, fließt <math>I_{R3}</math> über <math>R_4</math> weiter zum OPV-Ausgang.

Ua ist die Spannung vom Ausgang zur (virtuellen) Masse am (-)Eingang.
(--> Pfeil einzeichnen und klarmachen, daß es egal ist, ob der Pfeil vom
Ausgang zur Masse geht oder vom Ausgang "entgegen der Stromrichtung" zur
virtuellen Masse an (-)!)

Mit Hilfe von <math>I_{R3}=\frac{U_e}{R_3}</math> ergibt sich:

<math>U_a = -R_4 \cdot I_{R3} = -{{R_4} \over {R_3}} \cdot U_e.</math>

Die Energie für den Stromtransport über <math>R_4</math> stammt vom OPV! Sobald die Ladungen ausgehend von der Spannungsquelle <math>U_e</math> die virtuelle Masse an (-) erreicht haben, hat <math>U_e</math> seine gesamte Energie abgegeben.

== Reale OPs / Kennwerte ==
Abweichend vom idealen OP besitzen reale OPs diverse Einschränkungen und Kennwerte, die sie für verschiedene Einsätze mehr oder weniger prädestinieren.

=== Leerlaufverstärkung ===
Die Leerlaufverstärkung gibt an, wie stark sich das Ausgangssignal i.A. der Änderung eines Eingangsignals statisch ändert, bzw nach dem Einschwingen erreichen könnte, wenn es nicht durch die Betriebsgrenzen limitiert wäre.

=== Anstiegszeit ===
Bestimmend für die dynamische Änderung des Signal ist wiederum die slew rate, die wesentlich das AC-Verhalten bestimmt.

=== Frequenz-Bandbreiteprodukt ===

=== Gleichtaktverstärkung ===
Infolge des inhomogenen Aufbaus der internen Verstärkerstufen wird den die beiden Eingangssignale nicht exakt gleich verstärkt, was in einen Gleichanteil und einen Differenzaneil aufgeteilt werden kann. Der nicht erwünschte common mode ist dabei ein Mass für die Qualität des OP.

== Verstärkergrundschaltungen ==
=== Grundbeschaltung mit Berechung ===
[[Bild:Op-verstaerker-a.png]] [[Bild:Op-verstaerker-b.png]]

In a) und b) verwenden wir den OP als Verstärker und nutzen hier die Möglichkeit der Gegenkopplung, um definierte Verstärkungen zu erhalten. Wir gehen wieder davon aus, dass der OP ein ideales Bauteil ist und daher seine Leerlaufverstärkung unendlich ist. Ebenso betrachten wir den Eingangswiderstand als unendlich.

In a) ist ein invertierender Verstärker mit einem OP dargestellt. Durch die Widerstände R3 und R4 wird die Verstärkung bestimmt:

:<math>V = \frac{U_a}{U_e} = -\frac{R_4}{R_3}</math>

Das Verhältnis der beiden Widerstände bestimmt also die Verstärkung und somit die Ausgangsspannung:

:<math>U_a = -\frac{R_4}{R_3} \cdot U_e </math>

oder auch

:<math>U_a = V \cdot U_e</math>

Das negative Vorzeichen drückt aus, dass es sich um einen invertierenden Verstärker handelt.

Beim nichtinvertierenden Verstärker b) finden wir auch eine Rückkopplung über R6 zum invertierenden Eingang des OP. Die Verstärkung wird durch das Gegenkopplungsnetzwerk R6 und R7 exakt definiert. Hier ist:

:<math>V = 1 + \frac{R6}{R7}</math>

Eine Verstärkung von 1 ist sinnvoll, wenn eingangsseitig eine Spannungsquelle mit hohem Innenwiderstand verwendet wird. Für <math>\frac{R6}{R7} \to 0</math> heißt die Schaltung "Spannungsfolger".

Kleinere Werte als 1 lassen sich nicht realisieren. Die Ausgangsspannung errechnet sich also so:

:<math>U_a = U_e \cdot \left (1 + \frac{R_6}{R_7}\right )</math>

Beispiel: Eine Eingangsspannung von 0,5 V soll auf den Wert 5 V verstärkt werden, es ist also eine Verstärkung V von 10 benötigt. R7 ist mit 10 kΩ vorgegeben. Also ist das Verhältnis

:<math>\frac{R_6}{R_7} = V - 1</math>

Bei einem Wert von 10 kΩ für R7 errechnet sich R6 zu

:<math>
R6 = (V - 1) \cdot R7
= (10 - 1) \cdot 10\,\mathrm{k\Omega}
= 90\,\mathrm{k\Omega}
</math>

Die Ausgangsspannung Ua wird also:

:<math>
U_a = U_e \cdot \left (1 + \frac{R_6}{R_7}\right )
= 0,5\,\mathrm{V} \cdot \left (1 + \frac{90\,\mathrm{k\Omega}}{10\,\mathrm{k\Omega}}\right)
= 5\,\mathrm{V}
</math>

=== Spannungsfolger (Impedanzwandler) ===

[[Bild:Op-spannungsfolger1.png]]

Eine Abart des nichtinvertierenden Verstärkers stellt der Spannungsfolger dar. Beim nichtinvertierenden Verstärker errechnet sich die Ausgangsspannung aus:

:<math>U_a = U_e \cdot \left (1 + \frac{R_2}{R_1}\right )</math>

Wenn wir R2 auf 0 Ohm (mit R1 > 0) oder R1 auf unendlich (mit R2 < ∞) ändern, erhalten wir daher:

:<math>V = 1 + \frac{R_2}{R_1} = 1</math>

Ein Spannungsfolger hat also eine Verstärkung V von 1.

Umgezeichnet sieht die Schaltung so aus:

[[Bild:Op-spannungsfolger2.png]]

Was soll das nun? Wir nutzen die Eigenschaft, dass ein idealer OP einen unendlichen Eingangswiderstand und einen Ausgangswiderstand von 0 Ohm hat. Real sieht das natürlich anders aus: so liegt der Eingangswiderstand Re bei normalen OPs in der Größenordnung von 1MOhm bis <math>10^{15} \Omega</math>, der Ausgangswiderstand Ra im Bereich 20 Ohm bis 1kOhm. Deshalb spricht man bei dieser Schaltung von einem Impedanzwandler. Eine solche Schaltung kann also aus einer relativ hochohmigen Spannungsquelle eine niederohmige, durch Folgeschaltungen belastbare Spannungsquelle machen.

[[Bild:Op-spannungsfolger3.png|left]]

In dem nebenstehenden Beispiel ist eine einfache Möglichkeit zur Erzeugung einer Referenzspannung gezeigt. Es kommt eine normale Stabilisierungsschaltung mit einer Zenerdiode zur Anwendung, die aber nicht mehr die schlechten Eigenschaften der Standardbeschaltung mit lediglich Widerstand und Zenerdiode hat. Bei einer Zenerdiode hängt die genaue Spannung davon ab, welcher Strom durch sie durchfliesst. Dieser Strom (und damit auch die Höhe der Zenerspannung) würde sich aber ändern, wenn ein Verbraucher die Zenerdiode direkt mit seinem Stromfluss belasten würde. Als Folge davon würde die Spannungslage der Zenerdiode je nach Verbraucher leicht schwanken. Durch den Spannungsfolger wird das verhindert, weil der jetzt den vom Verbraucher gezogenen Strom bereitstellt.

{{Clear}}

[[Bild:Op-spannungsfolger4.png|left]]

Eine weitere Anwendungsmöglichkeit wäre das hochohmige Auskoppeln einer Brückenspannung. Die Brückenschaltung selbst wird durch Folgeschaltungen nicht mehr belastet, alle anderen Eigenschaften bleiben erhalten.

{{Clear}}

=== Der Komparator ===

[[Bild:Op-komp-a.png]] [[Bild:Op-komp-b.png]]

In der einfachsten Beschaltung des Operationsverstärkers erhält man einen Komparator. Es fällt auf, dass kein Gegenkopplungsnetzwerk vorhanden ist. Der OP arbeitet daher mit seiner vollen Leerlaufverstärkung Vo. Dies bedeutet, dass bereits eine kleine Eingangsspannung genügt, um den OP in die Begrenzung zu treiben. Das heißt, die Ausgangsspannung Ua wird annähernd die Betriebsspannung erreichen.

Beim Komparator gibt es zwei Möglichkeiten der Beschaltung: die invertierende nach a) und die nichtinvertierende Beschaltung nach b).

==== Berechnungsbeispiel für Schaltung b) ====

Angenommen die Leerlaufverstärkung Vo von 40000 und eine Eingangsspannung von 0,1 Volt. Die Betriebsspannungen Vcc und Vee legen wir auf +/- 24 V fest. Damit ergibt sich theoretisch für Ua:

:<math>U_a = V_0 \cdot U_e = 40000 \cdot 0,1\,\mathrm{V} = 4000\,\mathrm{V}</math>

Das ist natürlich ein unrealistischer Wert, da Ua nicht höher sein kann als die Betriebsspannung. Also anders ausgedrückt: Bei welcher Spannung Ue erreicht der OP seine Aussteuerungsgrenze?

:<math>U_e = V_{cc} / V_0 = 24\,\mathrm{V} / 40000 = 0,6\,\mathrm{mV}</math>

Das bedeutet, dass eine Spannung von 0,6 mV ausreicht um den Komparator in die Begrenzung zu treiben.

Das gleiche gilt auch für den invertierenden Komparator, allerdings wird hier der OP in die negative Begrenzung gebracht.

:<math>-U_a = V_0 \cdot U_e</math>

=== Der Addierer (Summierverstärker) ===

[[Bild:Op-addierer.png]]

Ein als invertierender Verstärker beschalteter OP lässt sich so beschalten, dass ein Summensignal aus den Eingangsspannungen gebildet wird. Um die Funktion deutlich zu machen, ist eine Betrachtung der einzelnen Ströme nötig.

In einem invertierenden Verstärker wird sich die Ausgangsspannung immer so einstellen, dass der invertierende Eingang Massepotential hat. Die virtuelle Masse (VM) unterscheidet sich von einer "normalen" Masse dadurch, dass das Potential durch einen Regelungsvorgang zustande kommt.
An der virtuellen Masse (VM) gilt die Knotenpunktregel, wonach die Summe der zufließenden Ströme gleich der Summe der abfließenden Ströme ist.

:<math>I_1 + I_2 = -I_3</math>

Sofern <math>U_{e1}</math> und <math>U_{e2}</math> bekannt sind, lässt sich die Gleichung umformen in:

:<math>\frac{U_{e1}}{R_1} + \frac{U_{e2}}{R_2} = -\frac{U_a}{R_3}</math>

Nach Ua aufgelöst ergibt sich:

:<math>-U_a = \left (U_{e1} \cdot \frac{R_3}{R_1}\right ) + \left (U_{e2} \cdot \frac{R_3}{R_2}\right ) + ... + \left (U_{en} \cdot \frac{R_3}{R_n}\right )</math>

Das war's eigentlich schon. Einen Sonderfall gibt es, wenn die Widerstände R1 und R2 gleich sind. Dann gilt

:<math>R_1 = R_2 = R_x</math>

und damit

:<math>-U_a = \frac{R_3}{R_x} \cdot (U_{e1} + U_{e2})</math>.

=== Der Subtrahierer (Differenzverstärker) ===

[[Bild:Op-subtrahierer.png]]

Ein Subtrahierer ist die Zusammenschaltung eines invertierenden und eines nichtinvertierenden Verstärkers. Schliessen wir Punkt Ue1 nach Masse kurz und steuern Ue2 an, arbeitet die Schaltung als nichtinvertierender Verstärker. Wird Ue2 nach Masse verbunden und Ue1 angesteuert, verhält sich die Schaltung als invertierender Verstärker (R7 vorerst nicht beachten).

Für den 1. Fall gilt:

:<math>U_a = U_{e2} \cdot \left (1 + \frac{R_6}{R_4}\right )</math>

Für den 2. Fall:

:<math>U_a = -U_{e1} \cdot \frac{R_6}{R_4}</math>

Der dritte Fall ist die Ansteuerung beider Eingänge:

:<math>U_a = -U_{e1} \cdot \frac{R_6}{R_4} + U_{e_2} \cdot \left (1 + \frac{R_6}{R_4}\right )</math>

Diese Schaltung ist gut für eine Erklärung, praktisch aber taugt sie nichts. Denn liegen an den Eingängen gleiche Spannungen an, ist die Ausgangsspannung nicht 0, wie eigentlich zu vermuten wäre. Deshalb ändern wir die Schaltung und fügen R7 ein. Jetzt stellt sich am Punkt + des OPs die Spannung

:<math>U_{e2+} = U_{e2} \cdot \frac{R_7}{R_5 + R_7}</math>

ein. Wenn wir das berücksichtigen, erhalten wir endlich einen richtigen Subtrahierer:

:<math>U_a = U_{e2} \cdot \left (1 + \frac{R_6}{R_4}\right ) \cdot \frac{R_7}{R_5 + R_7} - \frac{R_6}{R_4} \cdot U_{e1}</math>

Dies gilt für alle Subtrahierer, obwohl es natürlich auch hier wieder zwei Sonderfälle gibt; nämlich a) wenn alle Gegenkopplungswiderstände gleich sind:

:<math>R_6 = R_7 = R_4 = R_5</math>

dann ist

:<math>U_a = U_{e2} - U_{e1}</math>

oder b) wenn die Widerstandsverhältnisse gleich sind :

:<math>\frac{R_6}{R_4} = \frac{R_7}{R_5}</math>

Dann ergibt sich für Ua:

:<math>U_a = \left (U_{e2} \cdot \frac{R_6}{R_4}\right ) - \left (U_{e1} \cdot \frac{R_6}{R_4}\right )</math>

oder noch einfacher:

:<math>U_a = (U_{e2} - U_{e1}) \cdot \frac{R_6}{R_4}</math>

=== Addierer/Subtrahierer mit unterschiedlichen Faktoren ===
Legt man nicht den + sondern den - Eingang des Operationsverstärkers als Bezugspunkt zur Masse mit einem Widerstand fest, übernimmt der Vorwiderstand vom - Eingang, R4 die Aufgabe von R5.

[[Bild:Op-addsub.png]]

Hier die Schaltung die addieren und subtrahieren kann, mit unterschiedlichen Faktoren.
Sie kann verwendet werden für Aufgaben wie: Gesucht ist eine Schaltung, die aus 0...2.56 V eine Spannung von -10V...10V macht. Für dieses Beispiel wird hier die Dimensionierung durchgeführt:

{| class="wikitable" style="text-align: left"
|'''Ue1 = 5V'''
|Einfach festgelegt, muss nur ein positiver Wert sein
|-
|'''R6 = 200k'''
|Einfach festgelegt, könnte auch 100k oder 500k sein
|-
|Ue2i = 0V, '''Uai = -10V'''
|gewählter momentaner ''Zustand 1'', Ue2 = 0V ist günstig für Berechnung, Ua ist die dazupassende Ausgangsspannung
|-
|'''Ue2ii = 2.56V''', '''Uaii = 10V'''
|gewählter beliebiger ''Zustand 2''
|-
|Um = Ue2
|Gleichgewicht am Eingang
|-
|Ia + Ib = Ic
|In den Eingang fließt "kein" Strom
|-
|(Ua-Ue2)/R6 + (Ue1-Ue2)/R4 = Ue2/Rc
|Gleichung mit den Unbekannten R4 und Rc
|-
|(Uai-Ue2i)/R6 + (Ue1-Ue2i)/R4 = Ue2i/Rc
|Variablen für ''Zustand 1'' eingesetzt, bildet 1. Gleichung
|-
|(Uaii-Ue2ii)/R6 + (Ue1-Ue2ii)/R4 = Ue2ii/Rc
|Variablen für ''Zustand 2'' eingesetzt, bildet 2. Gleichung
|-
|<math>R4=-\frac{R6*U_{e1}}{U_{ai}}</math>
|2 Gleichungen mit 2 Unbekannten, Lösung durch Umformen der 1. Gleichung nach R4 und einsetzen von Ue2i=0 (freundlicherweise fällt die 2. Unbekannte dabei raus)
|-
|'''R4 = 100k'''
|restliche Werte eingesetzt
|-
|<math>Rc=\frac{R6*U_{e1}*U_{e2ii}}{U_{aii}*U_{e1}-U_{ai}*(U_{e1}-U_{e2ii})-U_{e1}*U_{e2ii}}</math>
|Ergebnis für R4 in die 2. Gleichung einsetzen und Umformen nach Rc
|-
|'''Rc = 41.6k'''
|Werte eingesetzt
|}

=== Der Instrumenten-Verstärker ===

[[Bild:Instrument.png]]

Ein Nachteil des Subtrahierer ist sein geringer Eingangswiderstand. Um den nahezu unendlichen Eingangswiderstand des verwendeten Operationsverstärkers zu erreichen, kann man einfach vor beide Eingänge je einen Impedanzwandler vorschalten.
Die hier beschriebene Schaltung ist um drei Widerstände erweitert und ermöglicht die Einstellung der Differenz-Verstärkung über nur einen Widerstand, nämlich R2.

Am invertierenden Eingang von IC1A gilt (Knotenregel):

:<math>\frac{U_{a1}-U_{e1}}{R_1}-\frac{U_{e1}-U_{e2}}{R_2}=0</math>

Am invertierenden Eingang von IC1C gilt (Knotenregel):

:<math>\frac{U_{a2}-U_{e2}}{R_1}+\frac{U_{e1}-U_{e2}}{R_2}=0</math>

Subtrahiert man die beiden Gleichungen voneinander, erhält man:

:<math>U_{a2}-U_{a1}=(U_{e2}-U_{e1})\cdot\left (1+\frac{2\cdot R_1}{R_2}\right )</math>

Letztere Differenz ist die Eingangsspannung eines normalen Subtrahierers mit der Verstärkung 1.

Also ergibt sich als Ausgangsspannung:

:<math>U_a=(U_{e2}-U_{e1}) \cdot \left (1+\frac{2\cdot R_1}{R_2}\right )</math>

Die Differenzverstärkung beträgt demnach:

:<math>V=\left (1+\frac{2\cdot R_1}{R_2} \right )</math>

Anwendung: Auswertung von Brückenschaltungen, wie Drucksensoren oder Dehnungsmessstreifen, die durch den Eingangswiderstand der Messschaltung nicht belastet werden dürfen. 
Instrumenten-Verstärker kann man auch fertig kaufen. Im INA102 ist die komplette Schaltung integriert. Für R2 sind 3 verschiedene Werte eingebaut, die bei passender Verschaltung eine Verstärkung von 1, 10, 100 oder 1000 ermöglichen.

=== Der Multiplizierer (Mischer) ===

=== Der Logarithmierer ===

= Spannungsversorgung und Beschaltung =

== Betrieb mit einfacher Versorgungsspannung ==

Häufig möchte man Wechselspannung (z. B. Audiosignale) die auch negative Spannungen enthält mit einem Opamp verstärken, hat aber nur eine einfache Versorgungsspannung, eine positive in Bezug zu Masse, zur Verfügung. Dafür bieten sich folgende Schaltungen an, die in der Literatur leider häufig vernachlässigt werden.

=== Nichtinvertierender Verstärker ===

[[Bild: Ss_opamp1.png]]

Der negative Eingang wird mit einem Spannungsteiler auf die halbe Betriebsspannung gelegt und das Signal mit Kondensatoren am Ein- und Ausgang entkoppelt.
Die Verstärkung ist in diesem Beispiel für Wechselspannung 11 (Formel wie oben), für Gleichspannung aber 1, da C4 für Gleichspannung einen unendlichen Widerstand darstellt. C3 sollte dorthin gehen, wo das Eingangssignal seinen Bezugspunkt hat, also die Abschirmung der Chinch-Buchse, während R5 dorthin geht, wo der Operationsverstärker seine negative Versorgungsspannung her bekommt, falls das nicht die gleichen Pontentiale, hier GND, sein sollten.

=== Invertierender Verstärker ===

Das Prinzip funktioniert analog auch für die invertierende Beschaltung:

[[Bild: Ss_opamp2.png]]

= Kaufempfehlung =
LM 158/258/358 2 OPs in einem Gehäuse Preis ca. 0,30€.

Siehe auch [[Standardbauelemente#Operationsverst.C3.A4rker|Standardbauelemente - Operationsverstärker]].

Wer Audio OpAmps sucht - tangentsoft.net hat mal welche unter die Lupe genommen: [http://www.tangentsoft.net/audio/opamps.html Notes on Audio OpAmps]

= Weblinks =
*[http://www.eetkorea.com/ARTICLES/2003SEP/A/2003SEP19_AMD_AN07.PDF Op Amp Circuit Collection] - National Semiconductor Application Note 31 mit vielen weiteren OP-Schaltungen
*[http://www-s.ti.com/sc/psheets/slod006b/slod006b.pdf Op Amps for Everyone] - englischsprachiges, sehr umfangreiches Dokument zu OPV und deren Anwendung (empfehlenswert)
* [http://www.elektronik-kompendium.de/sites/bau/0209092.htm Operationsverstärker im ElKo]
*[http://www.inf.fu-berlin.de/lehre/WS00/peg/folien/Peg_v7a.pdf OP Teil 1], [http://www.inf.fu-berlin.de/lehre/WS00/peg/folien/Peg_v7b.pdf OP Teil 2] - OP-Schaltungen (deutsch)
*[http://www.blecken.de/download/opverst.zip Schaltungstechnik mit Operationsverstärkern] - Prof. K. Blecken, Skript zur Vorlesung (deutsch, *.doc-Format)
* [http://www.roboternetz.de/wissen/index.php/Operationsverst%C3%A4rker RN-Wissen Operationsverstärker]
* [http://www.national.com/onlineseminar/#amps Online Seminar] von National Semiconductor
* [http://www.franzis.de/elo-das-magazin/grundlagen-und-ausbildung/operationsverstaerker/der-operationsverstaerker ELO-Online-Magazin, Franzis-Verlag], [http://www.franzis.de/online-shop/elektronik/lernpakete-elektronik/lernpaket-elektronik-mit-ics Lernpaket Elektronik mit ICs] "Elektronische Experimente mit integriertem Schaltkreis", Kasten mit Steckbrett/Bauelementen (ca. 40EUR),
* [[Schmitt-Trigger]]
* [[Aktiver RC-Bandpass|Aktiver RC-Bandpass auf Operationsverstärker-Basis]]

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

Diskussion:Frequenzumrichter mit Raumzeigermodulation

2011-10-18T16:11:16Z

Jackfritt: /* Rampen */

== Fragen ==

Ein paar Fragen die ich gerne im Artikel beantwortet sehen würde:

Wie wird der Motoranlauf realisiert?
Wie wird die Istdrehzahl erfasst?
Wie wird die Iststromaufnahme erfasst?
Warum kommt man ohne p-Kanal FETs aus?

Danke für die Anregungen.

Habe die Fragen unter Steuerung und Leistungsteil ausfürlich beantwortet.

Hier in Kürze:

Es gibt einen Hochlaufgeber in Programm.

Die Istdrehzahl kann mit einem Hallgeber erfasst werden, ist aber noch nicht getestet.

Ist-Strom wird nur im Zwischenkreis gemessen

----

== Rampen ==

Erstmal Respekt für dieses Projekt, normalerweise wird "FU selberbauen" mit einem "schau dir mal richtige FU's an das ist unmöglich..." abgetan.

Ich habe Interesse am Nachbau, jedoch einige Fragen:
Gibt es eine einstellbare Start-Stop Rampe? Weil von 0 auf 100 in 0s ist nicht gut für n Motor... zweitens, wie genau wird beim Stoppen Bremsenergie vernichtet?

Des weiteren: Das ganze ist ja auch für "richtige Motoren" ausgelegt, hast du es mal mit nem z.b. 0,75kW Drehstrommotor getestet?

Danke für die Lorbeeren.

Getestet habe ich mit einem 0,5KW Drehstromgebläse, da bekam ich die Leistung am einfachsten für den Dauerbetrieb "vernichtet". Nebenbei war auch der Staub aus den Ecken in meinem Bastelschuppen verschwunden bzw verteilt.

Die Hoch- und Rücklauframpe ist gleich und wird per Timer 0 im Mega 32 gebildet. Ist leider (noch) nicht konfortabel einstellbar, da muss am Timerwert geändert werden. Beim schnellen Verringern der Ausgangsfrequenz steigt automatisch die Zwischenkreisspannung an. Das liegt im Wesen des Wechselrichters. In der Einspeiseeinheit wird die Zwischenkreisspannung gemessen und ab 340V wird auf eine 100W Glühlampe geschoppt. Da das Gebläse am Ausgang nicht so viel Schwungmasse hatte, hat die Lampe nur kurz aufgeleuchtet. Reicht aber für den Funktionstest.

Axel

----

== Diverse Fragen ==

Aus der Mailkommunikation mit Axel:

'''1. zum Ladewiderstand (R16)'''

R16 in der Einspeisung ist mit 5Ohm bei 5W angegeben... wie kommst du auf den Wert?

Antwort:
Das ist der Ladewiderstand der Kondensatoren, sonst fließe ein zu großer Ladestrom und die Sicherung geht flitzen. Wenn der R größer ist dauert das Laden halt länger.

Rückfrage:
Soweit ist das schon klar... nur 5 Ohm bei 230V entsprechen 46A!? Also sind die 5W doch etwas klein!? Oder hält sich das in Grenzen, weil die Kondensatoren so schnell geladen werden?

Antwort:
hast Recht, nimm 20 Ohm, zur Zeit habe ich dort eine Glühlampe eingebaut.

Rückfrage:
Warum wird R16 bei erreichen einer best. Spannung überbrückt? Das verstehe ich nicht ganz.

Damit der Ladewiderstand im Betrieb nicht stört.

'''2. Dimensionierung Zwischenkreis Kondensatoren:'''

Die Zwischenkreis Kondensatoren haben bei dir keine angegebenen größen... Ich brauche wohl Elkos, die >400V aushalten, also müssten 450V Typen doch ausreichend sicher gewählt sein!?

Antwort: Ja

Zur Kapazität: Sie müssen doch lediglich die "Totzeiten" der gleichgerichteten Wechselspannung ausgleichen, also brauchen sie ja garnicht so extrem groß sein... wie groß hast du deine dimensioniert? Und wo bekomme ich die Dinger einigermaßen erschwinglich her?

Anwtort: habe ca 2000µF 
alte Schaltnetzteile, da habe ich meine her.

'''3. Bezugsquelle IR Chips'''

wo hast du die ganzen IR Chips und Mosfets her? Hab mal kurz bei Conrad geguckt, die haben zwar alles, was ich bisher gesucht habe, aber zu astronomischen Preisen :-/ Reichelt ist da besser, hat aber nicht alles... hast du ne bessere Quelle?

Antwort: auch von diesen Beiden

'''4. Unterschiedliche Mos-Fets in Leistungsteil'''

Im Leistungsteil hast du je einen IRFP460 und einen IRFPC40 parallel geschaltet. Hat das einen Grund?

Antwort: Reserve, muss nicht bestückt werden

Rückfrage:schon klar - aber warum gerade diese beiden? Ich könnte doch auch einen Typ nehmen, oder? der muss nur halt die Belastung aushalten... also genügend spannungsfest und entsprechend leistungsstark sein.

Antwort: Stimmt, das ist ein Fehler in Plan.

'''5. Dimensionierung der Widerstände R5-7 & R9'''

nochmal zurück zur Einspeisung: dort sind als Spannungsteiler (?) 3
Widerstände und ein Poti (R5-R7, R9) verrätst du mir die Werte?

Antwort: 270K, 3Stück wegen der Spannungsfestigkeit

Rückfrage: Das Poti hat auch 270k?

Das Poti hat 10K

----
== Treiber ==

Kann man statt den ir2109 auch ir2104 nehmen, worauf kommt es bei der auswahl an? Diese beiden sind recht ähnlich. Den ir2104 gibt es aber auch bei tme und das wesentlich preiswerter als den ir2109 bei Conrad.

Würde sagen, der 2104 ist noch etwas besser.

----

Gratuliere dir. Ist schon beachtlich was du in einem Hobbyprojekt geleistet hast. Hast du Beruflich auch etwas mit dieser Materie zu tun?

Die Ausgangsmodulation ist noch nicht Optimal aber schon sehr gut. Für weitere Anregungen kann ich dir das Buch von Felix Jenni und Dieter Wüest über „Steuerverfahren für selbstgeführte Stromrichter„ empfehlen wenn du das nicht sowieso schon kennst.

Mfg Michael

----

Hallo, Finde es super das du dir die Arbeit gemacht hast das Projekt online zustellen.
Ich habe eine Frage zu den Zener Dioden Am Gate der MosFets und der Spannungs Teiler R1,3,5 zu R7,9,11 (47 zu 47k). Erstens warum setzt du die Diode dort nur als Spannungs begrenzung? Brauche ich die auch wenn ich nur 12V auf dem Zwischenkreis habe? Zweitens du belastest den Bootstrap mit dem 47K Widerstand, ist der PullDown so wichtig das du es in Kauf nimmst den Bootstrap zu belasten?
(Hintergrund Mir rauchen in meiner Schaltun die IR2184 ab die fast gleich zu den 2109 oder 2104 sind)

Danke

Hallo,

Die Z-Diode ist eine reine Angst Diode. Habe ich in einer App-Note gefunden, Platz auf der Platine gehabt und somit reingebaut. Ob die Lebenswichtig ist glaube ich nicht, es gibt auch andere Schltpläne ohne diese Diode.

Der 47K Pull-Down verhindert ein Durchschalten beider Transistoren, wenn der IR2109 nicht steckt oder mal abgeraucht ist. Also wohl auch ein Angtwiderstand.
Da aber mit 2,5 Khz geschaltet wird, ist der Bootstrap Kondensator nie leer.

Axel

== Andere Spannungsversorgung ==

Hallo,

Ich will den Frequenzumrichter nachbauen, möchte ihn aber etwas kompakter machen. Bis jetzt habe ich es geschafft, den Hochspannungsteil komplett auf einer Platine (Eagle-freie-version-maximum) unterzubringen, aber für den Trafo finde ich einfach keinen Platz mehr. Ich möchte die 12 V aus den 325 V mit einer einfachen Schaltung herunterregeln (z.B. Mit einem MOSFET und einer Z-Diode). Weiß jemand wieviel Strom die Schaltung normalerweise von 15V zieht? Ist das lastabhängig (ich meine Motorlast)?

Falls es erwünscht ist, werde ich natürlich meine modifizierte Schaltung hier veröffentlichen, wenn sie fertig ist.

Mit freundlichen Grüßen,
Rupert Eibauer

Hallo Rupert,
es fleißen zwischen 50 und 100mA.
Das wären bei einem Längsregler 15 bis 30W Verlustleistung.
Such lieber einen Platz für den Trafo.

Deine Schaltung ist natürlich erwünscht, füge sie einfach unter einer neuen Überschrift an.

Axel
----

== Sektoren ==
Hallo Axel,
ich weis nicht ob ich hier an der richtigen stelle bin um ne frage zu stellen, aber ich tus mal naiiver weise ;)

hier ist die rede von raumzeigermodulation, aber im text habe ich irgendwas von "sechs sektoren" gelesen, ich vermute du meinst die sechs bitmuster die du verwendest. ich will nicht spitzfindig sein, aber in wie viele mikroschritte wird denn per elektrischen umdrehung des motors unterschieden, sprich, aus wievielen "schritten" besteht dein sinus (und somit der raumzeiger)? das oszi-bild zeigt ja, dass es sich hier nicht um sechs "plumpe schritte" wie in der block-kommutierung handelt. (kann man bei einer asynchron-maschine von kommutierung reden?)

wie dem auch sei, ein sehr schönes projekt, gefällt mir, obwohl ich lieber mit spannungen unter 48VDC arbeite und mit wechselspannung nix am hut habe ;)

hast du schon mal daran gedacht eine synchronmaschine zu kommutieren? das wäre mal eine echte herausforderung mit einem (oder mehreren) AVRs die d- und q-ströme in den griff zu bekommen. wenn man das aber hinkriegt und den kommutierungswinkel auf 90° regeln kann hätte man die synchronmaschine in die bastelwelt aller hier lesenden gehoben!

sicherlich nicht trivial, aber sportlich ;)
gruss, und nochmal respekt,

heinz

Hallo Heinz,

das Programm macht alle 400µs einen "Schritt". Dass heißt, je niedriger die Ausgangsfrequenz ist, umso besser wird der Sinus nachgebildet.

Eine Syncronmaschine geht mehr in den Bereich BLDC Motor. Der Artikel hier im Forum ist aber leider irgendwie nicht fertig geworden. Sollte ein Gemeinschaftswerk werden und obwohl zuerst alle recht begeistert bei der Sache waren, haben viele Köche doch den Brei verdorben.

Axel
----

== Einige Fragen ==

Hallo Axel,

Erstmal danke dafür, dass du dir die ganze Mühe gemacht hast, die Dokumentation deines Projektes zu schreiben, hier einzustellen und auch noch zu pflegen - vielen Dank!

Ich beschäftige mich leider erst einige Monate mit Elektronik, da ich damals ins Auge gefasst habe, einen Drehstrom-Asynchronmotor mit Steuerung zu entwerfen und zu bauen. Ich bin Physik-Student im 6. Semester und habe dementsprechend Basiswissen über die physikalischen Hintergründe, jedoch nur sehr wenig praktisches, angewandtes Wissen. Dafür bin ich aber in der außerordentlichen Position an meiner Uni das Studenten-Elektroniklabor zu leiten, das gerade eben erst von den Studiengebühren eingerichtet worden ist. Das heißt konkret, dass ich auch die Bauteile bestelle und deswegen Geld für mich nur eine untergeordnete Rolle spielt. Um einen Nachbau realisieren zu können, brauche ich allerdings noch ein paar Antworten auf ein paar Fragen, die ich im Internet noch nicht gefunden habe.

Ich entschuldige mich schonmal, da bestimmt einige Fragen dabei sind, die ziemlich dämlich bzw. mit einigem Suchen doch noch im Netz zu finden wären. Falls jemand trotzdem die Antworten zu ein paar der folgenden Antworten weiß und sie hier aufschreibt, wäre ich äußerst dankbar! Los gehts:

Zum Bremschopper:

1. Aus dem Netz kommen 230V Wechselspannung mit 50Hz. Um andere Frequenzen rauszufiltern, bilden die Spule und der Kondensator einen Bandpass. Wie groß wählt man z.B. den Q-Faktor des Bandpasses? Oder einfacher: Welche Werte haben C11 und L1? Muss man bei den großen Spannungen auf besondere Eigenschaften der beiden Bauteile achten? Spannungsfestigkeit von C11>325V?

''C11, L1 und C12 sind ein Filter um Störungen '' '''zurück''' '' ins Netz zu minimieren. C11,C12 befinden sich auf der Wechselspannungsseite vor dem Gleichrichter! Daher 450V ~ . Bei der Dimensionierung habe ich mich an alte Computernetzteile angelehnt, leider ohne jede Berechnung .''

2. Kann man statt C4 und C2 nicht einen Kondensator mit der Gesamtkapazität nehmen? Warum ist bei C4+C2 die Polung wichtig, und bei C12 nicht? Haben C2 und C4 jeweils einzeln 2000mikroFarrad, oder beide zusammen? Stimmt es, dass C2, C4 und C11 450V-Typen sind?

''Ich hatte leider keine unbegrenzten Geldmittel zur Verfügung, daher habe ich die Zwischenkreiskondensatoren aus alten Computernetzteilen ausgebaut. Es kann natürlich ein großer Kondensator 450V- verwendet werden. ( C11 siehe zu 1) ''

3. Warum braucht man zwei Relais (P1 und P2)? Ist das Relais, dass am ATTiny hängt, stellvertretend für diese beiden Relais?

''P1 und P2 sind die Kontakte des'' '''einen''' ''Relais K2. Hatte gerade ein solches Relais in der Bastelkiste. (siehe 2) ''

4. Aus den 230V werden auch 9V transformiert, so dass diese 9V für die Chips zur Verfügung steht. An manchen Stellen steht VCC im Plan, an anderen +12V. Woher kommen diese 12V? Woher nimmt man 5V und 15V?

''Aus 9V~ entstehen nach Gleichrichtung und Glättung 12V bis 15V DC. Die 5V werden durch den 7805 erzeugt. ''

5. Jetzt mal ne ganz blöde Frage: Wie funktioniert das mit den X1-3 usw. Anschlüssen? Sind das Verbindungen zu den anderen Platinen bzw. Klemmanschlüsse?

''Sind Klemmanschlüsse zur Wechselrichter-Platine. X1-1 ist 15VDC; X1-3 ist: Zwischenkreis OK, Ladung der Kondensatoren abgeschlossen. ''

6. Welche Anforderungen müssen die Gleichrichter erfüllen?
''B2 ist aus einem alten Schaltnetzteil ein 230V Typ! B1: 30V 100mA ''

7. Wieviele Zwischenkreiskondensatoren mit Spannungsfestigkeit > 450V brauche ich im Endeffekt, bzw. was für eine Kapazität muss ich erreichen?

''Das ist wie beim Hubraum bei Autos, viel hilft viel und bewahrt einen evtl. vor seltsamen Effekten. 2000µF sollten reichen. ''

Schonmal vielen Dank an jeden, der sich die Mühe macht, meine Fragen zu beantworten!
Ich habe übrigens das Schema der Einspeisung und des Bremschoppers ein wenig übersichtlicher gestaltet und die 270k-Angaben der drei Widerstände, die 20R vom Ladewiderstand, die 10k vom Poti und die 2mF bzw. 2000µF der Zwischenkreiskondensatoren im Plan ergänzt. Hier ist der Link:

http://www.uni-bonn.de/~maschoe/Bremsshopper_mod.sch
http://www.uni-bonn.de/~maschoe/Bremsshopper_mod. -> png

Soll ich den alten Plan einfach ersetzen? Natürlich werde ich auch in Zukunft alle Verbesserungen, die mir auffallen, ins Wiki fließen lassen.

''Kannst Du einstellen, ändere die +12V in +15V damit es sich mit den Bezeichnungen der Leistungsteilplatine nicht beißt. ''

Achja, und übrigens: Die Eagle-Dateien in der zip-File vom Leistungsteil sind irgendwie leer, jedenfalls bei mir - liegt das an meinem Rechner oder an den Dateien?

''Lässt sich bei mir entpacken: Wechselrichter 4.sch , Wechselrichter 4.brd und der Ordner WR88_RZM mit dem Steuerprogramm ''

Viele Grüße,
Matthias
1000fragen 19:28, 18. Mär. 2009 (CET)

Hallo Matthias,
habe die Antworten kursiv unter die Fragen geschrieben.

Axel

Hey Axel,

Viele Dank für die Hinweise! Ich habe sie im Artikel verwurstet.

Matthias

[[Benutzer:1000fragen|1000fragen]] 21:12, 22. Mär. 2009 (CET)

----

Hi Axel,

Wegen der Eagle-Dateien: Das Archiv lässt sich bei mir auch entpacken und die Dateien sind auch da, aber wenn ich die dann in Eagle öffne, sind die Pläne leer - Könntest du nochmal kurz nachsehen ob das bei dir auch so ist? Habs unter Windows und unter Linux getestet...

''Habe ein zweites Zip File hochgeladen, schau mal ob dieses geht.''

Außerdem noch eine Frage zum Schaltplan: Es sind ja einige Kondensatoren parallel geschaltet, z.B. gepolt 100u und ungepolt 100n. Sind die ungepolt 100n-Kondensatoren da, um die gepolten 100u-Kondensatoren vor eventuell falsch gepolten Spannungsspitzen zu schützen? Könnte ich also auch einfach 100u ungepolte Kondensatoren nehmen?

''Es geht hier nicht um dir Polung, sondern um die Geschwindigkeit mit der die unterschiedlichen Kondensatoren Ladung aufnehmen können. Die 100n sind für schnelle Änderungen.''

Was den Wechselrichter angeht:

Die Kondensatoren C8, C10, C12, C13: Ist C8+C10=2000uF? Was ist C12+C13?

''Da sind einige optionale Kondensatoren auf den Platinen, je nach dem welche Kondensatoren verügbar sind. Wie schon gesagt, es kann nicht schaden etwas mehr zu haben."

Ich nehme mal an, dass die Dioden alle vom Typ 1N4004 sind, oder?

''Die Dioden sind 1N4004''

Edit: Hat der Hochstromanschluss ein anderes Massepotential als die IR2109?

''Ist das gleiche Potential. Weiss auch nicht, warum ich die Linie nicht herunter gezeichnet habe. ''

Matthias

[[Benutzer:1000fragen|1000fragen]] 16:49, 25. Mär. 2009 (CET)

----

Hey Axel,

Vielen Dank für deine Antworten! Ich habe jetzt auch das Schema vom Wechselrichter öffnen können - Es lag am Leerzeichen im Dateinamen, das hat die Linux-Version von Eagle wohl nicht so gerne... naja, lernen durch Schmerzen. Ich hab in den letzten Tagen ein Lochrasterplatinenlayout erstellt, dass ich morgen anfangen werde, zusammenzulöten. Ich berichte dann, wie es läuft!

Matthias

[[Benutzer:1000fragen|1000fragen]] 19:16, 31. Mär. 2009 (CEST)

Zeichne bitte noch ein Massesymbol unter R16 und an X3/2 , sodass man sieht, dass hier eine Verbindung besteht.

Ich hoffe Du hast den Leistungsteil mit den 325 V nicht auf eine Lochrasterplatine aufgebaut.

Axel

Hallo Axel,

Habe gerade das Bild aktualisiert. Die Einspeisung habe ich fast fertig (bis auf die Zenerdiode und Anschlüsse), ich hoffe in den nächsten Tagen fertig zu werden und 325V Gleichspannung zu messen. Zu der Zenerdiode noch ne Frage: Was für eine ist das? BZX55 ist ja nur eine Serie von verschiedenen, oder?

Den Leistungsteil wollte ich ursprünglich auch auf eine Lochrasterplatine machen, werde statt dessen aber doch ein PCB nehmen. An welche Probleme hast du bei einer Lochrasterplatine gedacht?

Matthias
[[Benutzer:1000fragen|1000fragen]] 18:49, 28. Apr. 2009 (CEST)

Die Z Diode soll die max Gate Spannung auf 15V begrenzen, ist nur eine Angst-Diode, wenn die Eingangsspannung OK ist, geht es auch ohne.

Bei der Lochrasterplatine währen mir die Leiterbahnabstände für 325V viel zu klein

Axel

Mit dem Abstand der Leiterbahnen hast du wahrscheinlich Recht - die Abstände sind bei mir wirklich nicht groß, deswegen mach ich das ganze lieber nochmal als PCB mittels Toner-Transfer-Methode (wird hier im Forum ja ganz gut beschrieben). Ich melde mich dann nochmal, wenn ich das realisiert habe.

Matthias

----
== Einige Fragen II ==

So, wollte mich nur nochmal melden dass ich noch am Ball bin. Hab heute den Drucker geschrottet, weil ich testweise ne Folie bedrucken wollte, und die sich um die Trommel gewickelt hab. Beim Versuch die rauszuziehen hab ich dann die Trommel zerkratzt *narf* . Aber ich werd mich weiter Stückcken für Stückchen vorarbeiten! Bis zum 24. Juli werde ich nicht viel weiter kommen, aber an dem Tag ist meine letzte Klausur - Dann sollte ich etwas schneller vorankommen. Ich schreib dann nochmal in zwei Monaten oder so, wie es aussieht. Irgendwann krieg ich das Teil zusammengebaut!

Matthias

--[[Benutzer:131.220.221.230|131.220.221.230]] 15:47, 29. Jun. 2009 (CEST)

Viel Erfolg bei den Klausuren (Glück brauchen nur die Faulen)
Axel

Danke, habs zum Glück geschafft, noch neben den Klausuren was zu machen! Ich habe die drei Platinen per TTF-Verfahren geätzt und angefangen, den Einspeiseteil zu bestücken. Da sind noch ein paar Fragen aufgetaucht:

Steuerungsteil:

Was ist IC7 - ein 7805?

Ist R17 ein 10k-linear-Poti?

Welche Werte haben C5,6 und 14?

Was ist PL2?

Einspeiseteil:

Ich schätze mal, D2 ist auch eine N4001, oder?

Noch ne Frage zu den 470nF-Kondensatoren auf dem Leistungsteil: Die liegen ja zwischen 15V Steuerspannung und der Spannung der Hochstromanschlüsse. Was für ne Spannungsfestigkeit müssen die haben?

Matthias

IC7 ist ein 7805

R17 ist ein 10k-linear-Poti

C5=C6 = 47µF 25V oder was sonst so in der Bastelkiste herumliegt.

C14 100nF

D2 ist auch eine 1N4001, normale Freilaufdiode für das Relais

Die Bootstrap Kondensatoren liegen wenn die Low Side geschaltet hat an 15V. Wenn Low Side sperrt werden sie entladen, also kleiner 15V. Daher reichen 25-35V Spannungsfertigkeit

Axel

== Drehzahlregelung ==

Ich hab noch ein paar Fragen.
-Ich habe den Frequensumrichter nachgebaut, aber die Drehzahregelung geht nicht.
Es ist egal welche Spannung ich am Analogeingang anlege(0-5V) der Motor dreht immer gleich schnell.
-Wo kann man die Drehrichtung einstellen?
-Wofür sind die LEDs auf der Steuerplatine da?

Edit:Drehzahlregelung geht jetzt. Es war nur der Mega 32 kaputt der Motor dreht aber trotzdem nur sehr langsam(1U/sec)

Eine Drehzahlregelung findet nicht statt, nur eine Drehzahlverstellung ( eine Regelung hat eine Istwert-Rückführung)

Läuft der Mega 88 mit 20 Mhz? Alle Timer sind darauf abgestellt.

Der Sollwert wird im Mega32 am Analogeingang 2 eingelesen:

// ****** Einlesen Sollwert *********************************
ADMUX=0x02; // PortA2 = ADC2 = Analog Eingang
ADCSRA |= _BV(6); // single conversion mode ein
while(ADCSRA & (1<<6)); // warten bis Konvertierung abgeschlosen
sollwert_f_sample+=ADCW; // Aufsummierung der Samplewerte

Die Drehrichtung ist im Programm fest vorgegeben : das Bit liegt auf Bit 7 am Port D des Mega 32
Wenn beide Richtungen gefordert sind, dann über einen Eingang die Varable:
volatile unsigned char richtung=0; // Drehrichtung
verändern

Weiterhin viel Erfolg
Axel

Der Mega 88 läuft mit 16 Mhz wie im Schaltplan. Im Programm steht aber 20Mhz.
Das hat mich etwas verwirrt. Ich werde Montag mal einen 20Mhz Quarz besorgen.
Könnte man nicht einen der freien Eingange des Mega 32 für die Drehrichtung verwenden?

Julian

Hallo Julian,
wenn im Schaltplan 16 Mhz steht ist das falsch, 20 Mhz sind richtig. Aber zwischen 16 und 20 Mhz sollte der Unterschied in der Ausgangsfrequenz nicht so groß sein.

Hast Du ein LCD am Mega 32? dort kann man den Sollwert ablesen

Es sollte ein freier Eingang des Mega 32 für die Drehrichtung verwendet werden.

Axel

Ich hatte keien Mega 32 mehr, desshalb habe ich einen Mega 16 genommen aber jetzt geht das Display nicht mehr. Ich werde morgen dann auch gleich einen neuen Mega32 besorgen.

Julian

Hast Du schon folgende grundsätzliche Test durchgeführt:

Zwischenkreisspannung ca. 30 V aus einem Labornetzteil anlegen.

Ansteuerung der FET Treiber mit dem Scope prüfen

dann drei Leistungswiderstände 10Ohm im Stern schalten und die Spannung an den Widerständen messen. Sollte so wie im Artikel "Spannung an ohmschen Widerstand" aussehen.

Falls kein Scope vorhanden drei LED´s mit entsprechenden Vorwiderständen im Stern schalten und an die Ausgänge klemmen (evtl drei zusätzliche LED´s antiparallel). Bei niedriger Freguenz sollte man das Drehfeld am Blinken der LED´s erkennen können.( Evtl den Timervorteiler am Mega88 für den Test herunterstellen).

Danke schon mal für die Hilfe.
Es hat leider etwas länger gedauert. Pollin hat es in 2 Wochen leider nicht geschaft mir 2 Teile zu schicken. Der Mega88 läuft jetzt mit 20 MHz aber der Motor dreht trotzdem nicht viel schneller(1,5 U/min). Die Treiberansteuerung ist Ok und die LED´s blinken auch korrekt. Auf dem Display steht:

S=61U=20R=0e=1 5
U=012I=043n=000

Eingangsspannung:12V
Strom: 0,4A
Analogeingang: 4,9V

Julian

Hallo Julian,
die Anzeige auf dem Display bedeutet:

S=61 (Sollwert 61 entspricht 100%)

U=20 (Spannungssollwert 20 entspricht 100%)

R=0 (Richtungssollwert)

e=1 (1= Enablesignal steht an, Umrichter soll laufen)

Zweite Zeile:

U=12 (aktuelle Zwischenkreisspannung ist 12V)

I=043 (es fließt ein Strom im Zwischenkreis, Stromumrechnung hängt vom Shuntwiderstand ab)

Sieht alls soweit korrekt aus.

Was für ein Motor ist angeschlossen? Bei 12V Zwischenkreisspannung kannst Du den Phasenstrom über einen Shuntwiderstand messen, was kommt da raus?

Piepst der Motor?
Gibt es etwas Drehmoment, wenn man die Motorwelle mit der Hand dreht?

In der Interruptroutine von Timer 0 wird der Hochlaufgeber gebildet, der bestimmt, wie schnell der Motor beschleunigt.
Ändere sie wie folgt ab, dann wird lamgsamer beschleunigt.

SIGNAL(SIG_OVERFLOW0) // signal handler for tcnt0 overflow interrupt
{ // alle 10,24ms

hlg++;
if (hlg >=20) {

if (sollvh > sollnh) sollnh++;
if (sollvh < sollnh) sollnh--;
hlg=0;
}

TCNT0 = 215; // Timer auf 10,24ms stellen

Axel

Hallo
Es ist ein alter Motor aus einem CD laufwerk angschlossen. Der Motor piepst nicht und läuft sauber an. Nach der Programmänderung läuft der Motor langsamer an und das Display geht nicht mehr. Der Phasenstrom liegt bei 0,6A. Kann man im Programm irgendwo die max. Ausgangsfrequens einstellen?

Gruß Julian

Hallo Julian,
stell doch den Timer wieder zurück und mach den Wert "if (hlg >=20)" auf 200. Das ist der Vorteiler nach welchen der Sollwert auf oder ab integriert wird.

Die max Frequenz ist ziemlich tief im Programm des Mega88 verwurstelt.

Am Anfang des Programms gibt eine Tabelle:

const unsigned char fbwfl[67]=

dort sind Timerwerte abgelegt aus denen sich die jeweilige Frequenz ergibt. Ist zur Zeit auf 66 Hz festgelegt. Lässt sich bestimmt ändern, ist aber aufwändig.
Bei höheren Frequenzen wird natürlich der sinus des Motorstroms schlechter, da es nur einen Pulsfrequenz von 2,5Khz gibt. Lässt sich auch ändern, muss man nur tiefer ins Programm einsteigen.

Mich erstaunt, dass der Motor keinerlei Geräusche macht. Mein Testmotor hat fürchterlich gepiepst.

Axel

Ich hab das Programm noch einmal geändert, aber das hat gar keinen Einfluss auf den Motor. Zum Test hab ich auch noch einen Lenze 0,4kw Motor genommen. Der dreht aber auch nicht schneller. Beide Motoren laufen sauber an ohne piepsen oder so.

Gruß Julian

Hallo Julian,

die niedrige Drehzahl und keine Geräusche läßt mich vermuten, dass der Mega88 nicht auf 20Mhz läuft. Mache mal ein kleines Testprogramm, welches die LED im Sekundentakt blinken lasst und dann rein in den Mega88.

Der Lenze Motor ist sicherlich ein 230/400V Motor, betreibst Du den auch mit den 12V Zwischenkreisspanung? Das währe natürlich ziemlich wenig.

Hast Du ein Scope zur verfügung?

Axel

Hallo

Danke für die Hilfe. Es geht jetzt alles. Das war wieder so ein blöder Fehler, weil ich eine fuse falsch gesetzt habe. Er hat den Takt immer durch 8 geteilt.
Muss ich einfach nur die Tabelle erweitern, damit der Motor noch schneller dreht?

Gruß Julian

Hallo Julian,
schön wenn es nun geht.

Der Umlaufzähler für Omega ist "verantwotlich" für die Ausgangsfrequenz. Er wird im Timerinterrupt 0 "SIGNAL(SIG_OVERFLOW0)" hochgezählt. Die Ausgangsfrequenz ist der Kehrwert des Timerwert. Der 16 Bit Timer ist schon anderwertig gebraucht.

Das heißt nach 360 Durchläufen von Timer 0 hat sich der Motor einmal gedreht. Nun ist der Timer 0 leider ein 8 Bit Timer mit einer begrenzten Auflösung. Wenn der Motor sich schneller drehen soll muss der Vorteiler geändert werden und die Werte in der Tabelle müssen angepasst werden. Am besten mit Excel rechnen und die Werte in die Tabelle "const unsigned char fbwfl[67]" kopieren. Zur Zeit wird z.B. der Timerwert 183 für eine Ausgangsfrequenz von 12 Hz geladen.

Axel

Hallo

Wo änder ich denn der Vorteiler und wie weit darf ich ihn verändern?

Gruß Julian

es steht dort wo es immer steht:
void initial(void)
{
//.......
TCCR0B = 3; // count with cpu clock/64 CS02 CS01 CS00 = 0 1 1 clkI/O/64 (From prescaler)

Hallo

Ich habe den Vorteile von dem 8 Bit timer jetzt auf 2(Systemtakt/16)gesetzt.
Nach welcher Formel wurden die Werte in der Tabelle errechnet?
Der Motor läuft so auch schneller ohne die anpassung der Tabelle, aber er verbaucht sehr viel Strom und läuf unsauber.

Gruß Julian

Hallo Julian,
eine 2 bedeutet : clkI/O/8 (From prescaler)Steht auf Seite 106 im Datenblatt.
woher hast Du Systemtakt/16??

Durch die Änderung läuft der Motor 8 mal schneller (Vorher Systemtakt / 64 nun Systemtakt / 8). Das heisst, bei vollem Sollwert sind es 8*66Hz = 528 Hz! Das ist natürlich viel zu schnell bei einer Pulsfrequenz von 2,5Khz. Natürlich auch viel zu schnell für den Motor. Die Reibung wird den Motor schon voll auslasten, er kann auch mechanisch auseianderfliegen.

Daher sollte die Tabelle mit den Timerwerten angepasst werden, damit vernünftige max Frequenzen herauskommen. Wenn der Timer 360 mal durchlaufen wurde hat sich der Motor ein mal gedreht (OK der Anker).

Du hast den Systemtakt 20Mhz geteilt durch 8, dann hast Du die Zeit für den zwischen den Aufrufen der Timerroutine wenn der Timerwert 254 ist (oder255?). Wenn der Timerwert 253 ist wird der Interrupt nur noch halb so oft aufgerufen usw.usw.usw. Kann man schön in Excel ausrechnen und im AVR Studio ausprobieren.

Axel

Hallo
Ich hab den FU jetzt das erste Mal an 230 V getestet mit dem Originalprogramm und der Motor läuft grauenhaft. Er verbraucht im Leerlauf schon 3 A und läuft
ruppig.

Lenze
50Hz
0,37kw
910 U/min

Hier noch ein Video bei max Drehzahl.Wenn ich ihn langsamer drehen lasse wir es noch schlimmer.
http://www.youtube.com/watch?v=ywVAQz2g2JA

Gruß Julian

Hallo Julian,
der Motor hört sich wirklich grauselig an. Konntest Du schon die Ausgangsspannung an drei Widerständen bei 30V Zwischenkreisspannung mit dem Scope messen?

Axel

Hallo
Ich hab mal über einen 470 Ohm Widerstand gemessen zwischen einer Phase und dem Sternpunkt bei 30V.
Hier das Bild:

[IMG=http://img15.imageshack.us/img15/1184/dsc01796i.th.jpg][/IMG][/URL]

Hab leider kein Speicherscope.

Gruß Julian

Hallo Julian,
Achtung Fehlerteufel in: void initial(void)

DDRB = 0x2b; // PortB2 ist ein Eingang der Rest sind Ausgänge
Achtung: Hier stand fälschlicherweise DDRB = 0x1b !!!! geändert am 14.03.2010

Das könnte die Erklärung für deinen seltsamen Motorlauf sein.

Axel

Danke nochmal für die Hilfe, aber es geht immer noch nicht . Das kann aber auch an dem mega88 liegen der ist teilweise kaputt. Ich werden den nochmal tauschen
und ein Speicherscope besorgen .

Gruß Julian

Es geht jetzt. Hatte eine Halbbrücke an die LED angeklemmt, wie es Programm steht. Jetzt hab ich einen anderen Ausgang genommen nund das Programm umgeschrieben.Der Motor läuft sauber hoch und runterund zieht 1A im Dreieck, aber manchmal "verschluckt" er sich alles 10-20 sekunden.

Gruß Julian

Hallo Julian,
klasse dass es jetzt läuft, freut mich echt.
Diesen Rucker hatte ich auch mal gehabt, bei mir hat ein 4,7K Pull Up an den Steuereingängen geholfen. Die internen Pull Up reichen in der verseuchten Umgebung nicht.

Axel

== Spannung an ohmschen Widerstand ==
Es wurde eine Zwischenkreisspannung von ca. 24V angelegt.
Am Ausgang des FU werden drei Widerstände 470 Ohm im Stern geschaltet. Die Spannung wird über einen Widerstand gegen den Sternpunkt der Widerstände gemessen.

Je nach dem aktuellen Sektor sehen die Spanungsverläufe so oder invers aus.

[[Bild:FU_Spannug_an_ohmschen_Widerstand_P1020274a_.jpg|400px]]

[[Bild:FU_Spannug_an_ohmschen_Widerstand_P1020265a_.jpg|400px]]

Hallo

Hab das genau so gemessen wie oben beschrieben, aber ich bekomme das nicht getriggert. Deshalb sieht das etwas komisch aus.(siehe Bild oben)

MfG Julian

Hallo Julian,
habe die Triggerlevel klein eingestellt und mit der Speichertaste gespielt bis ich die Bilder hatte.

Axel

== Brückengleichrichter so wirklich OK? ==

Wenn ich richtig sehe wird eine Diode des Brückengleichrichters kurzgeschlossen und ist damit unnötig (OK ist auch nicht weiter schlimm). Eine andere Diode schließt negative Halbwellen von P nach N durch und dürfte vermutlich recht war werden oder schnell aufgeben und kaputt gehen.

Ich denke es wäre besser nur 2 Dioden, bzw. nur den halben Brückengleichrichter zu benutzen.
Das Netz wird hier übrigens nur unsymmetrisch belastet, da die negative Halbwelle überhaupt nicht benutzt wird.

Oder übersehe ich etwas? (Siehe Grafik)

[[Datei:Kurzschluss.JPG]]

Der Minus vom Zwischenkreis liegt natürlich nicht auf Erde. Da gibt es zwar ein Massesymbol, dies ist nicht mit der Erdungssymblol zu verwechseln.

Der Zwischenkreis Minus liegt auf 127V gegen Erde.

Axel

Hmm, ok. Ich sehe gerade das das ganze in dem Eagle file OK ist. Der Schaltplan "Bremschopper_3.png" im Artikel selbst ist aber scheinbar verkehrt weil er diesen Kurzschluss hat.

Viele Grüße, Kai (der gerade eine 2 Phasen Variante mit 90 Grad Phasenverschiebung baut für Kondensatormotoren).

Ich hab die stellen hier mal markiert:
[[Datei:ausschnitt.jpg]]

OK, der untere Masseanschluss ist natürlich Unfug.
Axel

Treiber

2011-09-27T06:33:27Z

Jackfritt: /* Beispiele zu Low-Side Treibern */

Ein '''Transistor-Treiber''' ist eine Schaltung, welche den nötigen Strom zur Verfügung stellt, um einen großen [[Transistor]] in der erforderlichen Zeit ein- bzw. auszuschalten. Es handelt sich dabei meist um einen Verstärker mit zusätzlichem [[Pegelwandler]]. Dadurch ist es möglich, mit einem Logikausgang, welcher meist mit 5 oder 3,3V betrieben wird, große Lasten mit [[FET|MOSFETs]] bzw. [[IGBT|IGBTs]] zu schalten. Dieser Treiber kann analog (linear) oder digital arbeiten.

In diesem Artikel wird hauptsächlich auf die Besonderheiten zur Ansteuerung von MOSFETs und IGBTs in der Leistungselektronik Bezug genommen, welche geschaltet betrieben werden. Diese Treiber sind digitale [[MOSFET-Übersicht#Mosfet-Treiber | MOSFET-Treiber]]

==Anwendung ==

[[FET | MOSFETs]] und [[IGBT]]s werden mit einer Spannung gesteuert. Bei einer Gate-Source bzw. Gate-Emitter Spannung von 0V ist das Bauteil gesperrt bzw. hochohmig. Steigt die Spannung über die sogenannte "Schwellenspannung" (engl. threshold voltage) – die für Leistungsbauteile zwischen ca. 3 und 4,5V liegt –
geht das Bauteil langsam vom gesperrten in den leitenden Zustand über. Bei einem weiteren Spannungsanstieg bis zu einem Level von ca. 12V verringert sich der Einschaltwiderstand beim MOSFET bzw. der Kollektor-Emitter Spannungsabfall beim IGBT auf den im Datenblatt angegebenen minimalen Wert. Eine weitere Erhöhung führt nur zu einer vergleichsweise geringen Reduktion des Widerstandes bzw. Spannungsabfalls und erhöht die Energiemenge, die beim Schalten durch den Treiber
umgeladen werden muß dramatisch (P~U² !). Praktisch beschränkt man sich daher meist auf Gatespannungen zwischen 12...18V. Aufgrund von unvermeidbaren, sehr kleinen parasitären Effekten tritt meist ein geringes Überschwingen der Gatespannung auf. Zusammen mit diesem Überschwingen darf die Gatespannung bei nicht "Logic-Level" FETs 20V nie überschreiten.

Im Betrieb fällt an einem Leistungstransistor immer eine bestimmte Verlustleistung an. Diese Verluste teilen sich auf in "Schaltverluste" und "Leitend- bzw. ON-Verluste". Die ON-Verluste sind hauptsächlich vom Leistungsschalter selbst abhängig, die Schaltverluste hingegen von der Schaltgeschwindigkeit. Je schneller ein FET/IGBT ein- bzw. ausgeschaltet wird, desto geringer sind die Schaltverluste.

Leider gibt es hier neben physikalischen Grenzen insbesondere unerwünschte Nebenwirkungen, nämlich die EMV ('''E'''lektro '''M'''agnetische '''V'''erträglichkeit). Je schneller geschaltet wird, desto stärker sind die Störungen die dadurch erzeugt werden. Diese Störungen sind sehr schnell so stark, daß andere Schaltungen im Umkreis von einigen Metern beeinflußt werden d.h. die USB Maus leuchtet plötzlich auf, ohne daß sie bewegt wurde bzw. der eigene Mikrocontroller macht nicht mehr was er eigentlich sollte. EMV ist Heute eines der wichtigsten "Krisenthemen" während der Entwicklungsphase, daher nicht auf die leichte Schulter nehmen.

=== Gatebeschaltung ===

Zwischen Treiberstufe und Schalter sind in fast allen Fällen einige passive Bauteile vorhanden. Dies wird hier im Weiteren als "Gatebeschaltung" bezeichnet.
 Hier ein Beispiel mit "Vollausstattung" und die dazugehörige Erklärung:

# Gatewiderstand "R_g1", um die Schaltgeschwindigkeit den Erfordernissen anzupassen. Je schneller die Schaltflanke, desto geringer die Schaltverluste. ABER Je schneller die Schaltflanke, desto größer die erzeugten Störungen (EMV). Gleichzeitig hat ein schnelles "Abschalten" auch einen starken Überschwinger (snap-off einer Diode und/oder Selbstinduktion (inductive kick)) zur Folge. Aus diesem Grund wird häufig
# ein Widerstand "R"_g2 und eine Diode "D" in Serienschaltung dem o.g. Gatewiderstand "R_g1" parallelgeschaltet, und zwar so, daß ein langsames ausschalten (D gesperrt) aber ein schnelles einschalten (D leitend und damit R_g1 parallel zu R_g2) ermöglicht wird, d.h. R_g1 || (R_g2+D).
# Um das empfindliche Gate zu schützen, wird oft eine Z-Diode, besser eine schnellere Transil-Diode (Transient Suppressor Diode) so zwischen "Gate" und "Source" bzw. "Emitter" geschaltet ("Kathode" am "Gate"), daß das "Gate" vor Spannungen > 20V geschützt wird. Bei einem sauberen Aufbau kann diese Sicherheitsfunktion normalerweise entfallen. Bei Testaufbauten ist eine 16V Transil-Diode Aufgrund der dort häufig vorkommenden Induktivitäten (Drahtverhau ;-) SEHR zu empfehlen. Das gleiche gilt für die
# Klemmdiodenkombination (Z- bzw. Transil Diode, antiseriell mit einer normalen Diode) zwischen "Drain" bzw. "Kollektor" und Gate so ("Kathode" der Z-Diode an "Drain" bzw. "Kollektor"), daß die Diode das Gatepotential anhebt, wenn die "Drain-Source" bzw. "Kollektor-Emitter" Potential in die Nähe der maximalen Blockierspannung (Spannungsfestigkeit) des Schalters kommt bzw. den vom Entwickler definierten, maximalen Spannungslevel erreicht. Dieses "anheben" führt dann zu einem vergleichsweise hochohmigen Einschalten des Schalters und damit zum VERLUSTBEHAFTETEN Energieabbau. Bei einem 30V FET verwendet man üblicherweise z. B. eine 24V Transil-Diode, bei 150V FET z. B. eine 130V Transil-Diode und bei einem 600V IGBT z. B. eine 540V Transil-Diode. Die antiserielle Diode, die verhindert, daß die Gatespannung bei fehlender Leistungsversorgung über die Transildiode abfließt, muß die gleiche Spannungsfestigkeit wie der Schalter aufweisen.

=== Treiberleistung ===

IGBT und FET sind zwar spannungsgesteuerte Bauelemente, trotzdem muß bei jedem Einschalten und bei jedem Ausschalten die Gatekapazität umgeladen werden, wozu ''Strom'' erforderlich ist. Der Energiegehalt eines Kondensators wird mit

:<math>E= \frac{1}{2} \cdot C \cdot U^2</math>

berechnet. Es ist jedoch der Energiebedarf bei jedem Aufladen und Entladen zu berücksichtigen. Zur Ermittlung der wirksamen Kapazität, welche in der Formel benötigt wird, hat es sich bewährt, die Datenblattangabe für "Cies" beim IGBT, bzw. den Datenblattwert für "Ciss" beim FET mit dem Faktor 5 zu multiplizieren.

Daher ergibt sich die Treiberleistung wie folgt:

:<math>P_\text{treiber} = 5 \cdot Cx \cdot U_g^2 \cdot f_\text{schalt}</math>

Zum Beispiel bei Ug=18V, Cies=4nF und ƒschalt=5kHz beträgt Ptreiber=32mW.

Bei größeren Strömen mit einer höheren Frequenz – z. B. Induktionsheizung – wird die Ansteuerleistung schon sehr interessant, z. B. Ug = 18V, Cies=20nF und ƒschalt=250kHz, hier beträgt Ptreiber=8,1W. Zusätzlich muß der Eigenverbrauch des Treibers berücksichtigt werden, der durchaus zwischen 0,5 und 1 W liegen kann.

=== Definition zu Low- und High-Side Schalter===

;Low-Side–Schalter: Der FET schaltet eine Last gegen GND – auch als ''LS-Schalter'' bezeichnet.

;High-Side–Schalter: Der FET schaltet eine Last an die Versorgungsspannung – auch als ''HS-Schalter'' bezeichnet.

===Beispiele zu Low-Side Treibern===

Nachfolgend ein paar Beispiele, die sowohl für FETs, als auch für IGBTs verwendet werden können. Achtung! Auch wenn bei FETs eine Diode (Bodydiode) implementiert ist, muß bei induktiven Lasten oder langen Zuleitungen sowohl bei FETs als auch bei IGBTs eine schnelle Diode parallel zum Leistungsschalter eingesetzt werden. Diese Diode – die hier im Beispiel nicht gezeigt ist – muß räumlich direkt neben dem Leistungsschalter platziert werden. Bitte beachten, daß jede Treiberschaltung sowohl an den Leistungsschalter, als auch an den gesamten Lastkreis individuell angepaßt werden muß.

[[Bild:Beispiel_LS_Treiber_1_2.png|miniatur|ohne|600px|Beispiele zu diskreten LS-Treibern ]]

Treiber-1 eignet sich eher dazu langsamere Schaltvorgänge mit Kleinsignal-FETs durchzuführen, aber auch höhere Leistungen sind prinzipiell so machbar, wenn man sich die höhere Verluste durch die langsame Ansteuerung erlauben kann.
Der Widerstand R26 sollte an das gewünschte Schaltverhalten angepaßt werden, weniger als ca. 100Ohm ist wegen der Stromtragfähigkeit des gewählen T4 nicht zu empfehlen. Das Schaltverhalten ist hier sehr unsymmetrisch ("langsam ein", sehr schnell "aus"). Sollten größere Ströme geschaltet werden wird eine andere Ansteuermöglichkeit empfohlen.

Treiber-2 ist durchaus in der Lage höhere Impulsleistungen an den Leistungstransistor zu liefern.
Letztendlich ist der maximale Strom von der Stromtragfähigkeit von T1&T2 abhängig. Die Gatewiderstände sind für schnelles (stromloses!) Einschalten und etwas langsameres Abschalten ausgelegt. Das oben gezeigte Beispiel kann so angepaßt werden, daß beim Abschalten nur ein kleiner Spannungsüberschwinger (10..20% der Betriebsspannung) zu sehen ist. Die Anbindung von C1 ist relativ kritisch, auf kürzest mögliche Anbindung ist zu achten

Zu beachten ist, daß Treiber 2 am Eingang vor R4 ein Signal erwartet, welches für "An" bereits auf der benötigten Gate-Spannung des FETs (typischerweise 10V) liegt. Steht dagegen nur ein Logik-Signal mit 5V oder 3.3V zur Verfügung, so muß diese zuerst über eine weitere Stufe erhöht werden. Folgende Schaltung erledigt dies. Zu beachten ist aber, daß dadurch das Eingangssignal invertiert wird.
[[Bild:Beispiel_LS_Treiber2_LogicLevel.png|miniatur|ohne|600px|Diskreter LS-Treiber 2 für LogicLevel-Signal]]

[[Bild:Beispiel_LS_Treiber_3.png|miniatur|ohne|600px|Beispiel eines LS-Treibers mit Logikbausteinen]]

Dieses Schaltungsbeispiel ist gut geeignet, um Leistungsfets mit einer mittleren Leistung anzusteuern. Es ist zu empfehlen einen Leistungsschalter mit geringer Gateladung (Qg) auszusuchen. Achtung auf den Maximalstrom den der Inverter liefern kann. Der 4069 sollte mit ca. 12V, max. 15V betrieben werden. Wenn ein Logic-Level Schalter ausgesucht wird, ist ein auch 74AC14 (kein AHC) zu empfehlen.

[[Bild:Beispiel_LS_Treiber_4.png|miniatur|ohne|600px|Beispiele eines LS-Treibers mit einem fertigen IC]]

Oben im Bild ist ein kommerzieller Treiber-IC zu sehen – hier im Beispiel 2127 von IR. Hierzu gibt es jedoch sehr viele Alternativen, sowohl von IR, als auch von anderen Firmen. Die Beschaltung ist jedoch immer relativ ähnlich, siehe dazu [[MOSFET-Übersicht#Mosfet-Treiber | MOSFET-Treiber]].

Achtung! Der GND-Zweig des Leistungskreises hat bei unsachgemäßem Aufbau einen recht großen Einfluß auf die beim Schalter ankommende Gatespannung. Je nach Aufbau führt das zu einer zu geringen Gatespannung im Schaltmoment – U_gs direkt am Schalter bricht beim Einschalten ein – oder zu einer Überspannung am Gate – U_gs schwingt über die Gatetreiberversorgung hinaus. Beides führt vermutlich früher oder später zu einer Zerstörung des Leistungsschalters. Letzters kann oft durch eine 15V-Z-Diode direkt am Schalter zwischen Gate und Source bzw. Emitter verhindert werden, eine Optimierung des Layouts bzw. der Verdrahtung ist jedoch zielführender. Beschreibungen hierzu im weiteren Verlauf des Artikels.

Die oben gezeigte Masseführung ist nicht zum Spaß ''genau so'' gezeichnet. Durch eine unsaubere Masseführung – und dazu zählt z. B. auch schon der Anschluß der Treiber-Masse direkt am GND-Symbol statt direkt am Schalter – kann der Treiber oder der Schalter durch Überspannung zerstört werden. Auch ein zu starkes "Unterschwingen" des GND-Potentials gegenüber des gerade auf Masse gelegten Gatesignals führt unweigerlich zur Zerstörung des Treibers. Viele Bausteine sind bis zu einer Spannungsdifferenz von ca. –5V betriebsfähig. 
10cm Kabel besitzen eine parasitäre Induktivität von ca. 100nH. Werden 50A in 1µs geschaltet – was schon relativ langsam ist – entsteht bei jedem Schalten eine Selbstinduktionsspannung von 100nH·50A/1µs = 5V.

===Beispiele zu High-Side Treibern===

Nachfolgend ein paar Beispiele zu HS-Treibern, die sowohl für FETs, als auch für IGBTs verwendet werden können. Bitte beachten, daß jede Treiberschaltung sowohl an den Leistungsschalter, alsauch an den gesamten Lastkreis individuell angepaßt werden muß.
High-Side Treiber sind etwas komplexer aufgebaut. Der Versorgungsspannungskreis muss isoliert zur restlichen Beschaltung aufgebaut werden. Auf die Isolationsabstände ist besonders zu achten.

Achtung: Auch wenn bei FETs eine – meist unzureichende – Diode implementiert ist, sollte bei induktiven Lasten (oder langen Zuleitungen) sowohl bei FETs, als auch bei IGBTs eine schnelle Diode parallel zum Leistungsschalter eingesetzt werden. Diese Diode – die hier im Beispiel nicht gezeigt ist – muß räumlich direkt neben dem Leistungsschalter implementiert werden.

[[Bild:Beispiel_HS_Treiber_1.png|miniatur|ohne|600px|Beispiel eines diskreten HS-Treibers ]]

Hier im ersten Beispiel eine diskrete Ansteuerung für einen HS-Schalter. Achtung, das Signal durch die Push-Pull-Stufe invertiert. Statt Q5/Q6 wird empfohlen einen integrierten high speed Treiber wie z. B. die sehr preisgünstigen MC34151 oder MC34152 zu verwenden.
Die hier abgebildete Beschaltung – die ohne weitere Veränderung bei geringerer Schaltleistung auch ohne die Push-Pull Stufe betrieben werden kann – ist für eine Betriebsspannung von ca. 400V ausgelegt. Der Widerstand R12 (hier 4k7) muß an eine geänderte Spannung angepaßt werden. Für 40V beträgt er in dieser Beschaltung 3k3. Diese Schaltung kann auch sehr einfach simuliert werden.

[[Bild:Beispiel_HS_Treiber_2.png|miniatur|ohne|600px|Beispiel eines HS-Treibers mit einem fertigen IC ]]

Das zweite Beispiel verwendet einen integrierten HS-Schalter von International Rectifier (IR) und eine separate, isolierte Versorgungsspannung. Zum IC gibt es sehr viele Alternativen, sowohl von IR, als auch von anderen Firmen. Die Beschaltung ist jedoch immer relativ ähnlich, siehe dazu [[MOSFET-Übersicht#Mosfet-Treiber|MOSFET-Treiber]]

[[Bild:Beispiel_HS_Treiber_3.png|miniatur|ohne|600px|Beispiel eines HS-Treibers mit Bootstrap Versorgung ]]

Das dritte Beipiel unterscheidet sich zum vorhergehenden nur dadurch, daß die Versorgungsspannung für den Treiber über eine Bootstrap-Schaltung gewonnen wird. Näheres im weiteren Verlauf dieses Artikels.

Die oben gezeigte Leitungsführung für Treiberbezugspotential und GND-Potential ist auch hier nicht zum Spaß ''genau so'' gezeichnet. Durch eine unsaubere Leitungsführung – und dazu zählt z. B. auch schon der Anschluß des Treiber-Bezugspotentials nicht direkt an Emitter bzw. Source – kann der Treiber oder der Schalter durch Überspannung zerstört werden. Auch ein zu starkes "Unterschwingen" des GND-Potentials gegenüber des gerade auf Bezugspotential gelegten Gatesignals führt unweigerlich zur Zerstörung des Treibers. Viele Bausteine sind bis zu einer Spannungsdifferenz von ca. –5V betriebsfähig.
10cm Kabel besitzen eine parasitäre Induktivität von ca. 100nH. Werden 50A in 1µs geschaltet – was schon relativ langsam ist – entsteht bei jedem Schalten eine Selbstinduktionsspannung von 100nH*50A/1µs = 5V.

=== Stromversorgung eines High-Side Treibers ===

Jede Treiberstufe benötigt eine entsprechende Spannungsversorgung.
Bei einem LS-Schalter gestaltet sich dies relativ einfach, da die Versorgungsspannung im Bereich von 12..15V über dem GND Potential
liegt.

Bei einem High Side N-Kanal Schalter ist deutlich mehr Aufwand nötig, da hier die Treiberspannung 12..15V über dem Sourcepotential des HS-Schalters liegen muß. Das Source-Potential liegt beim HS-Schalter je nach Anwendungsfall auf 12V bis 400V, manchmal sogar noch höher.

==== Versorgung über isolierte DCDC Wandler ====

Die Versorgung hierfür kann relativ einfach mit integrierten DCDC-Wandlermodulen aufgebaut werden, wie sie für wenig Geld bei Conrad oder Reichelt verfügbar sind (Leistung und Isolationsspannung beachten!).

==== Versorgung durch eine Bootstrap Schaltung====

Wenn es sich bei der Applikation um eine Halbbrücke handelt und der HS-Schalter nicht dauerhaft eingeschaltet sein muß (Tastverhältnis <100%), sondern regelmäßig getaktet wird ([[PWM]]), kann die Versorgung des HS-Schalters auch aus der massebezogenen Versorgung des LS-Schalters generiert werden. Diese Schaltung nennt sich ''Bootstrap''.

Immer wenn der LS einer Halbbrücke eingeschaltet ist, liegt das Source Potential des High Side Schalters auf GND. In diesem Zeitraum kann der Kondensator am Treiber des HS-Schalters über eine Diode aufgeladen werden. Energiequelle ist hierbei die Spannungsversorgung des LS-Schalters. Siehe dazu eines der Beispiele oben.

=====Bootstrapkondensator=====

Der Bootstrapkondensator soll eine niederinduktive und niederohmige Pufferung des Energiebedarfes für einen Schaltvorgang bereitstellen, daher ist ein Keramikkondensator oder auch ein Folienkondensator erforderlich. Den Energiebedarf eines Schaltvorganges ergibt sich recht einfach:

:<math> C = \frac{Q_\text{gate}}{\Delta U}</math>

Beispiel: Als erlaubten Spannungseinbruch während der Energieentnahme wird hier 0,5V festgelegt. Die gesamte Gateladung Qgate (Total gate charge) ist hier z. B. 58nC bei Ug=10V. Daraus errechnet sich eine Minimalkapazität von 58nC / 0,5V = 116nF. Die Erfahrung zeigt, daß ein großzügiges erhöhen um den Faktor 3..8 sinnvoll ist, da in der Rechnung weder Leckströme des FETs und des Kondensators noch der Energieverbrauch der Treiberschaltung selbst berücksichtigt wird. Des Weiteren ist die Gateladung nur für 10V angegeben. Höhere Gatespannungen erfordern eine höhere Energiemenge. Achtung: je größer der Kondensator gewählt wird, desto mehr Zeit wird zum Laden des Kondensators über die strombegrenzende Bootstrapdiode benötigt.

Auch wenn der Kerko für die Pufferung der Schaltenergie ausreichend ist, ist es meist sinnvoll einen Elko/Tako parallel zu schalten. Die dort gespeicherte Energie hilft z. B. wenn eine längere "on" Zeit erforderlich ist. Genauso verringert der zusätzliche Energiespeicher den zum Ladungsausgleich erforderlichen Strompuls des Kerkos. Dadurch verbessert sich das EMV-Verhalten des Treibers meßbar.

=====Auslegung des Bootstrapdiodenzweiges =====

# Die Spannungsfestigkeit der Diode muß größer sein, als die auftretende Maximalspannung des Lastkreises.
# Im ersten Ansatz muß die Recovery-Zeit der Diode (trr) mindestens um den Faktor 10 kürzer sein, als die minimale "on" Zeit des LS-FETs. Ist z. B. der LS-FET immer für mindestens 10ms ein, ist eine 1N4007 (trr ca. 1µs) ausreichend. Bei höheren Schaltfrequenzen genügt oft eine UF4007 (trr ca. 75ns). In einer Halbbrücke bedeutet eine längere trr-Zeit jedoch, daß der Bootstrapkondensator des HS-Treibers beim Einschalten solange entladen wird, bis die Diode wieder sperrt. In diesem Fall muß die schnellere Diode unabhängig von der "on" Zeit ausgewählt werden
#Der zulässige Strom durch die Diode ist das letzte Auswahlkriterium. Da der Strom kaum kontrollierbar ist muß er mit einem Widerstand begrenzt werden. Bei einer 1N4007 beträgt der wiederholbare Maximalstrom 1A. Die Diode hat als sogenannten ''Single pulse'' aber eine deutlich größere Strombelastung (Datenblattangabe UF4007 = 30A). Da der Kondensator nur beim ersten Einschalten komplett vollgeladen, im Betrieb aber wie hier im Beispiel berechnet nur um <0,5V aufgeladen wird, kann der Widerstand kleiner ausfallen. Daher ist in diesem Beispiel bei 15V Versorgungsspannung und Ausnutzung eines 50% = 15A Peaks für das erste Aufladen ein Minimalwiderstand von (15V – 1,5V) / 15A = 0,9Ω erforderlich. Der Widerstand wird auf 1Ω festgelegt. Die 1,5V stammen vom Spannungsabfall an der Diode bei 1A, bei höheren Strömen steigt der Spannungsabfall an.

Aus dem Wert des Bootstrap-Kondensators, des -widerstandes und des Tastverhältnisses (hier im Beispiel auf 2% festgelegt) ergibt sich eine minimale "on" Zeit für den LS-Schalter von
: t = Rbt · Cbt / D
d.h. 1Ω · 470nF / 0,02 = 23,5µs. Schneller als gut 40kHz sollte in diesem Beispiel also nicht geschaltet werden, da sonst der Bootstrapkondensator nur unzureichend nachgeladen werden kann.

===Besonderheiten beim Treiberaufbau===

[[Bild:Gatekreis_Bild1.png|miniatur|left|300px|Gatekreis, wie im Schaltplan gezeichnet]]
Fast jeder, der schon einmal eine geschaltete Leistungsendstufe in Betrieb genommen hat, mußte feststellen, daß der Leistungsschalter nicht immer genau das macht, was man vorher geplant hatte. Die Hauptursache ist meist – neben Problemen mit der Leistungsversorgung selbst, siehe weiter unten – der Gatekreis.

Die abgebildete Schaltung zeigt einen Aufbau wie er – unabhängig wie die Treiberstufe selbst umgesetzt wird – standardmäßig im Schaltplan implementiert ist.

{{Absatz}}

[[Bild:Gatekreis_Bild2.png|miniatur|rechts|350px|Gatekreis, wie er real auf der PCB vorhanden ist]]

Rechts ist der Gatekreis so gezeichnet, wie er sich unter realen Bedingungen wirklich darstellt.

Es ist hier nicht die Frage, ob diese parasitären Einflüsse wirklich vorhanden sind oder nicht, sondern nur wie groß die Werte sind. Hier sind unterschiedliche Einflüsse dargestellt, die sich teilweise gegenseitig beeinflussen.

# R & L zwischen Source und GND: Das "Treiber GND" Signal ist wie deutlich zu sehen DIREKT am Source Anschluß des FETs angeschlossen, und nicht am GND-Fußpunkt des Leistungspfades von "Vcc" zu "GND".Jeder Zentimeter der Leitung zwischen Source und GND beeinflußt den Gatekreis. Sobald der FET durchschaltet entsteht an den o.g. parasitären Bauteilen (Induktivität und Widerstand) ein Spannungsabfall, der dem Gatesignal entgegenwirkt, und damit z. B. beim Einschalten die am FET anliegende Gatespannung reduziert.
# R & L zwischen den Treiberausgängen "Gate Signal" und "Treiber GND": Da der Widerstand im unteren mΩ-Bereich liegt kann dieser Einfluß hier ignoriert werden. Die Induktivität im Gatekreis bremst jedoch den Signalanstieg am Gate, sodaß auch das Schaltverhalten beeinflußt wird. Hier besteht auch die Gefahr, daß die Induktivität mit der Gatekapazität einen Schwingkreis bildet.
# Überkopplung über Ciss: Wenn das Drainpotential z. B. beim abschalten plötzlich von "GND" auf "Vcc" springt, findet über Ciss eine überkopplung auf das Gatesignal statt. Diese Potentialanhebung kann im schlimmsten Fall zum wiedereinschalten des FETs oder zu Oszillationen führen.

;Fazit: Die Schleife zwischen den Treiberausgängen "Gate Signal" und "Treiber GND" muß ''unbedingt'' so klein wie möglich gehalten werden. Sitzt der Treiber nicht direkt am Leistungs-FET, ist es empfehlenswert die zwei Kabel so kurz wie möglich halten und zu verdrillen. Auf eine direkte Anbindung an Source bzw. Emitter ist zu achten!

;FAQ:

FET wird zu heiß:
*Verlustleistung zu hoch, Ursache könnte sein daß
**die Gatespannung zu niedrig ist,
**die Schaltgeschwindigkeit und damit die Treiberleistung zu gering ist oder
**Schwingungen auf der Gateleitung vorhanden sind.
*Die Kühlung ist unzureichend
**da keine oder falsche Isolierfolie oder,
**ein zu kleiner Kühlkörper verwendet wird.

== Leistungselektronik ==

=== Parallelschalten von Leistungstransistoren===

FETs und IGBTs lassen sich relativ einfach parallelschalten, wenn ein paar wenige Grundsätze beachtet werden:
# Jeder Transistor bekommt einen eigenen Gate-Vorwiderstand bzw. eine eigene R||RD Beschaltung (Gatebeschaltung).
# Die Gatebeschaltung wird möglichst nahe am Gate- und Source-Anschluß angebracht und bezüglich Leitungslänge (Induktivität) symmetriert. Die Zuleitung zu den Gatebeschaltungen ist unkritischer.
# Die Leistungsanbindung an Drain und Source – hier zählt "mΩ" und "nH" - wird symmetrisch aufgebaut.
# Die Schleife "Kondensator — Last — FET — Kondensator" wird minimiert.
# Jedes Bauteil wird nur zu <80% des maximal Möglichen ausgelastet. Trotz der hier genannten Maßnahmen können Asymmetrieen auftreten.

Sollten auf den Gateleitungen Schwingungen zu beobachten sein, kann es helfen, in ''jede'' Verbindung von Gatetreiber-Source zum Sourceanschluß des Schalters je einen Widerstand zu integrieren. Der Wert sollte bei etwa 10..30% des Gatewiderstandes liegen.

=== Stützkondensator ===

==== Einführung ====

[[Bild:Leistungsteil_Bild1.png|miniatur|left|350px|Einfache Endstufe wie im Schaltplan gezeichnet]]
Im nebenstehenden Bild ist der "Standard-Schaltplan" einer Endstufe mit ohmscher Last zu sehen.

Nehmen wir an, der Entwickler hat eine neue Autobatterie mit 13,5V als Stromquelle, und einen Heizwiderstand (L des Widerstandes hier vernachlässigt) mit 0,1 Ω. Der FET und die je 1m langen Zuleitungen haben zusammen 4mΩ. Dies ergibt einen Maximalstrom von ca. 130A.

Die Leistung des Heizwiderstandes soll mit einer PWM-Frequenz von 10kHz geregelt werden. In den nachfolgenden Beispielen wird ein Tastverhältnis von 50% fest vorgegeben
{{Absatz}}

[[Bild:Zwischenkreiskondensator_Ideal.png|miniatur|left|350px|Idealer Spannung- und Stromverlauf an einer ohmschen Last]]
Und hier der '''ideale''' Spannungs- und Stromverlauf zwischen FET und Lastwiderstand.
{{Absatz}}

[[Bild:Zwischenkreiskondensator_Real1.png|miniatur|left|350px|Annähernd realer Spannung- und Stromverlauf an der ohmschen Last mit Induktivitäten in der Zuleitung]]
Jetzt blicken wir der Realität ins Auge, und fügen bei unveränderter Gateansteuerung für die je 1m langen Versorgungsleitungen von- und zu der Batterie eine Induktivität von 1µH in das Simulationsmodell ein. Ohne genaue Kentniss des Lastkreises bzw. der Verdrahtung kann eine parasitäre Induktivität von 10nH/cm angenommen werden.

Deutlich ist zu erkennen, daß der Strom gerade einmal 120A anstatt 130A erreicht. Die Stromformen ist nicht vergleichbar.
Des Weiteren erreicht die Spannung am Drain des 30V FETs knapp 900V, was schnell zu einem zerstörten Bauelement führt.
{{Absatz}}

Ist kein Stützkondensator vorhanden, wird der gesammte AC-Stromrippel direkt aus der Batterie gezogen, was
# einen hohen Überspannungsimpuls erzeugt.
# die Zuleitungen als Sendeantenne mißbraucht (EMV).
# nicht den gewünschten Strom und Stromverlauf im Widerstand erzeugt.
# die Batterie selbst mit Mikrozyklen belastet.
# mit höchster Warscheinlichkeit einen häßlichen Ausschwinvorgang erzeugt (EMV).

[[Bild:Zwischenkreiskondensator_Real2.png|miniatur|left|350px|Annähernd kompensierter Spannung- und Stromverlauf an der ohmschen Last mit Induktivitäten in der Zuleitung ]]
Hier ein Beispiel mit einem Stützkondensator. Die beim Kondensator vorhandenen, parasitären Einflüsse sind in dieser Simulation nicht berücksichtigt um die Komplexität zu minimieren.

Designkriterien für den Kondensator folgen.

Der Einfluß des Kondensators ist deutlich sichtbar. Der rechteckförmige Stromverlauf ist schon fast wieder erkennbar... genauso wie eine Schwingneigung im entstandenen LC-Kreis ;-(
{{Absatz}}

==== Design des Stützkondensators ====

Den im Vergleich zwischen den beiden obigen Simulationen fehlende Strom liefert der Kondensator. Die parasitären Elemente dieses Bauteiles haben je nach Typ mehr oder weniger Einfluß in dieser Anwendung.

=====Ersatzschaltbild eines Kondensators=====

[[Bild:Kondensator_Ersatzschaltbild_einfach.png|miniatur|right|350px|Vereinfachtes Ersatzschaltbild eines Kondensators]]
Unabhängig vom Kondensatortyp besitzt jeder Kondensator nicht nur die aufgedruckte Kapazität, sondern auch einen internen Widerstand (ESR), und eine interne Induktivität (ESL).

Bei gewickelten Kondenstoren (fast alle Elkos und viele Folienkondensatoren) ist die parasitäre Induktivität aufbaubedingt größer, als bei geschichteten Folienkondensatoren. Für die meisten Anwendungen genügen jedoch Elektrolytkondensatoren, die bezahlbar und mit fast beliebigen Werten verfügbar sind.

Häufig ist es einfacher und preiswerter, mehrere Elkos parallel zu schalten, als auf Folienkondensatoren umzusteigen. Achtung: auf symmetrische Anbindung der parallelgeschalteten Bauteile zum Leistungsschalter achten! Es gibt jedoch einige Anwendungen – meist mit höherer Frequenz oder sehr kurzer Impulszeit (Induktionsheizung [Resonanz-C], elektromagnetische Beschleuniger, Coin-Schrinker, ... ) die die Verwendung von impulsfesten Folienkondensatoren (z. B. MKP10, FKP1,... ) erforderlich machen.
{{Absatz}}

=====Kondensatorauswahl=====

Die Bestimmung der benötigten Kapazität und Anzahl der Kondensatoren hängt ab von...

# Frequenz (Schaltfrequenz × 2)
# Flankensteilheit (trise, tfall)
# Tastverhältnis = Effektive Strombelastung (nicht Mittelwert!)
# Kühlmöglichkeiten (Verluste im Kondensator, Temperaturerhöhung, Kühlanbindung)
# ESR
# Betriebsspannung

[[Bild:RMS-Berechnung.png|miniatur|right|350px|Berechnung der RMS-Ströme für die am häufigsten vorkommenden Signalformen]]
Aufgrund der vielfältigen Möglichkeiten wird ein stark vereinfachter Ansatz verfolgt, der für den nicht professionellen Anwendungsfall als ausreichend erscheint. (Verbesserungsvorschläge sind jederzeit erwünscht! bitte über PN)

# Betriebsspannung definieren. Diese Spannung nur zu ca. 80% ausnutzen.
# Betriebspunkte festlegen: a) Wie lange dauert die Stromentnahme (dt in s), b) wie hoch ist der Peakstrom (I in A) und c) um welchen Wert darf die Spannung dadurch einbrechen (dU in V)?
# Über die Näherung C = I·dt/dU die dafür benötige Kapazität in Farad berechnen. Den nächsten, größeren Wert als minimum Wert wählen.
# Effektivwert der Strombelastung berechnen – siehe die folgende Übersicht unten – Wenn die Stromform im Augenblick unbekannt ist wäre der Versuch angebracht die ungefähre Stromform und damit die Belastung durch eine Simulation zu ermitteln. Ansonsten bleibt nur der Ansatz die Kondensatoren zuerst auf den Peakstrom auszulegen, was bei entsprechendem Geldbeutel der sichere Ansatz ist, und dann Stück für Stück die Anzahl der Kondensatoren zu reduzieren (siehe Punkt 8).
# Maximalstrom des Kondensators (bei Elkos bei 100Hz) aus dem Datenblatt auslesen. (Bei Folienkondensatoren den nächsten Punkt überspringen)
# Umrechnen des Datenblattwertes auf die Schaltfrequenz der eigenen Applikation (Umrechnungsbeispiel gilt nur für Elkos!): (von 100Hz auf 10Hz: I[10Hz] = I[100Hz]·0,8; von 100Hz auf 1kHz: I[1kHz] = I[100Hz]·1,3. Eine weitere Vergrößerung für höhere Frequenzen >1kHz ist so nicht zulässig, der 1kHz Wert bleibt bestehen.
# Wenn die Strombelastung größer als die im Datenblatt angegebene ist, mehrere Kondensatoren parallel schalten oder anderen Kondensatortyp wählen.
# Kondensator im Betrieb testen. Dazu wird der Kondensator in der Schaltung betrieben und dabei die Minimalspannung, die Maximalspannung und die Temperatur gemessen. Der Spannungseinbruch muß im selbst gewählten Rahmen bleiben, die Maximalspannung darf nie erreicht werden (Sicherheitsabstand!) und die maximal zulässige Betriebstemperatur des Bauteiles darf nicht erreicht werden (Messungen Anfangs in kurzen, dann je nach Änderungsgeschwindigkeit der Temperatur in längeren Abständen aufnehmen, bis sich die Temperatur auch nach einigen Minuten nicht mehr erhöht, sofortiger Abbruch bei erreichen der Maximaltemperatur!). Als Daumenregel gilt: Kann das Bauteil nicht mehr angefaßt werden (Vorsicht bei Spannungen über 40V!) ist es vermutlich überbelastet.
# Den Test unter Punkt 8. an mehreren Betriebspunkten wiederholen.

Auslegungskriterium bei Elkos ist die max. Rippelstrombelastbarkeit, bei Folienkondensatoren der erlaubte Spannungsrippel bzw. -einbruch. Nur in den seltensten Fällen wird die Verwendung von einem einzelnen Kondensator alle Probleme lösen. Die Parallelschaltung von mehreren Kondensatoren des gleichen Typs ist daher grundsätzlich zu empfehlen. Lieber mehrere Elko mit dem besten Preis-Leistungs Verhältnis, als ein Spezialtyp.
{{Absatz}}

=== Anbindung des Stützkondensators an den Leistungsteil ===
[[Bild:Leistungsteil_Bild2.png|miniatur|rechts|350px|Einfache Endstufe wie mit Verdrahtung und PCB umgesetzt ]]
Im Bild ist der Leistungspfad – bestehend aus Zuleitungen, Kondensator und Endstufe – mit den wirksamen parasitären Einflüssen dargestellt.
Die dort gezeigten parasitären Elemente zwischen Kondensator und Leistungsschalter stellen den kompletten Leistungszweig dar, der im Schaltvorgang belastet wird.

Die Optimierung der im Bild gezeigte Schleife – d.h. kürzest mögliche Verbindung mit minimierter Induktivität – muß beim Design oberste Priorität besitzen.
{{Absatz}}

===Kühlung der Leistungshalbleiter===

Beim Betrieb von Leistungshalbleitern wird Abwärme erzeugt. Dies geschieht sowohl im eingeschalteten Zustand, als auch bei jedem Ein- und Ausschalten.
Um eine Überhitzung und damit eine Zerstörung des Bauteiles zu verhindern muß diese Wärmeenergie entsprechend abgeführt werden. Ab einer Verlustleistung von 1..5W - je nach Größe des Bauteiles - ist es nicht mehr ausreichend wenn das Bauteil diese Energie nur abstrahlt. Am häufigsten werden diese Bauteile auf einen [[Kühlkörper]] geschraubt oder geklemmt, selten geklebt.

Sowohl die Oberfläche des Kühlkörpers als auch des wärmeerzeugende Bauteiles sind nicht eben und weisen eine gewisse Rauhigkeit auf. Dies bedeutet, daß sich die zwei Oberflächen nur punktuell berühren (meist nur mit wenigen Prozent der Gesamtfläche) und nicht auf der gesamten Fläche.

Luft hat eine sehr schlechte Wärmeleitfähigkeit und die Luft, die zwischen den zwei Oberflächen liegt, verhindert eine Wärmeleitung zwischen den zwei Teilen sehr effektiv. Als Daumenwert kann man sagen, daß 1µm Luft in etwa einem absoluten Wärmewiderstand von ca. 1K/W entspricht... jedoch wird es sich nur in den seltensten Fällen nur um einen Mikrometer handeln, sondern meistens deutlich mehr.

====Wärmeleitmaterialien:====

Diese Materialien verbessern die thermische Verbindung zwischen einem Bauteil, das Wärme erzeugt, und dem Bauteil, das diese Wärme durch Wärmestrahlung, Konvektion oder Wärmeleitung in ein Kühlmittel (Zwangskühlung durch Luft oder Wasser) abführt. Diese Materialien werden zwar "wärmeleit" -Folie bzw. -Paste genannt, leiten die Wärme jedoch nicht besonders gut...aber immer noch um mindestens den Faktor 100 besser als Luft... und genau das ist der Grund, warum diese verwendet werden müssen. (Kupfer leitet Wärme um den Faktor 15400 besser als Luft) Die Pasten enthalten meist Öle bzw. Wachse und Fette als Bindemittel und zur besseren Wärmeleitung Metalloxide bzw. Metall- oder Kohlenstoffpartikel als wärmeleitende Füllstoffe. Achtung: Die meisten Pasten neigen zur Austrocknung, verlieren also nach ca. 5 Jahren ihre wärmeleitenden Fähigkeiten und sind nur mehr als "Krümel" sichtbar.

Besondere Beachtung finden die Wärmeleitfolien, die auf beiden Seiten eine thermisch leitfähige, wachsartige Beschichtung aufweisen. Diese Beschichtung schmilzt unter Wärmeeinwirkung auf und füllt die Spalten zwischen den Oberflächen besonders gut. Folien dieser Art werden ''Phase Change Material'' genannt. Dieser erste Schmelzprozeß erfordert unter Umständen ein Nachspannen des Bauteiles nach dem ersten Aufheizen, da sich durch den Druck die Schichtdicke verringern kann. Achtung: ''Vor'' dem Aufheizen und Nachspannen hat die Wärmeleitfähigkeit noch nicht die möglichen Minimalwerte erreicht. Zum Teil ist die Wärmeanbindung noch um Faktoren schlechter, daher beim ersten Einschalten noch nicht voll belasten.

Hier eine Übersicht über die Wärmeleitfähigkeit von verschiedenen Materialien:

:{| class="wikitable" style="text-align:left"
|-
! Material || Wärmeleitfähigkeit [W/(m·K)] || Kommentar
|-
|Kupfer || 370 || schwankt zwischen ca. 350..400
|-
|Aluminium || 220 ||
|-
|Stahl || 50 || hochlegierte Stähle <20
|-
|Eisen || 80||
|-
|Silber || 430 ||
|-
|Zinn || 67 ||
|-
|Blei || 35||
|-
|Wärmeleitpasten || 3..10 ||
|-
|Luft || 0,024 ||
|-
|Wasser || 0,6||
|-
|Öl || 0,15||
|-
|}

Hier eine Übersicht über die Wärmeleitfähigkeit von ''ausgewählten'' Isolierfolien<ref>Wenn jemand gute und bezahlbare Folien findet/kennt, bitte hier mit allen Daten angeben.</ref> um dem Nutzer die Entscheidung zu erleichtern:

:{| class="wikitable" style="text-align:left"
|-
! Material || Wärmeleitfähigkeit [W/(m·K)] || Größe / Menge ||Bezugsquelle || ungefähre Kosten
|-
|WÄRMELEITFOL.86/82 ROT ||6,5 ||100×;100×0,25mm || C|| 14€
|-
|}
;Hinweis: Die Wärmeleitfähigkeit von Folien bezieht sich ausschließlich auf die Folie selbst. Selbst unter besten Bedingungen wird man die genannten Werte nicht erreichen, da durch den Übergang vom Bauteil in die Folie und von dort in den Kühlkörper ein zusätzlicher Wärmewiderstand entsteht. Eine Verschlechterung von ca. 30% oder mindestens 0,5K/W bei einem TO220-Bauteil ist zu erwarten.

Hier eine Übersicht über die Wärmeleitfähigkeit von ''ausgewählten'' Wärmeleitpasten<ref>Wenn jemand gute und bezahlbare Pasten findet/kennt, bitte hier mit allen Daten angeben.</ref> um dem Nutzer die Entscheidung zu erleichtern:

:{| class="wikitable" style="text-align:left"
|-
! Material || Wärmeleitfähigkeit [W/(m·K)] || Größe / Menge ||Bezugsquelle || ungefähre Kosten
|-
|Artic Silver ||8,9 || 3,5g || C || 13,95€
|-
|Standard Pasten auf Silikonbasis ||3,0|| 3g..150g|| C / Rei / ... || wenige €/g
|-
|}

Montagerichtlinien:
* Die so beliebten Bohrungen in eine blanken Kühlfahne des Transistors wie z. B. beim TO-220 Gehäuse suggerieren eine fantastisch einfache Montierbarkteit. Wird die Schraube aber nur ein klein wenig zu fest angezogen, verformt sich das Kupfer der Kühlfahne und sorgt dafür, daß sich der Kunststoff umpresste Teil des Transistors ein klein wenig abhebt. Dies hat eine deutlich schlechtere Wärmeanbindung zur Folge. Die isolierte Bohrung bei vollständig umspritzten – nicht zu verwechseln mit auch auf der Rückseite isolierten – Bauteilen umgeht dieses Risiko, genauso wie der nachfolgende Montagevorschlag.
* Bei hohen Verlustleistungen ist zu empfehlen, das Bauteil gegenüber der Stelle aufzupressen, an der die Verlustleistung entsteht, also direkt auf dem Kunststoff des Transistors über dem Chip.
* Werden mehrere Bauteile parallel auf dem Kühlkörper montiert sollte zwischen den Bauteilen ''mindestend'' soviel Abstand vorgesehen werden, wie die Breite des Bauteiles beträgt. Dies vermindert die gegenseitige, thermische Beeinflussing der Bauteile und ermöglicht eine bessere Wärmeabfuhr
* Zur Montage mehrerer Bauteile eignet sich eine Metallschiene die direkt auf den Kunststoff drückt sehr gut. Zwischen ''jedem'' Bauteil ist ein Verschraubungspunkt vorzusehen, damit jedes Bauteil gleichmäßig aufgedrückt wird.
* Vor dem Aufbringen der Paste/Folie sowohl Bauteil als auch Kühlkörper mit Alkohol reinigen.
* Die Wärmeleitwerte für eine Paste beziehen sich auf eine meist nicht genannte aber trotzdem ''minimale'' Schichtdicke. Diese gelingt relativ reproduzierbar, wenn die Paste mit einem flachen Gegenstand (Rasierklinge, Lineal, ...) aufgebracht, verteilt und vorsichtig abgezogen wird, sodaß nur eine ''dünne'' Schicht auf dem [[Kühlkörper]] verbleibt. Dies erfordert einige Übung. Paste aufhäufeln, Bauteil eindrücken und befestigen erzielt bei weitem nicht die optimale Kühlleistung.

== Zusätzliche Hinweise ==

Anregungen oder Fragen auch gerne per Email an [http://www.mikrocontroller.net/user/show/powerfreak Powerfreak]. Dieser Artikel kann dadurch regelmäßig erweitert und ggf. durch ein FAQ ergänzt werden.

== Fußnoten ==
<references/>

== Siehe auch ==
* [[Mosfet-Übersicht]]
* [[IGBT]]
* [[FET]]

[[Kategorie:Bauteile]]
[[Kategorie:Leistungselektronik]]

Frequenzumrichter mit Raumzeigermodulation

2011-09-26T15:41:42Z

Jackfritt: /* Modulation */

von Axel Jeromin

[[Bild:FU_WR_und_Steuerung.jpg|600px]]

Die FETs befinden sich auf der Unterseite der Platine, so ließ sich der Kühlkörper leicher montieren. Trotz der waagerechten Ausrichtung der Kühlrippen wird der Kühlkörper nach 30 min Betrieb nur ca. 40° C warm.

'''Achtung Fehlerteufel in: void initial(void) im Programm WR88rzm3.c'''

DDRB = 0x'''2b'''; // PortB2 ist ein Eingang der Rest sind Ausgänge

Achtung: Hier stand fälschlicherweise DDRB = 0x'''1b''' !!!! geändert am 14.03.2010

Danke an Uwe Scholz für den Hinweis. Der Fehler war mir nicht aufgefallen, weil ich in meiner Schaltung den Ausgang B5 am Mega88 mit einer Messspitze gekillt hatte und per Drahtbrücke den Ausgang B1 benutzt habe. War leider zu geizig den Controller zu wechseln.

Noch ein Hinweis von Uwe: Im Programm für den Mega32 muss die Reihenfolge der Intialisierung des LCD und des übrigen Controllers gedreht werden. Das heißt zuerst die Ports und dann das LCD initialisieren. Sonst hängen die Ausgänge während der langen Wartezeiten zur Initialisierung des LCD undefiniert in der Luft. Nochmal Danke an Uwe.

== Einleitung ==

Ein Frequenzumrichter ist ein Gerät zur Veränderung der Drehzahl eines Drehstrom Asynchronmotors.
Die Drehzahl eines Drehstrom Asynchronmotors ist nur von der Frequenz der angelegten Spannung abhängig. Eine Verringerung der Netzspannung bei konstanter Frequenz über einen Trafo oder Vorwiderstände verändert durch den zunehmen Schlupf irgendwann auch die Drehzahl, das Ganze ist dann aber stark lastabhängig und somit unbrauchbar. Diese Methode wurde mal vor sehr vielen Jahren für einen Sanftanlauf genutzt.
Ebenfall vor vielen Jahren nutzte man zur Frequenzänderung einen Umformer bestehend aus einem Gleichstrommotor und einem Drehstromgenerator. (Hier und Dort auch Heute noch im Einsatz, z. B. Walzwerk).

Heute wird die Netzspannung gleichgerichtet, geglättet und eine Leistungselektronik erzeugt dann die dreiphasige Wechselspannung mit variabler Frequenz und Spannung.

Die nachfolgend beschriebene Schaltung war zuerst für den Einsatz in einem Eigenbau Elektroauto gedacht. Da Drehstrommotoren wesentlich häufiger in Gebrauchtmarkt anzutreffen sind, sind diese auch günstiger als Gleichstrommotoren. Der Gedanke war, einen vorhandenen Motor anders zu verschalten oder neu zu wickeln, sodass dieser an einer geringeren Spannung betrieben werden kann.

Die Schaltung eignet sich für DC-Spannungen von 30V bis 325V. Mit 30V kann z. B. ein Motor einer Festplatte betrieben werden (dies war mein Testmotor, bevor es an die höheren Spannungen ging) und 325V für einen 230/400V Motor in Dreieckschaltung. Natürlich kann man so ein Gerät mittlerweile für kleines Geld fertig kaufen, aber bei nicht gebräuchlichen Spannungen (Elektroauto) oder ungewöhnlichen Anwendungen ist man mit einem Selbstbau flexibler.

Achtung: die Schaltung ist potentialbehaftet. D.h das Massepotentional der Steuerspannung liegt bei Betrieb mit 230V auf ca. 127V gegen Erde! Daher ist bei Progammmodifikationen die Schaltung unbedingt von Netz zu trennen und aus einer Batterie zu speisen.

== Allgemeines ==
Ein moderner Frequenzumrichter besitzt in der Regel einen Gleichrichter, einen Zwischenkreis und einen Wechselrichter. Davor kommt noch ein Filter zur Verminderung von Störungen zurück in das einspeisende Netz. Der Gleichrichter soll die angelegte Wechselspannung gleichrichten. Die erzeugte pulsierende Gleichspannung ist bei einer 2 phasigen Einspeisung mit 230V ==> UDC = 230V * Wurzel 2 = 325V.

Der Zwischenkreis glättet und puffert die Gleichspannung. Er besteht aus einem oder mehreren Glättungskondensatoren. Bei Spezialanwendungen wie z. B. einem Elektroauto wird auf die Einspeisung verzichtet und der Zwischenkreis direkt an die Akkus angeschlossen.

Der Wechselrichter besteht aus drei Halbbrücken. Jede Halbbrücke hat zwei Mos-Fet Transistoren. Je nachdem welcher FET der Halbbrücke leitet, liegt der Brückenabgriff an Plus oder Minus. Sind beide Transistoren leitend, gibt es einen prima Kurzschluss, den es zu vermeiden gilt.

== Hardware ==

=== Einspeisung und Bremschopper ===
Die Einspeisung besteht aus: den Eingangsklemmen, dem Filter, dem Gleichrichter und dem ersten Zwischenkreiskondensator.
Im Eingangskreis ist ein Ladewiderstand, welcher mittels eines Relais überbrückt werden kann. Das Relais wird ab einer eingestellten Zwischenkreisspannung vom Tiny45 geschaltet, um die Kondensatoren zuerst über den Widerstand langsam zu laden.
Anmerkung zu den Kondensatoren: sie müssen ausreichend spannungsfest sein (>400V aushalten). 450V Typen dürften reichen. Kondensatoren, die geeignet sind finden sich z. B. in Schaltnetzteilen. eBay hat auch öfters welche.
Die Kapazität ist abhängig von der Last. Hier wurden insgesamt 2000µF verwendet.

C11, C12 und die Drossel sind ein Filter um Störungen zurück ins Netz zu minimieren. Laut Wikipedia sind gute Werte: C11=100nF, C12=4,4nF und eine 1:1 Drossel mit 1 mH pro Spule.

Arbeitet der Motor generatorisch, d.h. die Motordrehzahl ist größer als der Umrichtersollwert, wird Energie in den Zwischenkreis gespeist. Da die Energie nicht durch den Einspeisegleichrichter zurück ins Netz gelangen kann, steigt in diesen Fall die Zwischenkreisspannung. Die Zwischenkreisspannung muss daher überwacht werden, ab einem bestimmten Wert wird ein sogenannter Bremswiderstand eingeschaltet, in welchen die überschüssige Energie in Wärme umgewandelt wird.

Der Bremschopper FET wird vom Low-Side Teil eines IR2101 getrieben. Als Bremswiderstand nutze ich eine Glühlampe.

Von einem Tiny45 wird die Zwischenkreisspannung gemessen. Ist die Spannung grösser 243V und kleiner 408V wird die Meldung “Zwischenkreis OK” herausgegeben. Ab einer Spannung von 243V wird das Relais zur Überbrückung des Ladewiderstands geschaltet. Ab 375V wird der Bremswiderstand gepulst. 375V entspricht 0% PWM, 400V entspricht 100% PWM. Die PWM Frequenz ist 150Hz. Zum Messen der Zwischenkreisspannung wurde ein Spannungsteiler mit 3 Widerständen je 270k (3 Stk. zur Erhöhung der Spannungsfestigkeit) und einem Poti zum justieren gearbeitet. Das Poti hat 10K, dadurch kann die Spannung am Analogeingang nicht so hoch werden.

[[Bild:Bremschopper_3.png|400px]]

Die Schaltung ist für eine 2 phasige Einspeisung mit 230V gedacht. Bei anderen Eingangsspannungen muss die Erzeugung der Steuerspannung von der Gleichrichtung getrennt werden. Die 15V und 5V können dann über ein Steckernetzteil oder DC/DC Wandler gewonnen werden.

=== Leistungsteil ===
Der Leistungsteil besteht im Wesentlichen aus drei Halbbrücken. Jeweils zwei FET´s in einer Halbbrücke werden von einem IR2109 getrieben, welcher wieder direkt durch den Atmel Mega 88 auf der Steuerungsplatine angesteuert wird. Der IR 2109 steuert immer in Abhängigkeit vom Eingang “IN” entweder den High side- oder den Low side FET durch. Zwischen dem Wechsel liegt immer eine Totzeit von 540ns. Dadurch ist der Programmierer von der Kurzschlussproblematik befreit.

In den Halbbrücken sind auch auf der High-Side N-Kanal Fet´s eingesetzt. Diese haben den Vorteil, dass sie günstiger und leistungsfähiger gegenüber P-Kanal Fet´s sind. „Problematisch“ ist an ihnen jedoch, dass ihre Gatespannung oberhalb der Zwischenkreisspannung liegen muss. Zur Erzeugung dieser Spannung wird bei jedem Schalten des Low side FET über eine Diode ein Kondensator geladen, aus welchem die Spannungsversorgung zur Ansteuerung des High side FET gewonnen wird. Low und Highside werden über eine Periode der Ausgangsspannung gleich oft geschaltet, so kann der sogenannte Bootstrap Kondensator immer nachgeladen werden. ('' Bootstrap ist lt. Wikipedia: englisch für Stiefelschlaufe, sinngemäß: sich an den eigenen Stiefeln [aus dem Sumpf] herausziehen '')

Der Ausgangsstrom ist natürlich von den eingesetzten Leistungsschaltern abhängig. Die Schaltung ist mit IRPF 460 (500V Rds< 0.27 Ohm 18.4A) bestückt. Da jeder Transistor durch die Ansteuerung mit Raumzeigermodulation über eine Sinusschwingung zu 50% eingeschaltet ist, kommt man an einen theoretischen Ausgangsstrom von 36,8A. Mit einigen Sicherheitsfaktoren sollten 5-10A Dauerphasenstrom möglich sein, getestet habe ich aber nur mit einem 500W Drehstromgebläse.
Die Platine ist zusätzlich mit Lack isoliert, in sauberer Umgebung reicht der Leiterbahnabstand auch so, aber bei etwas Luftfeuchte ist Lack besser als ein Loch in der Platine.

'''Leistungshalbleiter:'''
In der Schaltung sind zwei Satz FET´s parallel geschaltet. Der zweite Satz braucht nur bei größerem Strombedarf bestückt werden. Die FET´s werden nach der Zwischenkreisspannung und dem Ausgangestrom ausgewählt. Bei 325V sind IRFP460 eine gute Wahl.
Im Schaltplan sind unterschiedliche Mos-Fet´s angegeben, es sollten aber alle gleich sein.
Die Leiterbahnen müssen evtl. durch Auflöten von Kupferdraht verstärkt werden. Reines Verzinnen bringt durch den relativ hohen spez. Widerstand von Zinn nicht so viel.

[[Bild:FU_Wechselrichter.PNG|800px]]

=== Steuerung ===
Die Ansteuerung des Leistungskreis wird mittels Software-PWM realisiert. Zu einer präzisen Bildung der notwendigen Steuersignale ist eine kurze Programmlaufzeit notwendig. Eine LCD Ausgabe oder das Einlesen von Analogwerten sprengt den möglichen Rahmen. Daher ist die Steuerung auf zwei Prozessoren aufgeteilt.

Ein Mega 88 @20Mhz steuert die Halbbrücken. Er erhält den Frequenz- und Motorspannungssollwert über parallele Eingänge von einem Mega32. Dadurch konnte das Programm und damit auch die Zykluszeit kurz gehalten werden (12,15µs im Hauptprogramm).

Der Mega 32 ist der gemütliche Verwalter. Er liest den analogen Sollwert, Ist-Zwischenkreisspannung, Ist-Zwischenkreisstrom , Ist-Drehzahl ein und stellt die Werte auf dem LCD dar.

Der analoge Sollwert ändert sich durch die Rampe des Hoch- und Rücklaufgebers entsprechend langsam, sodass Sollwertsprünge und damit Stromspitzen z. B. beim Motoranlauf vermieden werden. Zur Zeit ist eine Rampe von 2 Sekunden für eine Änderung von 0 auf 50 Hz eingestellt. Der Wert kann im Programm angepasst werden.

Die Ist-Drehzahlerfassung soll mit einem Hallgeber und einem Magneten an der Motorachse realisiert werden. Dieser Programmteil ist aber noch nicht getestet. Ein Drehzahl von 3000U/min ergibt 50U/sec, dies sollte sich über einen normalen Portpin erfassen lassen.

Der Ist-Strom wird nur im Zwischenkreis gemessen. Ein OP verstärkt den Spannungsabfall über einen Shunt. Durch die Zwischenkreiskondensatoren ist der Strom hier einigermaßen glatt und lässt sich mit dem Analogeingang messen. Eine Messung der Phasenstromes hab ich nicht mehr auf der Platine unterbekommen und müsste extern erfolgen.

=== Verbindung Steuerung Leistungsteil ===
Auf der Steuerungsplatinne liegen auf dem Wannenstecker PL2, der auch für die Programmierung genutzt werden kann die folgenden Portpins:

Pin 1 am Stecker --> PB3 --> in1 auf dem Leistungsteil

Pin 9 am Stecker --> PB4 --> in3 auf dem Leistungsteil

Pin 7 am Stecker --> PB5 --> in2 auf dem Leistungsteil

Pin 3 am Stecker --> PD7 --> SD 1 bis 3 auf dem Leistungsteil (mit Brücken weiter verbinden)

In dem Wannenstecker ist eine Buchse mit einem Flachbandkabel. Das Kabel ist aufgetrennt und die notwendigen vier Leitungen sind mit den Anschlüssen auf dem Leistungsteil verlötet. Die anderen Adern sind isoliert.

[[Bild:FU_Steuerung_Anschluss.PNG|800px]]

Achtung: mittels Flachbandkabel keine weiteren Masserverbindungen zwischen Steuerung und Leistungsteil herstellen, da sonst eine Masseschleife entsteht und größere Ströme über die dünne Leitung fließen könnten.

=== Verbindung Steuerung LCD ===
In dem Wannenstecker LCD Port ist eine Buchse mit einem Flachbandkabel. Das Flachbandkabel ist wie folgt mit dem LCD verbunden:

PORT B 0 => LCD PORT 1 => Pin am Display 11 => DB4

PORT B 1 => LCD PORT 2 => Pin am Display 12 => DB5

PORT B 2 => LCD PORT 3 => Pin am Display 13 => DB6

PORT B 3 => LCD PORT 4 => Pin am Display 14 => DB7

PORT B 4 => LCD PORT 5 => Pin am Display 4 => RS

PORT B 5 => LCD PORT 6 => Pin am Display 6 => E

Siehe auch : [[Uc-wiki:AVR-Tutorial: LCD|AVR-Tutorial: LCD]]

== Steuerprogramm ==

Da der IR 2109 immer den High '''oder''' Low Side FET ansteuert, sind '''immer drei''' der sechs FET´s des Leistungsteils leitend. Es ergeben sich die folgenden Ausgangsmuster, wobei z. B. 001 bedeutet, dass den Halbbrücken 1 und 2 der Low Side FET und in der Halbbrücke 3 der High Side FET leitet. Je nach Motorschaltung (Stern oder Dreieck) ergeben sich unterschiedliche Spannungen an den Motorwicklungen '''u''' , '''v''' und '''w'''.

{| border="1"
|-
|
|
|
| Stern
|
|
|
|Dreieck
|
|
|-
|
|
|
| u
| v
| w
|
| u
| v
| w
|-
| Muster 1
|'''001'''
|
| -1/3 Udc
| -1/3 Udc
| +2/3 Udc
|
| 0 V
| - Udc
| + Udc
|-
|Muster 2
|'''011'''
|
| -2/3 Udc
| +1/3 Udc
| +1/3 Udc
|
| - Udc
| 0 V
| + Udc
|-
|Muster 3
|'''010'''
|
| -1/3 Udc
| +2/3 Udc
| -1/3 Udc
|
| - Udc
| + Udc
| 0 V
|-
|Muster 4
|'''110'''
|
| +1/3 Udc
| +1/3 Udc
| -2/3 Udc
|
| 0 V
| + Udc
| - Udc
|-
|Muster 5
|'''100'''
|
| +2/3 Udc
| -1/3 Udc
| -1/3 Udc
|
| + Udc
| 0 V
| - Udc
|-
|Muster 6
|'''101'''
|
| +1/3 Udc
| -2/3 Udc
| +1/3 Udc
|
| + Udc
| -Udc
| 0 V
|}

[[Bild:FU_Motorspannungen.PNG|600px]]

Im obigen Bild sind die geschalteten Ventile zur Vereinfachung weggelassen. Durch die Parallelschaltung von jeweils zwei Motorwicklungen in der Sternschaltung teilt sich die Zwischenkreisspannung im Verhältnis 1/3 zu 2/3 auf. Bei der Dreiecksschaltung wird jeweils eine Wicklung kurzgeschlossen, die Spannung ist hier 0 Volt.

Werden die Ausgangsmuster der Reihe nach ausgegeben, so wird der Rotor des angeschlossenen Motors seine Lage um jeweils 60 Grad verändern. Man spricht von den sechs Spannungsvektoren oder Raumzeigern. Hinzu kommen noch die Muster 000 und 111 bei welchen die Motorspannung 0V ist, da alle Wicklungen an + Udc oder - Udc hängen (Nullspannungsvektor).
Gibt man nun die Ausgangsmuster 1 bis 6 mit der entsprechenden Frequenz heraus, bekommt man eine Drehbewegung des Motors hin. Der Lauf des Motors ist aber ruckelig und der Motor erwärmt sich, da durch das Schalten der Rechtecke eine Menge Blindstrom im Motor unterwegs ist.

== Raumzeigermodulation ==
Für einen runden Lauf des Motors und natürlich zur Minimierung der Verluste, muss der Motorstrom möglichst sinusförmig sein. Eine Ansteuerung durch eine analoge Verstärkerschaltung würde immense Verlustleistung hervorrufen. Daher kommt nur eine Realisierung mittels PWM in Frage.

=== Pulsfrequenz ===
Die Höhe der PWM Frequenz ist immer ein Spagat zwischen Schaltverlusten und einer sauberen Nachbildung des Sinus. Je höher die Pulsfrequenz umso besser wird der Sinus getroffen, aber die Schaltverluste in den Leistungshalbleitern steigen ebenfalls. Bei Profigeräten sind Pulsfrequenzen zwischen 5KHz und 16 KHz üblich.

Realisiert ist in meinem Projekt eine '''Software PWM'''. In der Interrupt-Routine von Timer1 werden die Ausgänge entsprechend gesetzt. Durch die Normierung der nachfolgend erläuterten Tabelle mit den Sinuswerten, der Normierung der Spannungssollwerte und dem Prescaler (TCCR1B=2; // use CLK/8 prescale value, entspricht 0,4 µsec bei 20 MHz) kann die Pulsfrequenz verändert bzw erhöht werden. Dies habe ich aber noch nicht getestet. Für Ausgangsfrequenzen bis 50 Hz sind die 2,5Khz ganz OK. (Siehe Stromverlauf weiter unten)

Die Ausgabe wird in meinem Programm in 400µs lange Stücke geteilt. => Pulsfrequenz = 2,5KHz. Die Auflösung durch den Timer 1 ist 1000 Schritte (1000*0,4µs = 400µs).

=== Modulation ===

Die Raumzeigermodulation beruht auf folgenden Vorraussetzungen:

''' 1) ''' Durch den Halbbrückentreiber ist '''immer einer der beiden''' FET´s einer Halbbrücke leitend. (Totzeit vernachlässigt)

''' 2) ''' Gemäß der obigen Tabelle ergibt sich zum Beispiel bei einem im Stern geschaltetem Motor und einem Ausgangsmuster von 001 eine ''' statische ''' Spannung von -1/3 Udc in der Wicklung '''u''' des Motors (-1/3 Udc in '''v''' und +2/3 Udc in '''w'''). Bei dem Muster 011 eine Spannung von -2/3Udc in '''u''', +1/3 Udc in '''v''' und +1/3 Udc in '''w''' .

''' 3) '''Gibt man die beiden Muster abwechselnd aus, so ergibt sich in der Motorwicklung ein '''Mittelwert''' aus den beiden Spannungen. Vorausgesetzt man macht es schnell genug, so dass die Induktivität der Motorwicklung den Strom glättet.

''' 4) ''' Je nach zeitlichem Anteil der beiden Schaltzustände kann die Spannung im '''Verhältnis zu den beiden Zeitanteilen''' variiert werden. Wird z. B. das Muster 001 zu 25% der Zeit und das Muster 011 zu 75% der Zeit ausgegeben so ist die Spannung in der Wicklung '''u''': (0,25*-1/3Udc + 0,75*-2/3Udc)/2 = -0,58Udc

''' 5) ''' Der zeitliche Verlauf der Ausgangsspannung wird in '''gleich lange''' Blöcke, entsprechend der Pulsfrequenz aufgeteilt. In hier beschriebenen Programm sind dies 400µs. (siehe Pulsfrequenz)

''' 6) ''' In jedem dieser Blöcke werden vier unterschiedliche Ausgangsmuster mit meist unterschiedlichen '''Zeitanteilen''' ausgegeben. Die Zeitanteile der Muster heißen: To, Ta, Te und To. Die Berechnung der Zeitanteile wird nachfolgend beschrieben.

Für einen sinusförmigen Verlauf der Ausgangsspannung werden die Zeitanteile der beiden jeweiligen Ausgangsmuster in Verhältnis zu Sinus des Umlaufwinkels bewertet.

Durch die 6 Raumzeiger ist die Periode einer kompletten Sinusschwingung (und damit auch eine gesamte Motorumdrehung) in 6 Sektoren von jeweils 60 Grad Länge geteilt. Jeder Sektor hat eine Anfangsvektor und einen Endvektor mit dem entsprechenden Ausgangsmuster. Je nach dem Wert des Umlaufwinkels Omega wird der Anfangsvektor oder der Endvektor länger, bzw. kürzer eingeschaltet. Durch die Induktivität des Motors bildet sich ein Mittelwert der Spannung in der jeweiligen Motorwicklung proportional zu den Einschaltzeiten.
Im Programm läuft ein Zähler für Omega von 0 bis 59, dann wird der Sektorzähler erhöht und der Omega Zähler auf 0 gesetzt.

Ta = Zeit Anfangsvektor = proportional zu: sin (60-omega)

Te = Zeit Endvektor = proportional zu: sin (omega)

Da jedes Ausgangsmuster alle drei Wicklungen beeinflusst, braucht zur Erzeugung der benötigten Spannungen nur eine Berechnung der Schaltzeiten für alle drei Wicklungen stattfinden. Die Spannung in den anderen beiden Wicklungen ändern sich genauso.

Da der induktive Widerstand der Motorwicklungen frequenzabhängig ist, muss die Motorspannung umgekehrt proportional zur Frequenz verändert werden. Dies wird durch Verkleinerung der Einschaltdauer der spannungsführenden Vektoren und Ausgabe eines Nullspannungsvektors (Muster 000 oder 111) erreicht.

Ta = Zeit Anfangsvektor = proportional zu: sin (60-omega)* Motorspannung in %

Te = Zeit Endvektor = proportional zu: sin (omega)* Motorspannung in %

To = Zeit Nullspannungsvektor = Pulsperiode-(Zeit Anfangsvektor + Zeit Endvektor)

Für eine bessere Symmetrie wird To halbiert und jeweils vor und nach den Spannungsvektoren ausgegeben.
Die Nullspannung kann mit dem Muster 000 oder 111 erreicht werden. Zur Minimierung der Schaltverluste in den FET´s wird das Nullspannungsmuster gewählt, bei welchem nur eine Halbbrücke umgeschaltet werden muss. Die Schaltvorgänge werden ebenfalls minimiert, wenn in zwei aufeinander folgenden Pulsperioden die Muster in umgekehrter Reihenfolge ausgegeben werden. Der Mittelwert der erzeugten Spannung wird hierdurch nicht verändert.

{| border="1"
|Nullspannungsvektor
|Anfangsvektor
|Endvektor
|Nullspannungsvektor
|Nullspannungsvektor
|Endvektor
|Anfangsvektor
|Nullspannungsvektor
|-
|000
|010
|110
|111
|111
|110
|010
|000
|}

Werden anstelle eines Motors drei im Dreieck geschaltete Widerstände angeschlossen erhält man folgenden Spannungsverlauf:

[[Bild:FU_Spannung_an_ohmschen_Widerstand.jpg|400px]]

Es ist zu erkennen, wie der Anteil der positiven Spannungsanteile mit jeder Pulsperiode (0,4ms oder 2 Einheiten lang) zunimmt.

=== Programm für Atmel Mega 32 ===
Der Prozessor bekommt über 8 Eingänge (analog oder digital) die Steuerbefehle und gibt über parallele Ausgänge die Steuerbefehle an den Mega88 für die Raumzeigermodulation. Angesteuert wird auch ein LCD zur Anzeige vom Ist-Spannung, Ist-Strom, Ist-Drehzahl und Sollwerten.

Da sich die Ausgangssignale nur relativ langsam ändern, wird der Prozessor mit 1Mhz internem Oszillator betrieben

'''Timerinterrupts'''
Timer 0 = Hoch- und Rücklaufgeber. Sollwertintegraton, damit bei Sollwertsprüngen die Motordrehzahl langsam geändert wird. Der Eingangssollwert sollvh wird intergriert zum vorzeichenbehafteten Sollwert sollnh

'''Hauptprogrammablauf: '''
Einlesen des Sollwerts sollvh, Bildung des absoluten Sollwerts sollabs, Bildung des Richtungssignals und Bildung des Freigabesignals.

Einlesen von Ist-Spannung, Ist-Strom, und analogen Sollwerten.

Ausgaben an des LCD

Messung der Ist-Drehzahl

Und wieder nach oben in der Endlosschleife

=== Programm für Atmel Mega 88 ===
Der Prozessor bekommt den Frequenzsollwert, den Spannungssollwert, die Drehrichtung und das Freigabesignal über parallele Eingänge übermittelt. Angesteuert werden die drei Halbbrücken (IN), die Freigabeeingänge der Brückentreiber (SD) über einen gemeinsamen Ausgang und zwei LED`s.
Hochgezählt wird im Programm der Zeiger für den aktuellen Stand Sinusschwingung am Ausgang (Omega), aufgeteilt in 6 Sektoren. Daraus berechnet werden die Einschaltzeiten der Halbbrücken für jeweils zwei PWM-Perioden (Pulsperioden, zur Unterscheidung von der Periode der Ausgangsspannung).

'''Timerinterrupts'''

'''Timer 1''' = Ausgabe der Ausgangsmuster.

Die Timerwerte werden im Hauptprogramm berechnet und in drei Arrays abgelegt (pzh[8]; pzl[8]; pm[8]).

Es wird der „pulszykluszaehler“ für die Ausgabe des gewünschten Ausgangsmusters über die dazugehörige Zeit von 0 bis 7 hochgezählt. 7 entspricht dem Ende der zweiten Pulsperiode.

Pulszykluszaehler 0 ==> Nullspannungsvektor

Pulszykluszaehler 1 ==> Anfangsvektorvektor

Pulszykluszaehler 2 ==> Endvektor

Pulszykluszaehler 3 ==> Nullspannungsvektor

Pulszykluszaehler 4 ==> Nullspannungsvektor

Pulszykluszaehler 5 ==> Endvektor

Pulszykluszaehler 6 ==> Anfangsvektorvektor

Pulszykluszaehler 7 ==> Nullspannungsvektor

'''Timer 0''' = Zähler für dem Umlaufwinkel und für den aktuellen Sektor. Die Timerwerte sind in einer Tabelle gespeichert und werden im Abhängigkeit vom Sollwert sollabs an den Timer gegeben Es wird omega bis 59 und sektor bis 6 hochgezählt.

'''Hauptprogrammablauf:'''
Einlesen des Sollwerts sollabs, der Ausgangsspannung spg, des Richtungssignals richtung und des Freigabesignals enable
Laden der Timerwerte aus der Tabelle fbwfl[sollabs] für den Timer 0 zum Zählen von Omega und den Sektoren
Zwischenspeicherung von Omega und Sektor, damit während der Berechnungen mit den gleichen Werten gerechnet wird. Berechnung der Timerwerte für Timer 1: Ta, Te, To gemäss Raumzeigermodulation mit den dazugehörigen Ausgangsmustern. Die Werte für Sinus Omega 0 bis 59 sind in der Tabelle sin[omega] gespeichert, die Werte für Sinus (60-omega) in der Tabelle sinkomp[omega].

Ta= (sinkomp[omega]*spannung[sollabs]);

Te= (sin[omega]*spannung[sollabs]);

To= ((1000-(Ta+Te))/2);

Speicherung der Ausgangsmuster und Timerwerte für zwei Pulsperioden

Und wieder nach oben in der Endlosschleife

== Funktionstest ==
=== Spannung an ohmschen Widerstand ===
Es wurde eine Zwischenkreisspannung von ca. 24V angelegt.
Am Ausgang des FU werden drei Widerstände 470 Ohm im Stern geschaltet. Die Spannung wird über einen Widerstand gegen den Sternpunkt der Widerstände gemessen.

Je nach dem aktuellen Sektor sehen die Spanungsverläufe so oder invers aus.

[[Bild:FU_Spannug_an_ohmschen_Widerstand_P1020274a_.jpg|300px]]

[[Bild:FU_Spannug_an_ohmschen_Widerstand_P1020265a_.jpg|300px]]

=== Motorstrom ===

Hier das Ergebnis aller Bemühungen:

[[Bild:FU_Motorstrom_30Hz.jpg|400px]]

Motorstrom in einem angeschossenen Drehstrommotor über einen Shunt gemessen bei 30Hz Ausgangsfrequenz.

[[Bild:FU_Testkandidaten.jpg|400px]]

Hier die Testkandidaten, die alle thermischen Misshandlungen ausgehalten haben.

== Downloads ==

* Einspeisung [[Media:FU_Einspeisung.zip‎|download zip-File]]

* Leistungsteil [[Media:FU_Wechselrichter.zip‎|download zip-File]]
* Leistungsteil Schaltplan [[Media:FU_Wechselr_Schaltplan.zip‎|download zip-File]]

* Steuerung [[Media:FU_Steuerung.zip|download zip-File]]
‎

== Verluste ==

3 Stück IR2109 , 1 Stück Mega 8 , 1 Stück Mega 88 , 4 Stück IRFP150 verstarben in treuer Pflichterfüllung durch Unachtsamkeiten des Benutzers

= Umrichter von Uwe Scholz =
Steuerung und Bremsschopper sind weitgehend gleich geblieben, nur im Dickstromteil gab es größere Änderungen. Der mußte auch zweiseitig werden, da Drahtbrücken unter dem Kühlkörper nicht gegangen wären.

Der Trafo ist auch eine Numer größer, 0,5W war mir gefühlsmäßig etwas zu wenig. Falls ich noch einen bauen sollte, dann würde ich aber schon wieder ein paar Sachen anders machen;-)

[[Bild:FU_Uwe_Scholz_1.jpg‎|400px]]

[[Bild:FU_Uwe_Scholz_2.jpg‎|400px]]

[[Bild:FU_Uwe_Scholz_3.jpg‎|400px]]

[[Bild:FU_Uwe_Scholz_4.jpg‎|400px]]

= Umrichter von Patrick Leube =
Die Steuerung wurde über zwei Atmega 88 realisiert.
Die sechspuls Brückenschaltung ist etwas Abgespeckt worden.
Da dieser Umrichter für Akkupacks von 36V-60V ausgelegt wurde muste noch eine "Netzteil" gebastelt werden das 15V und 5V generiert.
Die Bedinung erfolgt über Taster für Sollwertvorgabe +/- RUN / STOP.
Als LCD kam ein 4*20 zum Einsatz.

Verluste: 1* LT1074HV = 12€

Da dieses Projekt mein erstes wirkliches Projekt mit µC und Elektronik im tieferen Sinne war möchte mich an dieser stelle auch nochmal bei Axel für seine Unterstützung bedanken.

[[Bild:FU_Patrick_1.jpg|300px]]

[[Bild:FU_Patrick_2.jpg|300px]]

[[Kategorie:AVR-Projekte]]
[[Kategorie:Leistungselektronik]]
[[Category:1. Wettbewerb]]
[[Kategorie:Spannungsversorgung und Energiequellen]]

Frequenzumrichter mit Raumzeigermodulation

2011-09-26T15:40:21Z

Jackfritt: /* Steuerprogramm */

von Axel Jeromin

[[Bild:FU_WR_und_Steuerung.jpg|600px]]

Die FETs befinden sich auf der Unterseite der Platine, so ließ sich der Kühlkörper leicher montieren. Trotz der waagerechten Ausrichtung der Kühlrippen wird der Kühlkörper nach 30 min Betrieb nur ca. 40° C warm.

'''Achtung Fehlerteufel in: void initial(void) im Programm WR88rzm3.c'''

DDRB = 0x'''2b'''; // PortB2 ist ein Eingang der Rest sind Ausgänge

Achtung: Hier stand fälschlicherweise DDRB = 0x'''1b''' !!!! geändert am 14.03.2010

Danke an Uwe Scholz für den Hinweis. Der Fehler war mir nicht aufgefallen, weil ich in meiner Schaltung den Ausgang B5 am Mega88 mit einer Messspitze gekillt hatte und per Drahtbrücke den Ausgang B1 benutzt habe. War leider zu geizig den Controller zu wechseln.

Noch ein Hinweis von Uwe: Im Programm für den Mega32 muss die Reihenfolge der Intialisierung des LCD und des übrigen Controllers gedreht werden. Das heißt zuerst die Ports und dann das LCD initialisieren. Sonst hängen die Ausgänge während der langen Wartezeiten zur Initialisierung des LCD undefiniert in der Luft. Nochmal Danke an Uwe.

== Einleitung ==

Ein Frequenzumrichter ist ein Gerät zur Veränderung der Drehzahl eines Drehstrom Asynchronmotors.
Die Drehzahl eines Drehstrom Asynchronmotors ist nur von der Frequenz der angelegten Spannung abhängig. Eine Verringerung der Netzspannung bei konstanter Frequenz über einen Trafo oder Vorwiderstände verändert durch den zunehmen Schlupf irgendwann auch die Drehzahl, das Ganze ist dann aber stark lastabhängig und somit unbrauchbar. Diese Methode wurde mal vor sehr vielen Jahren für einen Sanftanlauf genutzt.
Ebenfall vor vielen Jahren nutzte man zur Frequenzänderung einen Umformer bestehend aus einem Gleichstrommotor und einem Drehstromgenerator. (Hier und Dort auch Heute noch im Einsatz, z. B. Walzwerk).

Heute wird die Netzspannung gleichgerichtet, geglättet und eine Leistungselektronik erzeugt dann die dreiphasige Wechselspannung mit variabler Frequenz und Spannung.

Die nachfolgend beschriebene Schaltung war zuerst für den Einsatz in einem Eigenbau Elektroauto gedacht. Da Drehstrommotoren wesentlich häufiger in Gebrauchtmarkt anzutreffen sind, sind diese auch günstiger als Gleichstrommotoren. Der Gedanke war, einen vorhandenen Motor anders zu verschalten oder neu zu wickeln, sodass dieser an einer geringeren Spannung betrieben werden kann.

Die Schaltung eignet sich für DC-Spannungen von 30V bis 325V. Mit 30V kann z. B. ein Motor einer Festplatte betrieben werden (dies war mein Testmotor, bevor es an die höheren Spannungen ging) und 325V für einen 230/400V Motor in Dreieckschaltung. Natürlich kann man so ein Gerät mittlerweile für kleines Geld fertig kaufen, aber bei nicht gebräuchlichen Spannungen (Elektroauto) oder ungewöhnlichen Anwendungen ist man mit einem Selbstbau flexibler.

Achtung: die Schaltung ist potentialbehaftet. D.h das Massepotentional der Steuerspannung liegt bei Betrieb mit 230V auf ca. 127V gegen Erde! Daher ist bei Progammmodifikationen die Schaltung unbedingt von Netz zu trennen und aus einer Batterie zu speisen.

== Allgemeines ==
Ein moderner Frequenzumrichter besitzt in der Regel einen Gleichrichter, einen Zwischenkreis und einen Wechselrichter. Davor kommt noch ein Filter zur Verminderung von Störungen zurück in das einspeisende Netz. Der Gleichrichter soll die angelegte Wechselspannung gleichrichten. Die erzeugte pulsierende Gleichspannung ist bei einer 2 phasigen Einspeisung mit 230V ==> UDC = 230V * Wurzel 2 = 325V.

Der Zwischenkreis glättet und puffert die Gleichspannung. Er besteht aus einem oder mehreren Glättungskondensatoren. Bei Spezialanwendungen wie z. B. einem Elektroauto wird auf die Einspeisung verzichtet und der Zwischenkreis direkt an die Akkus angeschlossen.

Der Wechselrichter besteht aus drei Halbbrücken. Jede Halbbrücke hat zwei Mos-Fet Transistoren. Je nachdem welcher FET der Halbbrücke leitet, liegt der Brückenabgriff an Plus oder Minus. Sind beide Transistoren leitend, gibt es einen prima Kurzschluss, den es zu vermeiden gilt.

== Hardware ==

=== Einspeisung und Bremschopper ===
Die Einspeisung besteht aus: den Eingangsklemmen, dem Filter, dem Gleichrichter und dem ersten Zwischenkreiskondensator.
Im Eingangskreis ist ein Ladewiderstand, welcher mittels eines Relais überbrückt werden kann. Das Relais wird ab einer eingestellten Zwischenkreisspannung vom Tiny45 geschaltet, um die Kondensatoren zuerst über den Widerstand langsam zu laden.
Anmerkung zu den Kondensatoren: sie müssen ausreichend spannungsfest sein (>400V aushalten). 450V Typen dürften reichen. Kondensatoren, die geeignet sind finden sich z. B. in Schaltnetzteilen. eBay hat auch öfters welche.
Die Kapazität ist abhängig von der Last. Hier wurden insgesamt 2000µF verwendet.

C11, C12 und die Drossel sind ein Filter um Störungen zurück ins Netz zu minimieren. Laut Wikipedia sind gute Werte: C11=100nF, C12=4,4nF und eine 1:1 Drossel mit 1 mH pro Spule.

Arbeitet der Motor generatorisch, d.h. die Motordrehzahl ist größer als der Umrichtersollwert, wird Energie in den Zwischenkreis gespeist. Da die Energie nicht durch den Einspeisegleichrichter zurück ins Netz gelangen kann, steigt in diesen Fall die Zwischenkreisspannung. Die Zwischenkreisspannung muss daher überwacht werden, ab einem bestimmten Wert wird ein sogenannter Bremswiderstand eingeschaltet, in welchen die überschüssige Energie in Wärme umgewandelt wird.

Der Bremschopper FET wird vom Low-Side Teil eines IR2101 getrieben. Als Bremswiderstand nutze ich eine Glühlampe.

Von einem Tiny45 wird die Zwischenkreisspannung gemessen. Ist die Spannung grösser 243V und kleiner 408V wird die Meldung “Zwischenkreis OK” herausgegeben. Ab einer Spannung von 243V wird das Relais zur Überbrückung des Ladewiderstands geschaltet. Ab 375V wird der Bremswiderstand gepulst. 375V entspricht 0% PWM, 400V entspricht 100% PWM. Die PWM Frequenz ist 150Hz. Zum Messen der Zwischenkreisspannung wurde ein Spannungsteiler mit 3 Widerständen je 270k (3 Stk. zur Erhöhung der Spannungsfestigkeit) und einem Poti zum justieren gearbeitet. Das Poti hat 10K, dadurch kann die Spannung am Analogeingang nicht so hoch werden.

[[Bild:Bremschopper_3.png|400px]]

Die Schaltung ist für eine 2 phasige Einspeisung mit 230V gedacht. Bei anderen Eingangsspannungen muss die Erzeugung der Steuerspannung von der Gleichrichtung getrennt werden. Die 15V und 5V können dann über ein Steckernetzteil oder DC/DC Wandler gewonnen werden.

=== Leistungsteil ===
Der Leistungsteil besteht im Wesentlichen aus drei Halbbrücken. Jeweils zwei FET´s in einer Halbbrücke werden von einem IR2109 getrieben, welcher wieder direkt durch den Atmel Mega 88 auf der Steuerungsplatine angesteuert wird. Der IR 2109 steuert immer in Abhängigkeit vom Eingang “IN” entweder den High side- oder den Low side FET durch. Zwischen dem Wechsel liegt immer eine Totzeit von 540ns. Dadurch ist der Programmierer von der Kurzschlussproblematik befreit.

In den Halbbrücken sind auch auf der High-Side N-Kanal Fet´s eingesetzt. Diese haben den Vorteil, dass sie günstiger und leistungsfähiger gegenüber P-Kanal Fet´s sind. „Problematisch“ ist an ihnen jedoch, dass ihre Gatespannung oberhalb der Zwischenkreisspannung liegen muss. Zur Erzeugung dieser Spannung wird bei jedem Schalten des Low side FET über eine Diode ein Kondensator geladen, aus welchem die Spannungsversorgung zur Ansteuerung des High side FET gewonnen wird. Low und Highside werden über eine Periode der Ausgangsspannung gleich oft geschaltet, so kann der sogenannte Bootstrap Kondensator immer nachgeladen werden. ('' Bootstrap ist lt. Wikipedia: englisch für Stiefelschlaufe, sinngemäß: sich an den eigenen Stiefeln [aus dem Sumpf] herausziehen '')

Der Ausgangsstrom ist natürlich von den eingesetzten Leistungsschaltern abhängig. Die Schaltung ist mit IRPF 460 (500V Rds< 0.27 Ohm 18.4A) bestückt. Da jeder Transistor durch die Ansteuerung mit Raumzeigermodulation über eine Sinusschwingung zu 50% eingeschaltet ist, kommt man an einen theoretischen Ausgangsstrom von 36,8A. Mit einigen Sicherheitsfaktoren sollten 5-10A Dauerphasenstrom möglich sein, getestet habe ich aber nur mit einem 500W Drehstromgebläse.
Die Platine ist zusätzlich mit Lack isoliert, in sauberer Umgebung reicht der Leiterbahnabstand auch so, aber bei etwas Luftfeuchte ist Lack besser als ein Loch in der Platine.

'''Leistungshalbleiter:'''
In der Schaltung sind zwei Satz FET´s parallel geschaltet. Der zweite Satz braucht nur bei größerem Strombedarf bestückt werden. Die FET´s werden nach der Zwischenkreisspannung und dem Ausgangestrom ausgewählt. Bei 325V sind IRFP460 eine gute Wahl.
Im Schaltplan sind unterschiedliche Mos-Fet´s angegeben, es sollten aber alle gleich sein.
Die Leiterbahnen müssen evtl. durch Auflöten von Kupferdraht verstärkt werden. Reines Verzinnen bringt durch den relativ hohen spez. Widerstand von Zinn nicht so viel.

[[Bild:FU_Wechselrichter.PNG|800px]]

=== Steuerung ===
Die Ansteuerung des Leistungskreis wird mittels Software-PWM realisiert. Zu einer präzisen Bildung der notwendigen Steuersignale ist eine kurze Programmlaufzeit notwendig. Eine LCD Ausgabe oder das Einlesen von Analogwerten sprengt den möglichen Rahmen. Daher ist die Steuerung auf zwei Prozessoren aufgeteilt.

Ein Mega 88 @20Mhz steuert die Halbbrücken. Er erhält den Frequenz- und Motorspannungssollwert über parallele Eingänge von einem Mega32. Dadurch konnte das Programm und damit auch die Zykluszeit kurz gehalten werden (12,15µs im Hauptprogramm).

Der Mega 32 ist der gemütliche Verwalter. Er liest den analogen Sollwert, Ist-Zwischenkreisspannung, Ist-Zwischenkreisstrom , Ist-Drehzahl ein und stellt die Werte auf dem LCD dar.

Der analoge Sollwert ändert sich durch die Rampe des Hoch- und Rücklaufgebers entsprechend langsam, sodass Sollwertsprünge und damit Stromspitzen z. B. beim Motoranlauf vermieden werden. Zur Zeit ist eine Rampe von 2 Sekunden für eine Änderung von 0 auf 50 Hz eingestellt. Der Wert kann im Programm angepasst werden.

Die Ist-Drehzahlerfassung soll mit einem Hallgeber und einem Magneten an der Motorachse realisiert werden. Dieser Programmteil ist aber noch nicht getestet. Ein Drehzahl von 3000U/min ergibt 50U/sec, dies sollte sich über einen normalen Portpin erfassen lassen.

Der Ist-Strom wird nur im Zwischenkreis gemessen. Ein OP verstärkt den Spannungsabfall über einen Shunt. Durch die Zwischenkreiskondensatoren ist der Strom hier einigermaßen glatt und lässt sich mit dem Analogeingang messen. Eine Messung der Phasenstromes hab ich nicht mehr auf der Platine unterbekommen und müsste extern erfolgen.

=== Verbindung Steuerung Leistungsteil ===
Auf der Steuerungsplatinne liegen auf dem Wannenstecker PL2, der auch für die Programmierung genutzt werden kann die folgenden Portpins:

Pin 1 am Stecker --> PB3 --> in1 auf dem Leistungsteil

Pin 9 am Stecker --> PB4 --> in3 auf dem Leistungsteil

Pin 7 am Stecker --> PB5 --> in2 auf dem Leistungsteil

Pin 3 am Stecker --> PD7 --> SD 1 bis 3 auf dem Leistungsteil (mit Brücken weiter verbinden)

In dem Wannenstecker ist eine Buchse mit einem Flachbandkabel. Das Kabel ist aufgetrennt und die notwendigen vier Leitungen sind mit den Anschlüssen auf dem Leistungsteil verlötet. Die anderen Adern sind isoliert.

[[Bild:FU_Steuerung_Anschluss.PNG|800px]]

Achtung: mittels Flachbandkabel keine weiteren Masserverbindungen zwischen Steuerung und Leistungsteil herstellen, da sonst eine Masseschleife entsteht und größere Ströme über die dünne Leitung fließen könnten.

=== Verbindung Steuerung LCD ===
In dem Wannenstecker LCD Port ist eine Buchse mit einem Flachbandkabel. Das Flachbandkabel ist wie folgt mit dem LCD verbunden:

PORT B 0 => LCD PORT 1 => Pin am Display 11 => DB4

PORT B 1 => LCD PORT 2 => Pin am Display 12 => DB5

PORT B 2 => LCD PORT 3 => Pin am Display 13 => DB6

PORT B 3 => LCD PORT 4 => Pin am Display 14 => DB7

PORT B 4 => LCD PORT 5 => Pin am Display 4 => RS

PORT B 5 => LCD PORT 6 => Pin am Display 6 => E

Siehe auch : [[Uc-wiki:AVR-Tutorial: LCD|AVR-Tutorial: LCD]]

== Steuerprogramm ==

Da der IR 2109 immer den High '''oder''' Low Side FET ansteuert, sind '''immer drei''' der sechs FET´s des Leistungsteils leitend. Es ergeben sich die folgenden Ausgangsmuster, wobei z. B. 001 bedeutet, dass den Halbbrücken 1 und 2 der Low Side FET und in der Halbbrücke 3 der High Side FET leitet. Je nach Motorschaltung (Stern oder Dreieck) ergeben sich unterschiedliche Spannungen an den Motorwicklungen '''u''' , '''v''' und '''w'''.

{| border="1"
|-
|
|
|
| Stern
|
|
|
|Dreieck
|
|
|-
|
|
|
| u
| v
| w
|
| u
| v
| w
|-
| Muster 1
|'''001'''
|
| -1/3 Udc
| -1/3 Udc
| +2/3 Udc
|
| 0 V
| - Udc
| + Udc
|-
|Muster 2
|'''011'''
|
| -2/3 Udc
| +1/3 Udc
| +1/3 Udc
|
| - Udc
| 0 V
| + Udc
|-
|Muster 3
|'''010'''
|
| -1/3 Udc
| +2/3 Udc
| -1/3 Udc
|
| - Udc
| + Udc
| 0 V
|-
|Muster 4
|'''110'''
|
| +1/3 Udc
| +1/3 Udc
| -2/3 Udc
|
| 0 V
| + Udc
| - Udc
|-
|Muster 5
|'''100'''
|
| +2/3 Udc
| -1/3 Udc
| -1/3 Udc
|
| + Udc
| 0 V
| - Udc
|-
|Muster 6
|'''101'''
|
| +1/3 Udc
| -2/3 Udc
| +1/3 Udc
|
| + Udc
| -Udc
| 0 V
|}

[[Bild:FU_Motorspannungen.PNG|600px]]

Im obigen Bild sind die geschalteten Ventile zur Vereinfachung weggelassen. Durch die Parallelschaltung von jeweils zwei Motorwicklungen in der Sternschaltung teilt sich die Zwischenkreisspannung im Verhältnis 1/3 zu 2/3 auf. Bei der Dreiecksschaltung wird jeweils eine Wicklung kurzgeschlossen, die Spannung ist hier 0 Volt.

Werden die Ausgangsmuster der Reihe nach ausgegeben, so wird der Rotor des angeschlossenen Motors seine Lage um jeweils 60 Grad verändern. Man spricht von den sechs Spannungsvektoren oder Raumzeigern. Hinzu kommen noch die Muster 000 und 111 bei welchen die Motorspannung 0V ist, da alle Wicklungen an + Udc oder - Udc hängen (Nullspannungsvektor).
Gibt man nun die Ausgangsmuster 1 bis 6 mit der entsprechenden Frequenz heraus, bekommt man eine Drehbewegung des Motors hin. Der Lauf des Motors ist aber ruckelig und der Motor erwärmt sich, da durch das Schalten der Rechtecke eine Menge Blindstrom im Motor unterwegs ist.

== Raumzeigermodulation ==
Für einen runden Lauf des Motors und natürlich zur Minimierung der Verluste, muss der Motorstrom möglichst sinusförmig sein. Eine Ansteuerung durch eine analoge Verstärkerschaltung würde immense Verlustleistung hervorrufen. Daher kommt nur eine Realisierung mittels PWM in Frage.

=== Pulsfrequenz ===
Die Höhe der PWM Frequenz ist immer ein Spagat zwischen Schaltverlusten und einer sauberen Nachbildung des Sinus. Je höher die Pulsfrequenz umso besser wird der Sinus getroffen, aber die Schaltverluste in den Leistungshalbleitern steigen ebenfalls. Bei Profigeräten sind Pulsfrequenzen zwischen 5KHz und 16 KHz üblich.

Realisiert ist in meinem Projekt eine '''Software PWM'''. In der Interrupt-Routine von Timer1 werden die Ausgänge entsprechend gesetzt. Durch die Normierung der nachfolgend erläuterten Tabelle mit den Sinuswerten, der Normierung der Spannungssollwerte und dem Prescaler (TCCR1B=2; // use CLK/8 prescale value, entspricht 0,4 µsec bei 20 MHz) kann die Pulsfrequenz verändert bzw erhöht werden. Dies habe ich aber noch nicht getestet. Für Ausgangsfrequenzen bis 50 Hz sind die 2,5Khz ganz OK. (Siehe Stromverlauf weiter unten)

Die Ausgabe wird in meinem Programm in 400µs lange Stücke geteilt. => Pulsfrequenz = 2,5KHz. Die Auflösung durch den Timer 1 ist 1000 Schritte (1000*0,4µs = 400µs).

=== Modulation ===

Die Raumzeigermodulation beruht auf folgenden Vorraussetzungen:

''' 1) ''' Durch den Halbbrückentreiber ist '''immer einer der beiden''' FET´s einer Halbbrücke leitend. (Totzeit vernachlässigt)

''' 2) ''' Gemäß der obigen Tabelle ergibt sich zum Beispiel bei einem im Stern geschaltetem Motor und einem Ausgangsmuster von 001 eine ''' statische ''' Spannung von -1/3 Udc in der Wicklung '''u''' des Motors (-1/3 Udc in '''v''' und +2/3 Udc in '''w'''). Bei dem Muster 011 eine Spannung von -2/3Udc in '''u''', +1/3 Udc in '''v''' und +1/3 Udc in '''w''' .

''' 3) '''Gibt man die beiden Muster abwechselnd aus, so ergibt sich in der Motorwicklung ein '''Mittelwert''' aus den beiden Spannungen. Vorausgesetzt man macht es schell genug, so dass die Induktivität der Motorwicklung den Strom glättet.

''' 4) ''' Je nach zeitlichem Anteil der beiden Schaltzustände kann die Spannung im '''Verhältnis zu den beiden Zeitanteilen''' variiert werden. Wird z. B. das Muster 001 zu 25% der Zeit und das Muster 011 zu 75% der Zeit ausgegeben so ist die Spannung in der Wicklung '''u''': (0,25*-1/3Udc + 0,75*-2/3Udc)/2 = -0,58Udc

''' 5) ''' Der zeitliche Verlauf der Ausgangsspannung wird in '''gleich lange''' Blöcke, entsprechend der Pulsfrequenz aufgeteilt. In hier beschriebenen Programm sind dies 400µs. (siehe Pulsfrequenz)

''' 6) ''' In jedem dieser Blöcke werden vier unterschiedliche Ausgangsmuster mit meist unterschiedlichen '''Zeitanteilen''' ausgegeben. Die Zeitanteile der Muster heißen: To, Ta, Te und To. Die Berechnung der Zeitanteile wird nachfolgend beschrieben.

Für einen sinusförmigen Verlauf der Ausgangsspannung werden die Zeitanteile der beiden jeweiligen Ausgangsmuster in Verhältnis zu Sinus des Umlaufwinkels bewertet.

Durch die 6 Raumzeiger ist die Periode einer kompletten Sinusschwingung (und damit auch eine gesamte Motorumdrehung) in 6 Sektoren von jeweils 60 Grad Länge geteilt. Jeder Sektor hat eine Anfangsvektor und einen Endvektor mit dem entsprechenden Ausgangsmuster. Je nach dem Wert des Umlaufwinkels Omega wird der Anfangsvektor oder der Endvektor länger, bzw. kürzer eingeschaltet. Durch die Induktivität des Motors bildet sich ein Mittelwert der Spannung in der jeweiligen Motorwicklung proportional zu den Einschaltzeiten.
Im Programm läuft ein Zähler für Omega von 0 bis 59, dann wird der Sektorzähler erhöht und der Omega Zähler auf 0 gesetzt.

Ta = Zeit Anfangsvektor = proportional zu: sin (60-omega)

Te = Zeit Endvektor = proportional zu: sin (omega)

Da jedes Ausgangsmuster alle drei Wicklungen beeinflusst, braucht zur Erzeugung der benötigten Spannungen nur eine Berechnung der Schaltzeiten für alle drei Wicklungen stattfinden. Die Spannung in den anderen beiden Wicklungen ändern sich genauso.

Da der induktive Widerstand der Motorwicklungen frequenzabhängig ist, muss die Motorspannung umgekehrt proportional zur Frequenz verändert werden. Dies wird durch Verkleinerung der Einschaltdauer der spannungsführenden Vektoren und Ausgabe eines Nullspannungsvektors (Muster 000 oder 111) erreicht.

Ta = Zeit Anfangsvektor = proportional zu: sin (60-omega)* Motorspannung in %

Te = Zeit Endvektor = proportional zu: sin (omega)* Motorspannung in %

To = Zeit Nullspannungsvektor = Pulsperiode-(Zeit Anfangsvektor + Zeit Endvektor)

Für eine bessere Symmetrie wird To halbiert und jeweils vor und nach den Spannungsvektoren ausgegeben.
Die Nullspannung kann mit dem Muster 000 oder 111 erreicht werden. Zur Minimierung der Schaltverluste in den FET´s wird das Nullspannungsmuster gewählt, bei welchem nur eine Halbbrücke umgeschaltet werden muss. Die Schaltvorgänge werden ebenfalls minimiert, wenn in zwei aufeinander folgenden Pulsperioden die Muster in umgekehrter Reihenfolge ausgegeben werden. Der Mittelwert der erzeugten Spannung wird hierdurch nicht verändert.

{| border="1"
|Nullspannungsvektor
|Anfangsvektor
|Endvektor
|Nullspannungsvektor
|Nullspannungsvektor
|Endvektor
|Anfangsvektor
|Nullspannungsvektor
|-
|000
|010
|110
|111
|111
|110
|010
|000
|}

Werden anstelle eines Motors drei im Dreieck geschaltete Widerstände angeschlossen erhält man folgenden Spannungsverlauf:

[[Bild:FU_Spannung_an_ohmschen_Widerstand.jpg|400px]]

Es ist zu erkennen, wie der Anteil der positiven Spannungsanteile mit jeder Pulsperiode (0,4ms oder 2 Einheiten lang) zunimmt.

=== Programm für Atmel Mega 32 ===
Der Prozessor bekommt über 8 Eingänge (analog oder digital) die Steuerbefehle und gibt über parallele Ausgänge die Steuerbefehle an den Mega88 für die Raumzeigermodulation. Angesteuert wird auch ein LCD zur Anzeige vom Ist-Spannung, Ist-Strom, Ist-Drehzahl und Sollwerten.

Da sich die Ausgangssignale nur relativ langsam ändern, wird der Prozessor mit 1Mhz internem Oszillator betrieben

'''Timerinterrupts'''
Timer 0 = Hoch- und Rücklaufgeber. Sollwertintegraton, damit bei Sollwertsprüngen die Motordrehzahl langsam geändert wird. Der Eingangssollwert sollvh wird intergriert zum vorzeichenbehafteten Sollwert sollnh

'''Hauptprogrammablauf: '''
Einlesen des Sollwerts sollvh, Bildung des absoluten Sollwerts sollabs, Bildung des Richtungssignals und Bildung des Freigabesignals.

Einlesen von Ist-Spannung, Ist-Strom, und analogen Sollwerten.

Ausgaben an des LCD

Messung der Ist-Drehzahl

Und wieder nach oben in der Endlosschleife

=== Programm für Atmel Mega 88 ===
Der Prozessor bekommt den Frequenzsollwert, den Spannungssollwert, die Drehrichtung und das Freigabesignal über parallele Eingänge übermittelt. Angesteuert werden die drei Halbbrücken (IN), die Freigabeeingänge der Brückentreiber (SD) über einen gemeinsamen Ausgang und zwei LED`s.
Hochgezählt wird im Programm der Zeiger für den aktuellen Stand Sinusschwingung am Ausgang (Omega), aufgeteilt in 6 Sektoren. Daraus berechnet werden die Einschaltzeiten der Halbbrücken für jeweils zwei PWM-Perioden (Pulsperioden, zur Unterscheidung von der Periode der Ausgangsspannung).

'''Timerinterrupts'''

'''Timer 1''' = Ausgabe der Ausgangsmuster.

Die Timerwerte werden im Hauptprogramm berechnet und in drei Arrays abgelegt (pzh[8]; pzl[8]; pm[8]).

Es wird der „pulszykluszaehler“ für die Ausgabe des gewünschten Ausgangsmusters über die dazugehörige Zeit von 0 bis 7 hochgezählt. 7 entspricht dem Ende der zweiten Pulsperiode.

Pulszykluszaehler 0 ==> Nullspannungsvektor

Pulszykluszaehler 1 ==> Anfangsvektorvektor

Pulszykluszaehler 2 ==> Endvektor

Pulszykluszaehler 3 ==> Nullspannungsvektor

Pulszykluszaehler 4 ==> Nullspannungsvektor

Pulszykluszaehler 5 ==> Endvektor

Pulszykluszaehler 6 ==> Anfangsvektorvektor

Pulszykluszaehler 7 ==> Nullspannungsvektor

'''Timer 0''' = Zähler für dem Umlaufwinkel und für den aktuellen Sektor. Die Timerwerte sind in einer Tabelle gespeichert und werden im Abhängigkeit vom Sollwert sollabs an den Timer gegeben Es wird omega bis 59 und sektor bis 6 hochgezählt.

'''Hauptprogrammablauf:'''
Einlesen des Sollwerts sollabs, der Ausgangsspannung spg, des Richtungssignals richtung und des Freigabesignals enable
Laden der Timerwerte aus der Tabelle fbwfl[sollabs] für den Timer 0 zum Zählen von Omega und den Sektoren
Zwischenspeicherung von Omega und Sektor, damit während der Berechnungen mit den gleichen Werten gerechnet wird. Berechnung der Timerwerte für Timer 1: Ta, Te, To gemäss Raumzeigermodulation mit den dazugehörigen Ausgangsmustern. Die Werte für Sinus Omega 0 bis 59 sind in der Tabelle sin[omega] gespeichert, die Werte für Sinus (60-omega) in der Tabelle sinkomp[omega].

Ta= (sinkomp[omega]*spannung[sollabs]);

Te= (sin[omega]*spannung[sollabs]);

To= ((1000-(Ta+Te))/2);

Speicherung der Ausgangsmuster und Timerwerte für zwei Pulsperioden

Und wieder nach oben in der Endlosschleife

== Funktionstest ==
=== Spannung an ohmschen Widerstand ===
Es wurde eine Zwischenkreisspannung von ca. 24V angelegt.
Am Ausgang des FU werden drei Widerstände 470 Ohm im Stern geschaltet. Die Spannung wird über einen Widerstand gegen den Sternpunkt der Widerstände gemessen.

Je nach dem aktuellen Sektor sehen die Spanungsverläufe so oder invers aus.

[[Bild:FU_Spannug_an_ohmschen_Widerstand_P1020274a_.jpg|300px]]

[[Bild:FU_Spannug_an_ohmschen_Widerstand_P1020265a_.jpg|300px]]

=== Motorstrom ===

Hier das Ergebnis aller Bemühungen:

[[Bild:FU_Motorstrom_30Hz.jpg|400px]]

Motorstrom in einem angeschossenen Drehstrommotor über einen Shunt gemessen bei 30Hz Ausgangsfrequenz.

[[Bild:FU_Testkandidaten.jpg|400px]]

Hier die Testkandidaten, die alle thermischen Misshandlungen ausgehalten haben.

== Downloads ==

* Einspeisung [[Media:FU_Einspeisung.zip‎|download zip-File]]

* Leistungsteil [[Media:FU_Wechselrichter.zip‎|download zip-File]]
* Leistungsteil Schaltplan [[Media:FU_Wechselr_Schaltplan.zip‎|download zip-File]]

* Steuerung [[Media:FU_Steuerung.zip|download zip-File]]
‎

== Verluste ==

3 Stück IR2109 , 1 Stück Mega 8 , 1 Stück Mega 88 , 4 Stück IRFP150 verstarben in treuer Pflichterfüllung durch Unachtsamkeiten des Benutzers

= Umrichter von Uwe Scholz =
Steuerung und Bremsschopper sind weitgehend gleich geblieben, nur im Dickstromteil gab es größere Änderungen. Der mußte auch zweiseitig werden, da Drahtbrücken unter dem Kühlkörper nicht gegangen wären.

Der Trafo ist auch eine Numer größer, 0,5W war mir gefühlsmäßig etwas zu wenig. Falls ich noch einen bauen sollte, dann würde ich aber schon wieder ein paar Sachen anders machen;-)

[[Bild:FU_Uwe_Scholz_1.jpg‎|400px]]

[[Bild:FU_Uwe_Scholz_2.jpg‎|400px]]

[[Bild:FU_Uwe_Scholz_3.jpg‎|400px]]

[[Bild:FU_Uwe_Scholz_4.jpg‎|400px]]

= Umrichter von Patrick Leube =
Die Steuerung wurde über zwei Atmega 88 realisiert.
Die sechspuls Brückenschaltung ist etwas Abgespeckt worden.
Da dieser Umrichter für Akkupacks von 36V-60V ausgelegt wurde muste noch eine "Netzteil" gebastelt werden das 15V und 5V generiert.
Die Bedinung erfolgt über Taster für Sollwertvorgabe +/- RUN / STOP.
Als LCD kam ein 4*20 zum Einsatz.

Verluste: 1* LT1074HV = 12€

Da dieses Projekt mein erstes wirkliches Projekt mit µC und Elektronik im tieferen Sinne war möchte mich an dieser stelle auch nochmal bei Axel für seine Unterstützung bedanken.

[[Bild:FU_Patrick_1.jpg|300px]]

[[Bild:FU_Patrick_2.jpg|300px]]

[[Kategorie:AVR-Projekte]]
[[Kategorie:Leistungselektronik]]
[[Category:1. Wettbewerb]]
[[Kategorie:Spannungsversorgung und Energiequellen]]

AVR-GCC-Tutorial/Der UART

2011-05-09T05:26:59Z

Jackfritt: /* Software-UART */ Link aktualisiert

Über den [[UART]] kann ein [[AVR]] leicht mit einer [[RS-232]]-Schnittstelle eines PC oder sonstiger Geräte mit "[[seriell]]er Schnittstelle" verbunden werden.

== Allgemeines zum UART ==

Mögliche Anwendungen des UART:

;Debug-Schnittstelle: z. B. zur Anzeige von Zwischenergebnissen ("printf-debugging" - hier besser "Logging" oder "UART-debugging") über [[RS-232]] auf einem PC. Auf dem Rechner reicht dazu ein [[RS-232#Terminalprogramme|Terminalprogramm]] (MS-Windows: Hyperterm oder besser [https://sites.google.com/site/terminalbpp/], [http://www.der-hammer.info/terminal/ HTerm]; Unix/Linux z. B. minicom). Ein direkter Anschluss ist aufgrund unterschiedlicher Pegel nicht möglich, jedoch sind entsprechende Schnittstellen-ICs wie z. B. ein MAX232 günstig und leicht zu integrieren. Rechner ohne serielle Schnittstelle können über fertige USB-seriell-Adapter angeschlossen werden.
;Mensch-Maschine Schnittstelle: z. B. Konfiguration und Statusabfrage über eine "Kommandozeile" oder Menüs (siehe z. B. Forumsbeitrag [http://www.mikrocontroller.net/topic/52985 Auswertung RS232-Befehle] und Artikel [[Tinykon]])
;Übertragen von gespeicherten Werten: z. B. bei einem Datenlogger
;Anschluss von Geräten: mit serieller Schnittstelle (z. B. (Funk-)Modems, Mobiltelefone, Drucker, Sensoren, "intelligente" LC-Displays, GPS-Empfänger).
;"Feldbusse": auf RS485/RS422-Basis mittels entsprechenden Bustreiberbausteinen (z. B. MAX485)
;DMX, Midi: etc.
;LIN-Bus: '''L'''ocal '''I'''nterconnect '''N'''etwork: Preiswerte Sensoren/Aktoren in der Automobiltechnik und darüber hinaus

Einige AVR-Controller haben ein bis zwei vollduplexfähige UART ('''U'''niversal '''A'''synchronous '''R'''eceiver and '''T'''ransmitter) schon eingebaut ("Hardware-UART").
Übrigens: Vollduplex heißt nichts anderes, als dass der Baustein gleichzeitig senden und empfangen kann.

Neuere AVRs (ATmega, ATtiny) verfügen über einen bis vier U'''S'''ART(s), dieser unterscheidet sich vom UART hauptsächlich durch interne FIFO-Puffer für Ein- und Ausgabe und erweiterte Konfigurationsmöglichkeiten. Die Puffergröße ist allerdings nur 1 Byte.

== Die Hardware ==

Der UART basiert auf normalem TTL-Pegel mit 0V (logisch 0) und 5V (logisch 1). Die Schnittstellenspezifikation für RS-232 definiert jedoch -3V ... -12V (logisch 1) und
+3 ... +12V (logisch 0). Daher muss der Signalaustausch zwischen AVR und Partnergerät invertiert werden. Für die Anpassung der Pegel und das Invertieren der Signale gibt es fertige Schnittstellenbausteine. Der bekannteste davon ist wohl der MAX232.


Streikt die Kommunikation per UART, so ist oft eine fehlerhafte Einstellung der Baudrate die Ursache. Die Konfiguration auf eine bestimmte Baudrate ist abhängig von der Taktfrequenz des Controllers. Gerade bei neu aufgebauten Schaltungen (bzw. neu gekauften Controllern) sollte man sich daher noch einmal vergewissern, dass der Controller auch tatsächlich mit der vermuteten Taktrate arbeitet und nicht z. B. den bei einigen Modellen werksseitig eingestellten internen [[Oszillator]] statt eines externen Quarzes nutzt. Die Werte der verschiedenen fuse-bits im Fehlerfall also beispielsweise mit ''[[AVRDUDE]]'' kontrollieren und falls nötig anpassen. Grundsätzlich empfiehlt sich auch immer ein Blick in die [[AVR_Checkliste]].

== Die UART-Register ==

Der UART wird über vier separate Register angesprochen. Die USARTs der ATMEGAs verfügen über mehrere zusätzliche Konfigurationsregister. Das Datenblatt gibt darüber Auskunft. Die folgende Tabelle gibt nur die Register für die UARTs der ATmega8/16/32 u.ä. wieder.

{| class="wikitable"
|-
| '''UCSRA   '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''A'''. 
Hier teilt uns der UART mit, was er gerade so macht.

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''RXC'''|| '''TXC'''|| '''UDRE'''|| '''FE'''|| '''DOR'''|| '''PE'''|| '''U2X'''|| '''MPCM'''
|-
! R/W
| R|| R/W|| R|| R|| R|| R|| R/W|| R/W
|-
! Initialwert
| 0|| 0|| 1|| 0|| 0|| 0|| 0|| 0
|}

'''RXC''' (UART Receive Complete)
:Dieses Bit wird vom AVR gesetzt, wenn ein empfangenes Zeichen vom Empfangs-Schieberegister in das Empfangs-Datenregister transferiert wurde.
:Das Zeichen muss nun schnellstmöglich aus dem Datenregister ausgelesen werden. Falls dies nicht erfolgt, bevor ein weiteres Zeichen komplett empfangen wurde, wird eine Überlauf-Fehlersituation eintreten. Mit dem Auslesen des Datenregisters wird das Bit automatisch gelöscht.

'''TXC''' (UART Transmit Complete)
:Dieses Bit wird vom AVR gesetzt, wenn das im Sende-Schieberegister befindliche Zeichen vollständig ausgegeben wurde und kein weiteres Zeichen im Sendedatenregister ansteht. Dies bedeutet also, dass die Kommunikation vollumfänglich abgeschlossen ist.
:Dieses Bit ist wichtig bei Halbduplex-Verbindungen, wenn das Programm nach dem Senden von Daten auf Empfang schalten muss. Im Vollduplexbetrieb brauchen wir dieses Bit nicht zu beachten.
:Das Bit wird nur dann automatisch gelöscht, wenn der entsprechende Interrupthandler aufgerufen wird, ansonsten müssen wir das Bit selber löschen.

'''UDRE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty)
:Dieses Bit zeigt an, ob der Sendepuffer bereit ist, um ein zu sendendes Zeichen aufzunehmen. Das Bit wird vom AVR gesetzt (1), wenn der Sendepuffer leer ist. Es wird gelöscht (0), wenn ein Zeichen im Sendedatenregister vorhanden ist und noch nicht in das Sende-Schieberegister übernommen wurde. Atmel empfiehlt aus Kompatibilitätsgründen mit kommenden µC, UDRE auf 0 zu setzen, wenn das UCSRA Register beschrieben wird.
:Das Bit wird automatisch gelöscht, wenn ein Zeichen in das Sendedatenregister geschrieben wird.

'''FE''' ('''F'''raming '''E'''rror)
:Dieses Bit wird vom AVR gesetzt, wenn der UART einen Zeichenrahmenfehler detektiert, d.h. wenn das Stopbit eines empfangenen Zeichens 0 ist.
:Das Bit wird automatisch gelöscht, wenn das Stopbit des empfangenen Zeichens 1 ist.

'''DOR''' ('''D'''ata '''O'''ver '''R'''un)
:Dieses Bit wird vom AVR gesetzt, wenn unser Programm das im Empfangsdatenregister bereit liegende Zeichen nicht abholt bevor das nachfolgende Zeichen komplett empfangen wurde.
:Das nachfolgende Zeichen wird verworfen.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

'''PE''' ('''P'''arity '''E'''rror''')
:Dieses Bit wird vom AVR gesetzt, wenn das im Empfangsdatenregister bereit liegende Zeichen eine Paritätsfehler aufweist.
:Das Bit wird automatisch gelöscht, wenn das empfangene Zeichen in das Empfangsdatenregister transferiert werden konnte.

'''U2X''' (Double the transmission speed)
:Dieses Bit wird lediglich im asynchronen Modus genutzt. Im synchronen Modus ist es 0 zu setzen. Wird das Bit gesetzt, so wird der Baudraten Divisor von 16 auf 8 reduziert, was einer Verdopplung der Transferrate gleich kommt.

'''MPCM''' ('''M'''ulti '''P'''rozessor '''C'''ommunication '''M'''ode)
:Dieses Bit aktiviert die Multi-Prozessor-Kommunikation. Jeder eintreffende Frame der keine Adressinformation enthält wird dadurch ignoriert.

|-
| '''UCSRB    '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''B'''. 
In diesem Register stellen wir ein, wie wir den UART verwenden möchten. 
Das Register ist wie folgt aufgebaut:

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''RXCIE'''|| '''TXCIE'''|| '''UDRIE'''|| '''RXEN'''|| '''TXEN'''|| '''UCSZ2'''|| '''RXB8'''|| '''TXB8'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R|| R/W
|-
! Initialwert
| 0|| 0|| 0|| 0|| 0|| 0|| 0|| 0
|}

'''RXCIE''' ('''RX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART RX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART empfangen wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''TXCIE''' ('''TX''' '''C'''omplete '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART TX Complete Interrupt ausgelöst, wenn ein Zeichen vom UART gesendet wurde. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''UDRIE''' ('''U'''ART '''D'''ata '''R'''egister '''E'''mpty '''I'''nterrupt '''E'''nable)
:Wenn dieses Bit gesetzt ist, wird ein UART Datenregister Leer Interrupt ausgelöst, wenn der UART wieder bereit ist um ein neues zu sendendes Zeichen zu übernehmen. Das Global Enable Interrupt Flag muss selbstverständlich auch gesetzt sein.

'''RXEN''' ('''R'''eceiver '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Empfänger des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''TXEN''' ('''T'''ransmitter '''E'''nable)
:Nur wenn dieses Bit gesetzt ist, arbeitet der Sender des UART überhaupt. Wenn das Bit nicht gesetzt ist, kann der entsprechende Pin des AVR als normaler I/O-Pin verwendet werden.

'''UCSZ2''' (Characters Size)
:Dieses Bit setzt in Verbindung mit dem UCSZ1:0 Bits im UCSRC Register die Anzahl von Datenbits eines Frames beim Empfang oder Senden.

'''RXB8''' (Receive Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann enthält dieses Bit das 9. Datenbit eines empfangenen Zeichens.

'''TXB8''' (Transmit Data Bit 8)
:Wenn das vorher erwähnte CHR9-Bit gesetzt ist, dann muss in dieses Bit das 9. Bit des zu sendenden Zeichens eingeschrieben werden bevor das eigentliche Datenbyte in das Datenregister geschrieben wird.
|-
| '''UCSRC    '''
| '''U'''ART '''C'''ontrol and '''S'''tatus '''R'''egister '''C'''. 

{| class="wikitable" style="text-align:center"
|-
! Bit
| 7 || 6 || 5 || 4 || 3 || 2 || 1 || 0
|-
! Name
| '''URSEL'''|| '''UMSEL'''|| '''UPM1'''|| '''UPM0'''|| '''USBS'''|| '''UCSZ1'''|| '''UCSZ0'''|| '''UCPOL'''
|-
! R/W
| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W|| R/W
|-
! Initialwert
| 1|| 0|| 0|| 0|| 0|| 1|| 1|| 0
|}

'''URSEL''' (Register Select)
:Dieses Bit selektiert die Auswahl des UCSRC- bzw. des UBRRH Registers. Beim Lesen von UCSRC wird es als 1 gelesen. Beim Schreiben auf UCSRC muss es auf 1 gesetzt werden.

:Achtung: Manche Prozessoren verfügen über dieses Bit, andere wiederrum nicht. Was hat es damit auf sich? Um Zugriffsadressen einzusparen, wurde von Atmel ein etwas seltsamer Weg gewählt. Das UCSRC Register und das High-Byte des Baudratenregisters teilen sich dieselbe Registeradresse! Um der Hardware mitzuteilen, welche Bedeutung ein zugewiesener Wert haben soll, entweder neue Belegung des Baudratenregisters oder eben Konfiguration des UCSRC Registers, dient dieses Bit. Ist es nicht gesetzt, dann wird eine Zuweisung immer als Zuweisung an das High-Byte des Baudratenregisters angesehen, selbst wenn das so nicht beabsichtigt war. Nur dann wenn dieses Bit gesetzt ist, dann wird eine Zuweisung auch tatsächlich als eine Zuweisung an das UCSRC Register gewertet und die Konfiguration verändert. Lässt man das Bit irrtümlich weg, dann verursacht eine Zuweisung an UCSRC eine Veränderung der Baudrateneinstellung!

'''UMSEL''' (USART Mode Select)
:Durch dieses Bit kann eine asynchrone oder synchrone Übertragung eingestellt werden. Durch Setzen des Bits wird eine synchrone Übertragung eingestellt.

'''UPM1:0''' (Parity Mode)
{| class="wikitable" style="text-align:center"
|-
| '''UPM1'''|| '''UPM0'''|| '''Parity Mode'''
|-
| 0|| 0|| Disabled
|-
| 0|| 1|| Reserved
|-
| 1|| 0|| Enabled, Even Priority
|-
| 1|| 1|| Enabled, OddPriority
|}

'''USBS''' ('''U'''SART '''S'''top '''B'''it '''S'''elect)
:Diese Bits setzen die Anzahl der zu sendenden Stopbits eines Frames. Beim Setzen werden 2 Stopbits übertragen, andernfalls nur 1 Stopbit.
{| class="wikitable" style="text-align:center"
|-
| '''USBS'''|| '''Anzahl der Stop Bits'''
|-
| 0|| 1
|-
| 1|| 2

|}

'''UCSZ1:0''' (Character Size)
:Diese Bits setzen in Verbindung mit UCSZ2 aus dem UCSRB Register die Anzahl der Datenbits eines Frames.
:Diese Bits setzen den entsprechenden Paritätsmodus.
{| class="wikitable" style="text-align:center"
|-
| '''UCSZ2'''|| '''UCSZ1'''|| '''UCSZ0'''|| '''Character Size'''
|-
| 0|| 0|| 0|| 5-Bit
|-
| 0|| 0|| 1|| 6-Bit
|-
| 0|| 1|| 0|| 7-Bit
|-
| 0|| 1|| 1|| 8-Bit
|-
| 1|| 0|| 0|| Reserved
|-
| 1|| 0|| 1|| Reserved
|-
| 1|| 1|| 0|| Reserved
|-
| 1|| 1|| 1|| 9-Bit
|}

'''UCPOL''' (Clock Polarity)

|-
| '''UDR'''
| '''U'''ART '''D'''ata '''R'''egister. 
Hier werden Daten zwischen UART und CPU übertragen. Da der UART im
Vollduplexbetrieb gleichzeitig empfangen und senden kann, handelt es sich
hier physikalisch um 2 Register, die aber über die gleiche I/O-Adresse
angesprochen werden. Je nachdem, ob ein Lese- oder ein Schreibzugriff auf
den UART erfolgt wird automatisch das richtige UDR angesprochen.
|-
| '''UBRR'''
| '''U'''ART '''B'''aud '''R'''ate '''R'''egister. 
In diesem Register müssen wir dem UART mitteilen, wie schnell wir gerne kommunizieren möchten. Der Wert, der in dieses Register geschrieben werden muss, errechnet sich nach folgender Formel (wenn U2X Bit 0 gesetzt ist):

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

Es sind Baudraten bis über 115200 Baud möglich, je nach Controller und CPU-Frequenz. Siehe Datenblatt.
|}

== UART initialisieren ==

Wir wollen nun Daten mit dem UART auf die serielle Schnittstelle ausgeben. Dazu müssen wir den UART zuerst mal initialisieren. Dazu setzen wir je nach gewünschter Funktionsweise die benötigten Bits im '''U'''ART '''C'''ontrol '''R'''egister.

Da wir vorerst nur senden möchten und noch keine Interrupts auswerten wollen, gestaltet sich die Initialisierung wirklich sehr einfach, da wir lediglich das '''Transmitter Enable''' Bit setzen müssen:

<c>
UCSRB |= (1<<TXEN);
</c>

Neuere AVRs mit USART haben mehrere Konfigurationsregister und erfordern eine etwas andere Konfiguration. Für einen ATmega16 z. B.:

<c>
UCSRB |= (1<<TXEN); // UART TX einschalten
UCSRC = (1<<URSEL)|(1 << UCSZ1)|(1 << UCSZ0); // Asynchron 8N1
</c>

Nun ist noch das Baudratenregister '''UBRR''' einzustellen. Bei neueren AVRs besteht es aus zwei Registern '''UBRRL''' und '''UBRRH'''. Der Wert dafür ergibt sich aus der angegebenen Formel durch Einsetzen der Taktfrequenz und der gewünschten Übertragungsrate. Das Berechnen der Formel wird dem [[C-Präprozessor|Präprozessor]] überlassen. Dabei ist zu beachten, dass der Präprozessor keine Floating Point Ergebnisse liefert, sondern Integer Ergebnisse. Das bedeutet, dass wenn durch Division auf einen Integer Wert 1.99 zugewiesen wird, 0.99 abgeschnitten werden und das Ergebnis 1.0 ist - obwohl 2.0 viel näher wäre. Aus diesem Grund kann man sich einem kleinen Trick bedienen, indem vor der eigentlichen Division bei der Zuweisung die Hälfte des Wertes dazu addiert wird. Allgemein formuliert bedeutet das: <c>int i = ( a + b/2 ) / b;</c> Dies wird in der unten angegebenen Berechnung von UBRR_VAL ausgenutzt um den Fehler zu minimieren.

Eine ausführliche Erklärung zum ''cleveren Runden'' findet sich in der Forumsdiskussion [http://www.mikrocontroller.net/topic/170617#1631916].

<c>
/*
UART-Init:
Berechnung des Wertes für das Baudratenregister
aus Taktrate und gewünschter Baudrate
*/

#ifndef F_CPU
/* In neueren Version der WinAVR/Mfile Makefile-Vorlage kann
F_CPU im Makefile definiert werden, eine nochmalige Definition
hier wuerde zu einer Compilerwarnung fuehren. Daher "Schutz" durch
#ifndef/#endif

Dieser "Schutz" kann zu Debugsessions führen, wenn AVRStudio
verwendet wird und dort eine andere, nicht zur Hardware passende
Taktrate eingestellt ist: Dann wird die folgende Definition
nicht verwendet, sondern stattdessen der Defaultwert (8 MHz?)
von AVRStudio - daher Ausgabe einer Warnung falls F_CPU
noch nicht definiert: */
#warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 4000000"
#define F_CPU 4000000UL // Systemtakt in Hz - Definition als unsigned long beachten
// Ohne ergeben sich unten Fehler in der Berechnung
#endif

#define BAUD 9600UL // Baudrate

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

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
</c>

Die Makros sind sehr praktisch, da sie sowohl automatisch den Wert für UBRR als auch den Fehler in der generierten Baudrate berechnen und im Falle einer Überschreitung (+/-1%) einen Fehler und somit Abbruch im Compilerablauf generieren. Damit können viele Probleme mit "UART sendet komische Zeichen" vermieden werden. Ausserdem kann man mühelos die Einstellung an eine neue Taktfrequenz bzw. Baudrate anpassen, ohne selber rechnen oder in Tabellen nachschlagen zu müssen.

Inzwischen gibt es in der avr-libc Makros für obige Berechnung der UBRR Registerwerte aus Taktrate F_CPU und Baudrate BAUD in der Includedatei <util/setbaud.h> ([http://www.nongnu.org/avr-libc/user-manual/group__util__setbaud.html]). Der berechnete Wert kann dann einfach über das Makro UBRR_VALUE aufgerufen werden.

Die eigentliche Initialisierung der UART Register kann im Hauptprogramm main() vorgenommen werden. Öfters wird jedoch eine Funktion z. B. uart_init() dafür geschrieben, die in der eigenen Codesammlung in mehreren Projekten verwendet werden kann.

Für einige AVR (z. B. ATmega169, ATmega48/88/168, AT90CAN jedoch nicht für z. B. ATmega16/32, ATmega128, ATtiny2313) wird durch die Registerdefinitionen der avr-libc (io*.h) auch für Controller mit zwei UBRR-Registern (UBRRL/UBRRH) ein UBRR bzw. UBRR0 als "16-bit-Register" definiert und man kann den Wert direkt per UBRR = UBRR_VAL zuweisen. Intern werden dann zwei Zuweisungen für UBRRH und UBRRL generiert.

<c>
/* UART-Init Bsp. ATmega48 */

void uart_init(void)
{
UBRR0 = UBRR_VAL;
UCSR0B |= (1<<TXEN0);
// Frame Format: Asynchron 8N1
UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);
}
</c>

Die einzelne Anweisung ist nicht bei allen Controllern möglich, da die beiden Register nicht bei allen aufeinanderfolgende Addressen aufweisen. Die getrennte Zuweisung an UBRRH und UBRRL wie im nächsten Beispiel gezeigt, ist universeller und portabler und daher vorzuziehen. Wichtig ist, dass UBRRH '''vor''' UBRRL geschrieben wird:

<c>
/* UART-Init Bsp. ATmega16 */

void uart_init(void)
{
UCSRB |= (1<<TXEN); // UART TX einschalten
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1

UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
}
</c>

Siehe auch:
* [http://www.wormfood.net/avrbaudcalc.php WormFood's AVR Baud Rate Calculator] online.
* [http://www.gjlay.de/helferlein/avr-uart-rechner.html AVR Baudraten-Rechner] in JavaScript

== Senden mit dem UART ==

=== Senden einzelner Zeichen ===

Um nun ein Zeichen auf die Schnittstelle auszugeben, müssen wir dasselbe
lediglich in das '''U'''ART '''D'''ata '''R'''egister schreiben. Vorher ist zu prüfen, ob das UART-Modul bereit ist, das zu sendende Zeichen entgegenzunehmen. Die Bezeichnungen des/der Statusregisters mit dem Bit UDRE ist abhängig vom Controllertypen (vgl. Datenblatt).

<c>
// bei neueren AVRs steht der Status in UCSRA/UCSR0A/UCSR1A, hier z. B. fuer ATmega16:
while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */
{
}

UDR = 'x'; /* schreibt das Zeichen x auf die Schnittstelle */
</c>

=== Schreiben einer Zeichenkette (String) ===

Die Aufgabe "String senden" wird durch zwei Funktionen abgearbeitet. Die universelle/controllerunabhängige Funktion uart_puts übergibt jeweils ein Zeichen der Zeichenkette an eine Funktion uart_putc, die abhängig von der vorhandenen Hardware implementiert werden muss. In der Funktion zum Senden eines Zeichens ist darauf zu achten, dass vor dem Senden geprüft wird, ob der UART bereit ist den "Sendeauftrag" entgegenzunehmen.

<c>
/* ATmega16 */
int uart_putc(unsigned char c)
{
while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */
{
}

UDR = c; /* sende Zeichen */
return 0;
}

/* puts ist unabhaengig vom Controllertyp */
void uart_puts (char *s)
{
while (*s)
{ /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */
uart_putc(*s);
s++;
}
}
</c>

Die in uart_putc verwendeten Schleifen, in denen gewartet wird bis die UART-Hardware zum senden bereit ist, sind insofern etwas kritisch, da während des Sendens eines Strings nicht mehr auf andere Ereignisse reagiert werden kann. Universeller ist die Nutzung von FIFO(first-in first-out)-Puffern, in denen die zu sendenden bzw. empfangenen Zeichen/Bytes zwischengespeichert und in Interruptroutinen an die U(S)ART-Hardware weitergegeben bzw. von ihr ausgelesen werden. Dazu existieren fertige Komponenten (Bibliotheken, Libraries), die man recht einfach in eigene Entwicklungen integrieren kann. Es empfiehlt sich, diese Komponenten zu nutzen und das Rad nicht neu zu erfinden.

=== Schreiben von Variableninhalten ===

Sollen Inhalte von Variablen (Ganzzahlen, Gleitkomma) in "menschenlesbarer" Form gesendet werden, ist vor dem Transfer eine Umwandlung in Zeichen ("ASCII") erforderlich. Bei nur einer Ziffer ist diese Umwandlung relativ einfach: man addiert den ASCII-Wert von Null zur Ziffer und kann diesen Wert direkt senden.

<c>
#include <avr/io.h>
#include <stdlib.h>
//...

// hier uart_putc (s.o.)

int main (void)
{
// Ausgabe von 0123456789
char c;

uart_init();

for (uint8_t i=0; i<=9; ++i) {
c = i + '0';
uart_putc( c );
// verkuerzt: uart_putc( i + '0' );
}

while (1) {
;
}

return 0; // never reached

}
</c>

Soll mehr als eine Ziffer ausgegeben werden, bedient man sich zweckmäßigerweise vorhandener Funktionen zur Umwandlung von Zahlen in Zeichenketten/Strings. Die Funktion der avr-libc zur Umwandlung von vorzeichenbehafteten 16bit-Ganzzahlen (int16_t) in Zeichenketten heißt ''itoa'' (Integer to ASCII). Man muss der Funktion einen Speicherbereich zur Verarbeitung (buffer) mit Platz für alle Ziffern, das String-Endezeichen ('\0') und evtl. das Vorzeichen bereitstellen.

<c>
#include <avr/io.h>
#include <stdlib.h>

//...

// hier uart_init, uart_putc, uart_puts (s.o.)

int main(void)
{
char s[7];
int16_t i = -12345;

uart_init();

itoa( i, s, 10 ); // 10 fuer radix -> Dezimalsystem
uart_puts( s );

// da itoa einen Zeiger auf den Beginn von s zurueckgibt verkuerzt auch:
uart_puts( itoa( i, s, 10 ) );

while (1) {
;
}

return 0; // never reached
}
</c>

Für vorzeichenlose 16bit-Ganzzahlen (uint16_t) exisitert ''utoa''. Die Funktionen für 32bit-Ganzzahlen (int32_t und uint32_t) heißen ''ltoa'' bzw. ''ultoa''. Da 32bit-Ganzzahlen mehr Stellen aufweisen können, ist ein entsprechend größerer Pufferspeicher vorzusehen.

Auch Gleitkommazahlen (float/double) können mit bereits vorhandenen Funktionen in Zeichenfolgen umgewandelt werden, dazu existieren die Funktionen ''dtostre'' und ''dtostrf''. dtostre nutzt Exponentialschreibweise ("engineering"-Format). (Hinweis: z.Zt. existiert im avr-gcc kein "echtes" double, intern wird immer mit "einfacher Genauigkeit", entsprechend float, gerechnet.)

dtostrf und dtostre benötigen die libm.a der avr-libc. Bei Nutzung von Makefiles ist der Parameter -lm in in LDFLAGS anzugeben (Standard in den WinAVR/mfile-Makefilevorlagen). Nutzt man AVRStudio als IDE für den GNU-Compiler (gcc-Plugin) ist die libm.a unter Libaries auszuwählen: Project -> Configurations Options -> Libaries -> libm.a mit dem Pfeil nach rechts einbinden. Siehe auch die [[FAQ#Aktivieren_der_Floating_Point_Version_von_sprintf_beim_WinAVR_mit_AVR-Studio|FAQ]]

<c>
#include <avr/io.h>
#include <stdlib.h>

//...

// hier uart_init, uart_putc, uart_puts (s.o.)

/* lt. avr-libc Dokumentation:
char* dtostrf(
double __val,
char __width,
char __prec,
char * __s
)
*/

int main(void)
{
// Pufferspeicher ausreichend groß
// evtl. Vorzeichen + width + Endezeichen:
char s[8];
float f = -12.345;

uart_init();

dtostrf( f, 6, 3, s );
uart_puts( s );
// verkürzt: uart_puts( dtostrf( f, 7, 3, s ) );

while (1) {
;
}

return 0; // never reached
}
</c>

== Empfangen ==
=== Einzelne Zeichen empfangen ===

Zum Empfang von Zeichen muss der Empfangsteil des UART bei der Initialisierung aktiviert werden, indem das RXEN-Bit im jeweiligen Konfigurationsregister (UCSRB bzw UCSR0B/UCSR1B) gesetzt wird. Im einfachsten Fall wird solange gewartet, bis ein Zeichen empfangen wurde, dieses steht dann im UART-Datenregister (UDR bzw. UDR0 und UDR1 bei AVRs mit 2 UARTS) zur Verfügung (sogen. "Polling-Betrieb"). Ein Beispiel für den ATmega16:

<c>
#include <inttypes.h>
#include <avr/io.h>

/* Siehe auch obere Baudrateneinstellung */
/* USART-Init beim ATmega16 */

void uart_init(void)
{
UCSRB |= (1<<RXEN); // UART RX einschalten
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1

UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
}

/* Zeichen empfangen */
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar
;
return UDR; // Zeichen aus UDR an Aufrufer zurueckgeben
}
</c>

Und die Anwendung in einem Beispiel:

<c>
#include <avr/io.h>
#include <stdlib.h>

// hier Makro für die Baudratenberechnung

// hier uart_init, uart_getc (s.o.)

int main(void)
{
uart_init();
while (1)
{
uint8_t c;
c = uart_getc();

// hier etwas mit c machen z.B. auf PORT ausgeben
DDRC = 0xFF; // PORTC Ausgang
PORTC = c;
}
return 0; // never reached
}
</c>

Die Funktion uart_getc() blockiert allerdings den Programmablauf, denn es wird gewartet, bis ein Zeichen empfangen wird! Möchte man das Warten vermeiden, kann das RXC-Bit in einer Programmschleife abgefragt werden und dann nur bei gesetztem RXC-Bit UDR ausgelesen werden.

<c>
#include <avr/io.h>
#include <stdlib.h>

// hier Makro für die Baudratenberechnung

// hier uart_init, uart_getc (s.o.)

int main(void)
{
uart_init();
while (1)
{
if ( (UCSRA & (1<<RXC)) )
{
// Zeichen wurde empfangen, jetzt abholen
uint8_t c;
c = uart_getc();
// hier etwas mit c machen z.B. auf PORT ausgeben
DDRC = 0xFF; // PORTC Ausgang
PORTC = c;
}
else
{
// Kein Zeichen empfangen, Restprogramm ausführen...
}
}
return 0; // never reached
}
</c>

Eleganter und in den meisten Anwendungsfällen "stabiler" ist die Vorgehensweise, die empfangenen Zeichen in einer Interrupt-Routine einzulesen und zur späteren Verarbeitung in einem Eingangsbuffer (FIFO-Buffer) zwischenzuspeichern. Dazu existieren fertige und gut getestete [[Libraries|Bibliotheken]]  und Quellcodekomponenten (z. B. UART-Library von P. Fleury, procyon-avrlib und einige in der "Academy" von avrfreaks.net).

Siehe auch:
* [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html Dokumenation der avr-libc/stdlib.h]
* [http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Die_Nutzung_von_sprintf_und_printf Die Nutzung von sprintf und printf]
* [http://homepage.hispeed.ch/peterfleury/ Peter Fleurys] UART-Bibiliothek fuer avr-gcc/avr-libc


TODO: 9bit

=== Empfang von Zeichenketten (Strings) ===

Beim Empfang von Zeichenketten, muß man sich zunächst darüber im klaren sein, daß es ein Kriterium geben muß, an dem der µC erkennen kann, wann ein Text zu Ende ist. Sehr oft wird dazu das Zeichen 'Return' benutzt, um das Ende eines Textes zu markieren. Dies ist vom Benutzer einfach eingebbar und er ist auch daran gewöhnt, daß er eine Eingabezeile mit einem Druck auf die Return Taste abgeschlossen wird.

Prinzipiell gibt es jedoch keine Einschränkung bezüglich dieses speziellen Zeichens. Es muß nur sichergestellt werden, daß dieses spezielle 'Ende eines Strings' - Zeichen nicht mit einem im Text vorkommenden Zeichen verwechselt werden kann. Wenn also im zu übertragenden Text beispielsweise kein ';' vorkommt, dann spricht nichts dagegen, den Benutzer die Eingabe eines Textes mit einem ';' abschließen zu lassen.

Im Folgenden wird die durchaus übliche Annahme getroffen, daß eine Stringübertragung identisch ist mit der Übertragung einer Textzeile und daher mit einem Return ('\n') abgeschlossen wird.

Das Problem der Übertragung eines Strings reduziert sich damit auf die Aufgabenstellung: Empfange und sammle Zeichen in einem char Array, bis entweder das Array voll ist oder das Text Ende Zeichen' empfangen wurde. Danach wird der empfangene Text noch mit einem '\0' Zeichen abgeschlossen um einen Standard C-String daraus zu machen, mit dem dann weiter gearbeitet werden kann.

<C>
/* Zeichen empfangen */
uint8_t uart_getc(void)
{
while (!(UCSRA & (1<<RXC))) // warten bis Zeichen verfuegbar
;
return UDR; // Zeichen aus UDR an Aufrufer zurueckgeben
}

void uart_gets( char* Buffer, uint8_t MaxLen )
{
uint8_t NextChar;
uint8_t StringLen = 0;

NextChar = uart_getc(); // Warte auf und empfange das nächste Zeichen

// Sammle solange Zeichen, bis:
// * entweder das String Ende Zeichen kam
// * oder das aufnehmende Array voll ist
while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
*Buffer++ = NextChar;
StringLen++;
NextChar = uart_getc();
}

// Noch ein '\0' anhängen um einen Standard
// C-String daraus zu machen
*Buffer = '\0';
}
</C>

Beim Aufruf ist darauf zu achten, dass das empfangende Array auch mit einer
vernünftigen Größe definiert wird.

<C>

char Line[40]; // String mit maximal 39 zeichen

uart_gets( Line, sizeof( Line ) );
</C>

Bei der Benutzung von sizeof() ist allerdings zu beachten, dass sizeof() nicht die Anzahl der Elemente des Arrays liefert, sondern die Länge in Byte. Da ein char nur ein Byte lang ist, passt der Aufruf 'uart_gets(Line, sizeof( Line ) );' in diesem Fall. Falls man - aus welchen Gründen auch immer - andere Datentypen benutzen möchte, sollte man zur korrekten Angabe der Array-Länge folgende Vorgehensweise bevorzugen:

<C>
int Line[40]; // Array vom Typ int

uart_gets( Line, sizeof( Line ) / sizeof( Line[0] ) );
</C>

==Interruptbetrieb==

Hier wird das Grundwissen des Artikels [[Interrupt]] und des Abschnitts [[AVR-GCC-Tutorial#Programmieren_mit_Interrupts|AVR-GCC-Tutorial: Programmieren_mit_Interrupts]] vorausgesetzt.

=== Empfangen (RX) ===

Beim ATmega8 muss das '''RXCIE''' Bit im Register UCSRB gesetzt werden, damit ein Interrupt beim Empfang eines Zeichens ausgelöst werden kann.

<c>
/* siehe auch obere Baudrateneinstellung */
/* USART-Init beim ATmega16 */
void uart_init(void)
{
UCSRB |= (1<<RXEN)|(1<<TXEN)|(1<<RXCIE); // UART RX, TX und RX Interrupt einschalten
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1

UBRRH = UBRR_VAL >> 8;
UBRRL = UBRR_VAL & 0xFF;
}
</c>

Natürlich muss "Global Interrupt Enable" aktiviert sein (sei()). Interrupt-spezifische Definitionen werden über die Includedatei eingebunden:

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

Der Interrupt wird immer ausgelöst, wenn ein Zeichen erfolgreich empfangen wurde. Zusätzlich braucht man die Interruptserviceroutine (ISR).

In diesem Beispiel enthält die ISR einen FIFO-Puffer (First in, First out). Dafür werden ein paar globale Variablen und Makros benötigt:

<c>
#define UART_MAXSTRLEN 10

volatile uint8_t uart_str_complete = 0; // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";
</c>

<c>
ISR(USART_RXC_vect)
{
unsigned char nextChar;

// Daten aus dem Puffer lesen
nextChar = UDR;
if( uart_str_complete == 0 ) { // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen

// Daten werden erst in string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
if( nextChar != '\n' &&
nextChar != '\r' &&
uart_str_count < UART_MAXSTRLEN - 1 ) {
uart_string[uart_str_count] = nextChar;
uart_str_count++;
}
else {
uart_string[uart_str_count] = '\0';
uart_str_count = 0;
uart_str_complete = 1;
}
}
}
</c>

Zur Funktion: Wurde eine komplette Zeichenkette empfangen, also das Ende (\n oder \r) erkannt oder die maximale Länge ''UART_MAXSTRLEN'' erreicht, wird die globale Variable ''uart_str_complete'' auf '1' gesetzt. Damit wird dem Hauptprogramm, welches auf diese Variable pollt, mitgeteil, dass die Zeichenkette ''uart_string'' zur Verarbeitung bereit steht. Nach der Verarbeitung der Zeichenkette in der entsprechenden main-Routine, muss die Variable ''uart_str_complete'' wieder auf '0' zurück gesetzt werden. Dadurch werden alle neu empfangenen Zeichen wieder in den globalen Puffer geschrieben.

=== (Baustelle) ===

* Empfangen (Receive) (Anm.: z.T. erledigt)
** ggf. Fallstricke ([http://www.mikrocontroller.net/topic/84256#707214 UDR in der ISR lesen!])
** Komplettes, einfaches Beispiel ([http://www.mikrocontroller.net/topic/84228#707052 Echo] (noch buggy beim Datenzugriff, siehe Lit. 2+3!)), ggf. LED zur ISR-Empfangsanzeige oder Overflow-Anzeige

* Senden (Transmit)
** Variante "UART Data Register Empty" (UDRE) [http://www.mikrocontroller.net/topic/101472#882716]
** Variante "UART Transmit Complete" (TXC)

* FIFO-Puffer [http://www.mikrocontroller.net/topic/101472#882716], Ringpuffer (Byte Buffering (circular))

* UART-Bibliotheken
** [http://homepage.hispeed.ch/peterfleury/avr-software.html UART-Library] von Peter Fleury (UART (interrupt driven), Byte Buffering (circular))
** [http://hubbard.engr.scu.edu/embedded/avr/avrlib/ Procyon AVRlib] von Pascal Stang (UART (interrupt driven), Byte Buffering (circular), VT100 Terminal Output)

* Literatur
** [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=48188 avrfreaks.net Tutorial] inkl. Diskussion (engl.)
** avr-libc FAQ: [http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_16bitio Why do some 16-bit timer registers sometimes get trashed?]

==Software-UART==

Falls die Zahl der vorhandenen Hardware-UARTs nicht ausreicht, können weitere Schnittstellen über sogennante Software-UARTs ergänzt werden. Es gibt dazu (mindestens) zwei Ansätze:
* Der bei AVRs üblichste Ansatz basiert auf dem Prinzip, dass ein externer Interrupt-Pin für den Empfang ("RX") genutzt wird. Das Startbit löst den Interrupt aus, in der Interrupt-Routine (ISR) wird der externe Interrupt deaktiviert und ein Timer aktiviert. In der Interrupt-Routine des Timers wird der Zustand des Empfangs-Pins entsprechend der Baudrate abgetastet. Nach Empfang des Stop-Bits wird der externe Interrupt wieder aktiviert. Senden kann über einen beliebigen Pin ("TX") erfolgen, der entsprechend der Baudrate und dem zu sendenden Zeichen auf 0 oder 1 gesetzt wird. Die Implementierung ist nicht ganz einfach, es existieren dazu aber fertige Bibliotheken (z. B. bei [http://www.avrfreaks.net/ avrfreaks] oder in der [http://www.procyonengineering.com/embedded/avr/avrlib/ Procyon avrlib]).
* Ein weiterer Ansatz erfordert keinen Pin mit "Interrupt-Funktion" aber benötigt mehr Rechenzeit. Jeder Input-Pin kann als Empfangspin (RX) dienen. Über einen Timer wird der Zustand des RX-Pins mit einem vielfachen der Baudrate abgetastet (dreifach scheint üblich) und High- bzw. Lowbits anhand einer Mindestanzahl identifiziert. (Beispiel: "Generic Software Uart" Application-Note von IAR)

Neuere AVRs (z. B. ATtiny26 oder ATmega48,88,168,169) verfügen über ein Universal Serial Interface (USI), das teilweise UART-Funktion übernehmen kann. Atmel stellt eine Application-Note bereit, in der die Nutzung des USI als UART erläutert wird (im Prinzip "Hardware-unterstützter Software-UART").

==Handshaking==
Wenn der Sender ständig sendet, wird irgendwann der Fall eintreten, daß der Empfänger nicht bereit ist, neue Zeichen zu empfangen. In diesem Fall muß durch ein '''Handshake-Verfahren''' die Situation bereinigt werden. Handshake bedeutet nichts anderes, als daß der Empfänger dem Sender mitteilt, daß er zur Zeit keine Daten annehmen kann und der Sender die Übertragung der nächsten Zeichen solange einstellen soll, bis der Empfänger signalisiert, daß er wieder Zeichen aufnehmen kann.
===Hardwarehandshake (RTS/CTS)===
Beim Hardwarehandshake werden zusätzlich zu den beiden Daten-Übertragungsleitungen noch 2 weitere Leitungen benötigt: '''RTS''' ('''R'''equest '''T'''o '''S'''end) und '''CTS''' ('''C'''lear '''T'''o '''S'''end). Jeder der beiden Kommunikationspartner ist verpflichtet, bevor ein Zeichen gesendet wird, den Zustand der '''RTS''' Leitung zu überprüfen. Nur wenn die Gegenstelle darauf Empfangsbereitschaft signalisiert, darf das Zeichen gesendet werden. Um der Gegenstelle zu signalisieren, daß sie zur Zeit keine Zeichen schicken soll, wird die Leitung '''CTS''' benutzt.

===Softwarehandshake (XON/XOFF)===
Beim Softwarehandshake sind keine speziellen Leitungen notwendig. Statt dessen werden besondere ASCII-Zeichen benutzt, die der Gegenstelle signalisieren, daß Senden einzustellen bzw. wieder aufzunehmen. 
* '''XOFF''' Aufforderung das Senden einzustellen
* '''XON''' Gegenstelle darf wieder senden

Nachteilig bei einem Softwarehandshake ist es, dass dadurch keine direkte binäre Datenübertragung mehr möglich ist. Von den möglichen 256 Bytewerten werden ja 2 (nämlich '''XON''' und '''XOFF''') für besondere Zwecke benutzt und fallen daher aus.

==Galvanische Trennung==
Für eine geringe Überspannungsfestigkeit empfielt es sich, die Datenkanäle über Optokoppler zu führen. Es bietet sich z.b. der 6N138 an, ein "normaler" CNY-17 ist für hohe Baudraten nicht brauchbar.

==Fehlersuche==
Erstaunlich oft wird im Forum der Hilferuf laut: "Meine UART funktioniert nicht, was mache ich falsch". In der überwiegenden Mehrzahl der Fälle stellt sich dann heraus, daß es sich um ein Hardwareproblem handelt, wobei da wiederrum der Löwenanteil auf das Konto einer nicht korrekt eingestellten Taktrate geht: Der µC benutzt nicht einen angeschlossenen Quarz, so wie er auch im Programm eingetragen ist, sondern läuft immer noch mit dem internen RC-Takt. Daraus resultiert aber auch, daß der Baudraten Konfigurationswert falsch berechnet wird.

Hilfreich zum Aufspüren solcher Fehler ist auch die [[AVR_Checkliste#UART/USART|AVR-Checkliste]].

==Links==
Tipps zur Verarbeitung von Strings sind in den [[FAQ]].

[[Kategorie:avr-gcc Tutorial]]
[[Kategorie:UART und RS232]]

AVRDUDE

2011-05-02T12:04:42Z

Jackfritt: /* Weblinks */ link entfernt da er nur noch auf Hauptseite führt und keine Info´s zu avrdude enthält.

== Beschreibung ==
AVRDUDE (http://www.nongnu.org/avrdude/) ist eine Programmiersoftware für Atmel [[AVR]] Controller.

Funktionen unter Anderem:

* Übertragen von Programmcode in den Flash-Speicher
* Auslesen ungeschützen Codes aus dem Flash
* Setzen und Lesen von Fuse- und Lockbits (Siehe auch: [[AVR_Fuses#Vergleich_der_Fuses_bei_verschiedenen_Programmen|Vergleich der Fuses bei verschiedenen Programmen]])
* Schreiben und Lesen des EEPROMs

AVRDUDE kann das [[STK500]] (auch mit Firmware 2.x als stk500v2), das Atmel AVRISP (auch mit Firmware 2.x als avrispv2 o.ä.), das Atmel AVRISP MKII (USB Ansteuerung mittels lib-usb bzw. lib-usb-W32), [[AVR_In_System_Programmer#USB | AVR910-kompatible]] Programmierer, den [[AVR Butterfly]]/AVR109-kompatible Bootloader, [[STK200]]-Programmierdongles und verschiedene andere Parallelport-Adapter sowie "serielle Statusportprogrammierer" (Siprog) ansteuern. Auch das Atmel JTAGICE (oder Nachbauten wie Bootice oder Evertool), Atmel JTAGICE-MKII und der AVR Dragon können als Programmierhardware genutzt werden.

Das Programm ist unter MS-Windows (Cygwin nicht erforderlich), Linux, BSD, Solaris und Mac OS X lauffähig. Die Version für MS-Windows ist im [[WinAVR]]-Paket enthalten. Der Quellcode ist frei verfügbar (Lizenz beachten).

Da alle AVRDUDE-Funktionen über Kommandozeilenparamter gesteuert werden können, eignet es sich gut zur Integration in Makefiles. Beispiele finden sich in der Makefile-Vorlage von [[WinAVR]] und Mfile.

Die gesamte Konfiguration liegt in einer Textdatei (avrdude.conf), so dass sich bei Bedarf ein beliebiger neuer Parallelport-Programmierdongle oder auch ein noch nicht unterstützter AVR-Controller ergänzen lassen. Die Syntax für die Definition eines AVR-Controllers lehnt sich an die Datenblatt-Tabelle für die serielle Programmierung an, so dass man praktisch nur das Datenblatt "intelligent" abtippen muss.

Für die Ansteuerung von Parallelport-Adaptern unter MS-Windows NT/2000/XP wird ein spezieller Porttreiber (giveio) mitgeliefert. Bei der Installation von [[WinAVR]] wird giveio bereits mitinstalliert.

Programmer mit üblicher serieller Schnittstelle (RS232) benötigen keine zusätzliche Software oder Treiber zum Betrieb mit AVRDUDE.

Für Hardware mit USB-Anschluss muss die lib-usb bzw. lib-usb-win32 installiert sein.

===GUIs===
Bei [[WinAVR]] wird die grafische Oberfläche avrdude-gui.exe mitgeliefert.

Für Windows, Linux und andere Betriebssysteme gibt zwei weitere GUIs: den in Java geschriebene [[Burn-o-mat|AVR Burn-O-Mat]] und den [http://www.soft-land.de/index.php?page=avrburner avrburner].

Für Mac OS X gibt es noch [http://www.vonnieda.org/software/avrfuses AVRFuses.app]. AVRFuses muss beim ersten Starten auf den verwendeten Programmer und den Speicherort von AVRDUDE eingestellt werden.

GUIs vereinfachen vor allem Programmieren der Fuses.

== Kurzanleitung für Linux und STK200 ==

Dazu muss erst ein Hardware-Link auf die Printerport-Treiber eingerichtet werden:
<pre>
su
mknod /dev/parport0 c 99 0
chmod a+rw /dev/parport0
avrdude -p m8535 -c stk200 -e -U qqtraff.hex
</pre>

Hinweis :
Bei USB Programmern ist zu beachten, dass diese durch das Betriebssystem auf einen anderen Port gelegt werden können, als im Beispiel angegeben.
Diesen Port kann man unter Anderem "im Terminal" mit dem Befehl
<pre>
user@server: dmesg
</pre>
ermitteln.
Alternativ kann man sich eine Auflistung der Ports, im Verzeichnis "/dev" anzeigen lassen:
<pre>
user@server: ls /dev/
</pre>
Sollte man nicht sicher sein, auf welchem Port der Programmer liegt, kann man den Programmer nochmals ausstecken und "ls /dev/" ausführen. Der nun Fehlende Port, ist der Programmerport.
Diesen Port muss man statt "parport0" in die oben beschriebenen Terminalkommandos einsetzen.

Siehe auch :
* [http://wiki.ctbot.de/index.php/AVR_ISP_Programmer#BlueMP3_bzw._STK200_kompatible_Flasher weitere Beispiele für avrdude Kommandos (http://wiki.ctbot.de/index.php)]
* [[AVR_In_System_Programmer#STK200-kompatibel]]
* http://www.mikrocontroller.net/topic/200390#new

== Tipps + Tricks ==

=== [[AVR_In_System_Programmer#Parallelport|Parallelport-Programmer]] an aktuellen PCs ===
Aktuelle PCs sind einfach zu schnell mit dem Bitgewackel an der parallelen Schnittstelle, vor allem für AVRs, die noch mit den 1 MHz im Auslieferungszustand laufen (maximal zulässiger ISP-Takt < 250 kHz). Neuere Versionen von avrdude unterstützen zu diesem Zweck eine Option '''-i <N>''', wobei <N> die Anzahl der Mikrosekunden bezeichnet, die beim Bitwackeln zusätzlich zu warten ist. Einfach mal mit -i 10 anfangen und dann entweder die Fuses auf die Ziel-Taktfrequenz umstellen (falls diese wesentlich höher sein wird als die 1 MHz), oder sukkzessive mit kleineren Werten testen ([http://www.mikrocontroller.net/topic/83524#699933 Forenbeitrag von Jörg]).

Die Option -i ist auch nützlich bei AVRs, die für einen langsamen Takt konfiguriert sind. Bei einem ATmega8, der mit einem 32.768 kHz Quarz läuft, kann es z.B. notwendig sein, die Option -i 90 zu verwenden. Den Zahlenwert ggf. ausprobieren.

Manche Programmer werten die Option -i manchmal nicht aus, dann sollte man einen anderen Programmer versuchen.

Beim USBTINY und USBASP kann man die Geschwindigkeit der SPI-Schnittstelle mit dem Parameter -B [Periodendauer in Mikrosekunden] begrenzen. Da beide Geräte durch Interrupts der Software-USB-Schnittstelle stark belastet werden, handelt es sich hier um die Maximalbitrate.

Unter WinXPsp2 auf einem Thinkpad T40 lies sich die "avrdude: AVR device not responding"-Meldung beheben durch Ändern von Gerätemanager-->Ltp1-->Eigenschaften-->Anschlusseinstellungen-->Interrupt-nie-verwenden in "Jeden dem Anschluss zugewiesenem Interrupt verwenden".

===USB Programmer===
Ein Selbstbau USB-Programmer ist unter
[http://www.rototron.info/?Page=USBAVR/USBAVR.aspx http://www.rototron.info]
zu finden. Er läuft auch unter VISTA und benötigt mit der neuesten AVRDUDE Version keinen Treiber, da er im HID-Modus betrieben wird.

==== libusb0.dll wird bei WinAvr 20070525 nicht gefunden====
[http://www.mikrocontroller.net/topic/83524#701461 Forenbeitrag von Paul]: Habe leider noch etwas zu bemängeln, und zwar meckerte avrdude, dass es die "libusb0.dll" nicht fand. Musste dann erst noch manuell den Pfad c:\winavr\utils\libusb\bin in die autoxecec.bat eintragen. Siehe auch [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&p=373283 Diskussion bei www.avrfreaks.net]

====Aufruf unter Linux als user (non-root)====

Unter Linux kann häufig avrdude nur als user 'root' auf den USB-Programmer zugreifen. Als normaler User bekommt man eine Fehlermeldung wie:

<pre>
#avrdude -c usbtiny -p m8

avrdude: error: usbtiny_transmit:
error sending control message:
Operation not permitted
</pre>

Dies liegt daran, dass die device-nodes, die beim Einstecken des USB-Programmers von udev angelegt werden, root zugeordnet sind. Man kann dies ändern, indem man udev-Regeln für die verwendeten Programmer anlegt. Unter Debian muß man dazu nur eine neue Datei, z. B. 015_usbprog.rules unter /etc/udev/rules.d anlegen, z. B. mit folgenden Inhalt:

<pre>
# Atmel AVR ISP mkII
SUBSYSTEM=="usb", SYSFS{idVendor}=="03eb", SYSFS{idProduct}=="2104", GROUP="users", MODE="0660"

# usbprog bootloader
ATTRS{idVendor}=="1781", ATTRS{idProduct}=="0c62", GROUP="users", MODE="0660"

# USBasp programmer
ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="05dc", GROUP="users", MODE="0660"

# USBtiny programmer
ATTRS{idVendor}=="1781", ATTRS{idProduct}=="0c9f", GROUP="users", MODE="0660"
</pre>



Danach muss in der Regel der udev-Dienst neu gestartet werden, was -- je nach System -- mit einem der beiden folgenden Befehle funktionieren sollte (natürlich nur als root):


<pre>sudo /sbin/udevadm control --reload-rules</pre> bei aktueller udev-version, oder
<pre>sudo /sbin/udevcontrol --reload-rules</pre>, bei älteren udev-versionen.

Danach sollte der USB-Programmer erneut angeschlossen werden. Falls es immer noch nicht funktioniert kann es helfen, als GROUP "plugdev" statt "users" zu verwenden.

Hiermit werden der AVR ISP mkII, der usbprog Bootloader, USBasp und USBtiny bekannt gemacht, so daß alle User in der Gruppe "users" darauf zugreifen können.

Für weitere USB-Programmer muß man die entsprechende Zeile (mit ATTRS...) anlegen und die passenden Vendor und Product IDs eintragen.

Siehe auch:
* [http://www.reactivated.net/writing_udev_rules.html Writing udev rules]

=== Anzeige unterstützter AVRs ===
Wie die anderen Atmels bei avrdude heißen zeigt:
<pre>
avrdude -?
avrdude -p ?
</pre>

=== neuere AVRs hinzufügen ===
Manch neueres Silizium wird nicht erkannt da sich z.T. die IDs geändert haben. Um diese erfolgreich zu Programmieren empfiehlt sich ein eigenes config-File zu verwenden. Darin werden die 'fehlenden' CPUs ergänzt:

z.B. ATmega168P (Programmierung wie ATmega168): einfach den ATmega168 Teil duplizieren und die entsprechenden Änderungen (id, desc, signature) vornehmen
<pre>
#------------------------------------------------------------
# ATmega168P
#------------------------------------------------------------

part
id = "m168p";
desc = "ATMEGA168P";
has_debugwire = yes;
flash_instr = 0xB6, 0x01, 0x11;
eeprom_instr = 0xBD, 0xF2, 0xBD, 0xE1, 0xBB, 0xCF, 0xB4, 0x00,
0xBE, 0x01, 0xB6, 0x01, 0xBC, 0x00, 0xBB, 0xBF,
0x99, 0xF9, 0xBB, 0xAF;
stk500_devcode = 0x86;
# avr910_devcode = 0x;
signature = 0x1e 0x94 0x0b;

...
;
</pre>

danach kann, unter Angabe des neuen config-Files, auch ein ATmega168P programmiert werden, z.B.:

<pre>
avrdude -pm168p -C ~/.avrdude.config.neu -cstk500v2 -v -U flash:w:main.hex
</pre>

=== Anschluss an COM10 und höher (Windows) ===

Wenn AVRDUDE unter Windows an COM10 und höher betrieben werden soll, ist eine andere Schreibweise für die Schnittstelle in der Kommandozeile nötig. Beispiel:

<pre>
avrdude -c stk500v2 -p m16 -P \\.\com13 -uF -vvvv 2> logfile.txt
</pre>

In diesem Beispiel wird statt der gewohnten Schreibweise '''com13''' die spezielle Schreibweise '''\\.\com13''' verwendet und es wird mit ''-vvvv 2> logfile.txt'' eine ausführliche Debugausgabe für Fragen im Forum erzeugt. Näheres hierzu in der [http://www.mikrocontroller.net/topic/90401 Forumsdiskussion].

=== AVRISPmkII + AVRDUDE + Window Vista (32) ===

http://www.mikrocontroller.net/topic/126594#1157327

=== "avrdude was compiled without usb support" ===

Offenbar enthielt WinAVR-20100110 zunächst fälschlicherweise eine AVRDUDE Version ohne USB Support [http://www.mikrocontroller.net/topic/163022#1554907].

Abhilfe:

1. WinAVR deinstallieren, gleiches Release (WinAVR-20100110) nocheinmal herunterladen und installieren (mindestens seit Anfang März 2010 enthält dieses Release avrdude in der Version 5.10 und bringt USB-Support mit).

2. AVRDUDE selbst compilieren: http://www.mikrocontroller.net/topic/163675

3. Compilierte Version 5.10 downloaden: http://www.mikrocontroller.net/topic/163675#1594689

=== Textausgabe in Datei umleiten? ===

Die Windows-"Shell" ''cmd'' benutzt für die Ausgabeumleitung die gleiche Syntax wie die Bourne-Shell (und damit auch
Bash):

<pre>
programm >datei 2>&1
</pre>

zur Umleitung von STDOUT und STDERR in die gleiche Datei (Yalu in [http://www.mikrocontroller.net/topic/124509#1135568]).

Beispiel für Windows ([http://www.mikrocontroller.net/topic/124509#1136322], [http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx?mfr=true M$]):

<pre>
avrdude -c avrispmkII -p m8 -P usb:xx -v > "C:\output.txt" 2>&1
</pre>

oder nur STDERR in Datei umleiten:

<pre>
avrdude -c avrispmkII -p m8 -P usb:xx -v 2> "C:\output.txt"
</pre>

=== [http://www.franzis.de/elektronik/lernpakete-elektronik/lernpaket-mikrocontroller Franzis] bzw. [http://www.elo-web.de/elo/mikrocontroller-und-programmierung/avr-grundlagen/experimente-mit-dem-attiny13 ELO] Lernpaket Mikrocontroller (Attiny13) ===

Markus hat in [http://www.mikrocontroller.net/topic/169549#1649459] einen Weg beschrieben, wie man den einfachen Programmieradapter des Lernpakets mit AVRDUDE ansteuern kann.

Eine weitere Anleitung [http://www.elektronik-labor.de/AVR/AVRdude.html LP Mikrocontroller und Attiny45 mit Avrdude] gibt es von Ralf Beesner auf der Webseite des Entwicklers Burkhard Kainka. In ''avrdude.conf'' wird dabei ein neuer Programmieradapter namens ''burkhard'' hinzugefügt. Ein zweiter Eintrag ''burkhard2'' in dieser '''avrdude.conf''' ist für die Programmierung des Atmega8 auf dem Franzis Retro-Pong Bausatz mit Hilfe des "Mega8-ISP-Programmer" (Layout siehe ELO-Webseite) vorgesehen.

=== AVRDUDE mit Arduino Bootloader benutzen ===

Mit der Option ''-c stk500v1'' kann AVRDUDE den [[Bootloader]] in Arduino Boards ansprechen [http://www.mikrocontroller.net/topic/195963#1919654].

Es existieren auch modifizierte Versionen von AVRDUDE, die einen Programmer namens ''arduino'' kennen (avrdude.conf untersuchen!). Damit lautet die Kommandozeile für ein Arduinoboard mit Atmega168 beispielsweise [http://www.neuraladvance.com/2010/04/08/using-avrdude-with-the-arduino-duemilanove/]

<pre>
avrdude -c arduino -p m168 -P usb -U flash:w:<filename>
</pre>

Die Bootloader-Hacks von [http://www.ladyada.net/library/arduino/bootloader.html Ladyada] arbeiten nochmal etwas anders.

Gelegentlich gibt es unter Windows Probleme mit der allgemeinen AVRDUDE Version und deren Handling der DTR/RTS Leitung ([[RS232]]). Es kann helfen unmittelbar von dem Absenden der Kommandozeile einen RESET auf dem Arduinoboard durchzuführen.
Ein kurzes letzen der DTR Leitung auf HIGH bewirkt ein RESET. So ist es möglich eine .bat Datei zu erstellen mit folgendem Code: (com6 ist ein Virtueller USB Comport)
<pre>
mode com6 dtr=on
avrdude -c arduino -p m168 -P \\.\com6 -U flash:w:<filename>
if %ERRORLEVEL%==0 goto fertig
Pause
:fertig
exit
</pre>

=== mysmartUSB V2.11 und ATtiny 13 ===

mysmartUSB V2.11 verlangt -cavr910 als Programmer. Leider ist in avrdude
5.10 immer noch nich der ATtiny13 damit zu programmieren. Also in die
avrdude.conf folgendes mit unter ATtiny13 aufnehmen, so kann er dann
korrekt programmiert werden(inkl. Fuse Bits).
<pre>
#------------------------------------------------------------
# ATtiny13
#------------------------------------------------------------

part
id = "t13";
desc = "ATtiny13";
has_debugwire = yes;
flash_instr = 0xB4, 0x0E, 0x1E;
eeprom_instr = 0xBB, 0xFE, 0xBB, 0xEE, 0xBB, 0xCC, 0xB2, 0x0D,
0xBC, 0x0E, 0xB4, 0x0E, 0xBA, 0x0D, 0xBB, 0xBC,
0x99, 0xE1, 0xBB, 0xAC;
stk500_devcode = 0x14;
avr910_devcode = 0x55;
......
</pre>

Achtung! Programmieren geht auch mit -cavr911. Allerdings geht das Fuse
setzen nicht und man bekommt eine Fehlermeldung.(Programm läuft aber)
<pre>
Reading | ################################################## | 100%
0.12s

avrdude: verifying ...
avrdude: 226 bytes of flash verified
avrdude: reading input file "0x7a"
avrdude: writing lfuse (1 bytes):

Writing | ***failed;
################################################## | 100% 0.00s

avrdude: 1 bytes of lfuse written
avrdude: verifying lfuse memory against 0x7a:
avrdude: load data lfuse data from input file 0x7a:
avrdude: input file 0x7a contains 1 bytes
avrdude: reading on-chip lfuse data:

Reading | ################################################## | 100%
0.00s

avrdude: verifying ...
avrdude: 1 bytes of lfuse verified
avrdude: reading input file "0xff"
avrdude: writing hfuse (1 bytes):

Writing | ***failed;
</pre>

== Weblinks ==
* Offizielle AVRDUDE Homepage unter http://www.nongnu.org/avrdude/
* User Manual (engl.) unter http://www.nongnu.org/avrdude/user-manual/avrdude.html#Top
* Kompilierte Windows Version mit USB Support http://yuki-lab.jp/hw/avrdude-GUI/avrdude-5.5-win32-bin.zip
* Kompilierte Windows Version avrdude 5.10 mit USB Support http://www.mikrocontroller.net/topic/163675#1594689
* Wer Interesse an der modifizierten Version von AVRDUDE und des AVR910-Programmer hat, kann sich bei http://www.fischl.de/thomas/elektronik/avr910e/ informieren. Der Programmer bleibt auch mit der Modifikation weiterhin kompatibel zu anderer Programmiersoftware.
* [[Burn-o-mat|AVR Burn-O-Mat]] GUI (Graphic User Interface) für AVRDUDE http://burn-o-mat.net mit FUSE-Editor (Java, für Windows und Linux)
* [http://www.soft-land.de/index.php?page=avrburner AVRBurner] Ponyprog ähnliche Oberfläche für AVRDUDE.
* [http://www.microstar.ir/download/SinaProg.zip SinaProg] SinaProg - avrdude GUI mit AVR Fuse Calculator.

[[Kategorie:AVR-Programmer und -Bootloader]]
[[Kategorie:Entwicklungstools]]

AVRDUDE

2011-05-02T12:01:51Z

Jackfritt: /* mysmartUSB V2.11 und ATtiny 13 */

== Beschreibung ==
AVRDUDE (http://www.nongnu.org/avrdude/) ist eine Programmiersoftware für Atmel [[AVR]] Controller.

Funktionen unter Anderem:

* Übertragen von Programmcode in den Flash-Speicher
* Auslesen ungeschützen Codes aus dem Flash
* Setzen und Lesen von Fuse- und Lockbits (Siehe auch: [[AVR_Fuses#Vergleich_der_Fuses_bei_verschiedenen_Programmen|Vergleich der Fuses bei verschiedenen Programmen]])
* Schreiben und Lesen des EEPROMs

AVRDUDE kann das [[STK500]] (auch mit Firmware 2.x als stk500v2), das Atmel AVRISP (auch mit Firmware 2.x als avrispv2 o.ä.), das Atmel AVRISP MKII (USB Ansteuerung mittels lib-usb bzw. lib-usb-W32), [[AVR_In_System_Programmer#USB | AVR910-kompatible]] Programmierer, den [[AVR Butterfly]]/AVR109-kompatible Bootloader, [[STK200]]-Programmierdongles und verschiedene andere Parallelport-Adapter sowie "serielle Statusportprogrammierer" (Siprog) ansteuern. Auch das Atmel JTAGICE (oder Nachbauten wie Bootice oder Evertool), Atmel JTAGICE-MKII und der AVR Dragon können als Programmierhardware genutzt werden.

Das Programm ist unter MS-Windows (Cygwin nicht erforderlich), Linux, BSD, Solaris und Mac OS X lauffähig. Die Version für MS-Windows ist im [[WinAVR]]-Paket enthalten. Der Quellcode ist frei verfügbar (Lizenz beachten).

Da alle AVRDUDE-Funktionen über Kommandozeilenparamter gesteuert werden können, eignet es sich gut zur Integration in Makefiles. Beispiele finden sich in der Makefile-Vorlage von [[WinAVR]] und Mfile.

Die gesamte Konfiguration liegt in einer Textdatei (avrdude.conf), so dass sich bei Bedarf ein beliebiger neuer Parallelport-Programmierdongle oder auch ein noch nicht unterstützter AVR-Controller ergänzen lassen. Die Syntax für die Definition eines AVR-Controllers lehnt sich an die Datenblatt-Tabelle für die serielle Programmierung an, so dass man praktisch nur das Datenblatt "intelligent" abtippen muss.

Für die Ansteuerung von Parallelport-Adaptern unter MS-Windows NT/2000/XP wird ein spezieller Porttreiber (giveio) mitgeliefert. Bei der Installation von [[WinAVR]] wird giveio bereits mitinstalliert.

Programmer mit üblicher serieller Schnittstelle (RS232) benötigen keine zusätzliche Software oder Treiber zum Betrieb mit AVRDUDE.

Für Hardware mit USB-Anschluss muss die lib-usb bzw. lib-usb-win32 installiert sein.

===GUIs===
Bei [[WinAVR]] wird die grafische Oberfläche avrdude-gui.exe mitgeliefert.

Für Windows, Linux und andere Betriebssysteme gibt zwei weitere GUIs: den in Java geschriebene [[Burn-o-mat|AVR Burn-O-Mat]] und den [http://www.soft-land.de/index.php?page=avrburner avrburner].

Für Mac OS X gibt es noch [http://www.vonnieda.org/software/avrfuses AVRFuses.app]. AVRFuses muss beim ersten Starten auf den verwendeten Programmer und den Speicherort von AVRDUDE eingestellt werden.

GUIs vereinfachen vor allem Programmieren der Fuses.

== Kurzanleitung für Linux und STK200 ==

Dazu muss erst ein Hardware-Link auf die Printerport-Treiber eingerichtet werden:
<pre>
su
mknod /dev/parport0 c 99 0
chmod a+rw /dev/parport0
avrdude -p m8535 -c stk200 -e -U qqtraff.hex
</pre>

Hinweis :
Bei USB Programmern ist zu beachten, dass diese durch das Betriebssystem auf einen anderen Port gelegt werden können, als im Beispiel angegeben.
Diesen Port kann man unter Anderem "im Terminal" mit dem Befehl
<pre>
user@server: dmesg
</pre>
ermitteln.
Alternativ kann man sich eine Auflistung der Ports, im Verzeichnis "/dev" anzeigen lassen:
<pre>
user@server: ls /dev/
</pre>
Sollte man nicht sicher sein, auf welchem Port der Programmer liegt, kann man den Programmer nochmals ausstecken und "ls /dev/" ausführen. Der nun Fehlende Port, ist der Programmerport.
Diesen Port muss man statt "parport0" in die oben beschriebenen Terminalkommandos einsetzen.

Siehe auch :
* [http://wiki.ctbot.de/index.php/AVR_ISP_Programmer#BlueMP3_bzw._STK200_kompatible_Flasher weitere Beispiele für avrdude Kommandos (http://wiki.ctbot.de/index.php)]
* [[AVR_In_System_Programmer#STK200-kompatibel]]
* http://www.mikrocontroller.net/topic/200390#new

== Tipps + Tricks ==

=== [[AVR_In_System_Programmer#Parallelport|Parallelport-Programmer]] an aktuellen PCs ===
Aktuelle PCs sind einfach zu schnell mit dem Bitgewackel an der parallelen Schnittstelle, vor allem für AVRs, die noch mit den 1 MHz im Auslieferungszustand laufen (maximal zulässiger ISP-Takt < 250 kHz). Neuere Versionen von avrdude unterstützen zu diesem Zweck eine Option '''-i <N>''', wobei <N> die Anzahl der Mikrosekunden bezeichnet, die beim Bitwackeln zusätzlich zu warten ist. Einfach mal mit -i 10 anfangen und dann entweder die Fuses auf die Ziel-Taktfrequenz umstellen (falls diese wesentlich höher sein wird als die 1 MHz), oder sukkzessive mit kleineren Werten testen ([http://www.mikrocontroller.net/topic/83524#699933 Forenbeitrag von Jörg]).

Die Option -i ist auch nützlich bei AVRs, die für einen langsamen Takt konfiguriert sind. Bei einem ATmega8, der mit einem 32.768 kHz Quarz läuft, kann es z.B. notwendig sein, die Option -i 90 zu verwenden. Den Zahlenwert ggf. ausprobieren.

Manche Programmer werten die Option -i manchmal nicht aus, dann sollte man einen anderen Programmer versuchen.

Beim USBTINY und USBASP kann man die Geschwindigkeit der SPI-Schnittstelle mit dem Parameter -B [Periodendauer in Mikrosekunden] begrenzen. Da beide Geräte durch Interrupts der Software-USB-Schnittstelle stark belastet werden, handelt es sich hier um die Maximalbitrate.

Unter WinXPsp2 auf einem Thinkpad T40 lies sich die "avrdude: AVR device not responding"-Meldung beheben durch Ändern von Gerätemanager-->Ltp1-->Eigenschaften-->Anschlusseinstellungen-->Interrupt-nie-verwenden in "Jeden dem Anschluss zugewiesenem Interrupt verwenden".

===USB Programmer===
Ein Selbstbau USB-Programmer ist unter
[http://www.rototron.info/?Page=USBAVR/USBAVR.aspx http://www.rototron.info]
zu finden. Er läuft auch unter VISTA und benötigt mit der neuesten AVRDUDE Version keinen Treiber, da er im HID-Modus betrieben wird.

==== libusb0.dll wird bei WinAvr 20070525 nicht gefunden====
[http://www.mikrocontroller.net/topic/83524#701461 Forenbeitrag von Paul]: Habe leider noch etwas zu bemängeln, und zwar meckerte avrdude, dass es die "libusb0.dll" nicht fand. Musste dann erst noch manuell den Pfad c:\winavr\utils\libusb\bin in die autoxecec.bat eintragen. Siehe auch [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&p=373283 Diskussion bei www.avrfreaks.net]

====Aufruf unter Linux als user (non-root)====

Unter Linux kann häufig avrdude nur als user 'root' auf den USB-Programmer zugreifen. Als normaler User bekommt man eine Fehlermeldung wie:

<pre>
#avrdude -c usbtiny -p m8

avrdude: error: usbtiny_transmit:
error sending control message:
Operation not permitted
</pre>

Dies liegt daran, dass die device-nodes, die beim Einstecken des USB-Programmers von udev angelegt werden, root zugeordnet sind. Man kann dies ändern, indem man udev-Regeln für die verwendeten Programmer anlegt. Unter Debian muß man dazu nur eine neue Datei, z. B. 015_usbprog.rules unter /etc/udev/rules.d anlegen, z. B. mit folgenden Inhalt:

<pre>
# Atmel AVR ISP mkII
SUBSYSTEM=="usb", SYSFS{idVendor}=="03eb", SYSFS{idProduct}=="2104", GROUP="users", MODE="0660"

# usbprog bootloader
ATTRS{idVendor}=="1781", ATTRS{idProduct}=="0c62", GROUP="users", MODE="0660"

# USBasp programmer
ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="05dc", GROUP="users", MODE="0660"

# USBtiny programmer
ATTRS{idVendor}=="1781", ATTRS{idProduct}=="0c9f", GROUP="users", MODE="0660"
</pre>



Danach muss in der Regel der udev-Dienst neu gestartet werden, was -- je nach System -- mit einem der beiden folgenden Befehle funktionieren sollte (natürlich nur als root):


<pre>sudo /sbin/udevadm control --reload-rules</pre> bei aktueller udev-version, oder
<pre>sudo /sbin/udevcontrol --reload-rules</pre>, bei älteren udev-versionen.

Danach sollte der USB-Programmer erneut angeschlossen werden. Falls es immer noch nicht funktioniert kann es helfen, als GROUP "plugdev" statt "users" zu verwenden.

Hiermit werden der AVR ISP mkII, der usbprog Bootloader, USBasp und USBtiny bekannt gemacht, so daß alle User in der Gruppe "users" darauf zugreifen können.

Für weitere USB-Programmer muß man die entsprechende Zeile (mit ATTRS...) anlegen und die passenden Vendor und Product IDs eintragen.

Siehe auch:
* [http://www.reactivated.net/writing_udev_rules.html Writing udev rules]

=== Anzeige unterstützter AVRs ===
Wie die anderen Atmels bei avrdude heißen zeigt:
<pre>
avrdude -?
avrdude -p ?
</pre>

=== neuere AVRs hinzufügen ===
Manch neueres Silizium wird nicht erkannt da sich z.T. die IDs geändert haben. Um diese erfolgreich zu Programmieren empfiehlt sich ein eigenes config-File zu verwenden. Darin werden die 'fehlenden' CPUs ergänzt:

z.B. ATmega168P (Programmierung wie ATmega168): einfach den ATmega168 Teil duplizieren und die entsprechenden Änderungen (id, desc, signature) vornehmen
<pre>
#------------------------------------------------------------
# ATmega168P
#------------------------------------------------------------

part
id = "m168p";
desc = "ATMEGA168P";
has_debugwire = yes;
flash_instr = 0xB6, 0x01, 0x11;
eeprom_instr = 0xBD, 0xF2, 0xBD, 0xE1, 0xBB, 0xCF, 0xB4, 0x00,
0xBE, 0x01, 0xB6, 0x01, 0xBC, 0x00, 0xBB, 0xBF,
0x99, 0xF9, 0xBB, 0xAF;
stk500_devcode = 0x86;
# avr910_devcode = 0x;
signature = 0x1e 0x94 0x0b;

...
;
</pre>

danach kann, unter Angabe des neuen config-Files, auch ein ATmega168P programmiert werden, z.B.:

<pre>
avrdude -pm168p -C ~/.avrdude.config.neu -cstk500v2 -v -U flash:w:main.hex
</pre>

=== Anschluss an COM10 und höher (Windows) ===

Wenn AVRDUDE unter Windows an COM10 und höher betrieben werden soll, ist eine andere Schreibweise für die Schnittstelle in der Kommandozeile nötig. Beispiel:

<pre>
avrdude -c stk500v2 -p m16 -P \\.\com13 -uF -vvvv 2> logfile.txt
</pre>

In diesem Beispiel wird statt der gewohnten Schreibweise '''com13''' die spezielle Schreibweise '''\\.\com13''' verwendet und es wird mit ''-vvvv 2> logfile.txt'' eine ausführliche Debugausgabe für Fragen im Forum erzeugt. Näheres hierzu in der [http://www.mikrocontroller.net/topic/90401 Forumsdiskussion].

=== AVRISPmkII + AVRDUDE + Window Vista (32) ===

http://www.mikrocontroller.net/topic/126594#1157327

=== "avrdude was compiled without usb support" ===

Offenbar enthielt WinAVR-20100110 zunächst fälschlicherweise eine AVRDUDE Version ohne USB Support [http://www.mikrocontroller.net/topic/163022#1554907].

Abhilfe:

1. WinAVR deinstallieren, gleiches Release (WinAVR-20100110) nocheinmal herunterladen und installieren (mindestens seit Anfang März 2010 enthält dieses Release avrdude in der Version 5.10 und bringt USB-Support mit).

2. AVRDUDE selbst compilieren: http://www.mikrocontroller.net/topic/163675

3. Compilierte Version 5.10 downloaden: http://www.mikrocontroller.net/topic/163675#1594689

=== Textausgabe in Datei umleiten? ===

Die Windows-"Shell" ''cmd'' benutzt für die Ausgabeumleitung die gleiche Syntax wie die Bourne-Shell (und damit auch
Bash):

<pre>
programm >datei 2>&1
</pre>

zur Umleitung von STDOUT und STDERR in die gleiche Datei (Yalu in [http://www.mikrocontroller.net/topic/124509#1135568]).

Beispiel für Windows ([http://www.mikrocontroller.net/topic/124509#1136322], [http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx?mfr=true M$]):

<pre>
avrdude -c avrispmkII -p m8 -P usb:xx -v > "C:\output.txt" 2>&1
</pre>

oder nur STDERR in Datei umleiten:

<pre>
avrdude -c avrispmkII -p m8 -P usb:xx -v 2> "C:\output.txt"
</pre>

=== [http://www.franzis.de/elektronik/lernpakete-elektronik/lernpaket-mikrocontroller Franzis] bzw. [http://www.elo-web.de/elo/mikrocontroller-und-programmierung/avr-grundlagen/experimente-mit-dem-attiny13 ELO] Lernpaket Mikrocontroller (Attiny13) ===

Markus hat in [http://www.mikrocontroller.net/topic/169549#1649459] einen Weg beschrieben, wie man den einfachen Programmieradapter des Lernpakets mit AVRDUDE ansteuern kann.

Eine weitere Anleitung [http://www.elektronik-labor.de/AVR/AVRdude.html LP Mikrocontroller und Attiny45 mit Avrdude] gibt es von Ralf Beesner auf der Webseite des Entwicklers Burkhard Kainka. In ''avrdude.conf'' wird dabei ein neuer Programmieradapter namens ''burkhard'' hinzugefügt. Ein zweiter Eintrag ''burkhard2'' in dieser '''avrdude.conf''' ist für die Programmierung des Atmega8 auf dem Franzis Retro-Pong Bausatz mit Hilfe des "Mega8-ISP-Programmer" (Layout siehe ELO-Webseite) vorgesehen.

=== AVRDUDE mit Arduino Bootloader benutzen ===

Mit der Option ''-c stk500v1'' kann AVRDUDE den [[Bootloader]] in Arduino Boards ansprechen [http://www.mikrocontroller.net/topic/195963#1919654].

Es existieren auch modifizierte Versionen von AVRDUDE, die einen Programmer namens ''arduino'' kennen (avrdude.conf untersuchen!). Damit lautet die Kommandozeile für ein Arduinoboard mit Atmega168 beispielsweise [http://www.neuraladvance.com/2010/04/08/using-avrdude-with-the-arduino-duemilanove/]

<pre>
avrdude -c arduino -p m168 -P usb -U flash:w:<filename>
</pre>

Die Bootloader-Hacks von [http://www.ladyada.net/library/arduino/bootloader.html Ladyada] arbeiten nochmal etwas anders.

Gelegentlich gibt es unter Windows Probleme mit der allgemeinen AVRDUDE Version und deren Handling der DTR/RTS Leitung ([[RS232]]). Es kann helfen unmittelbar von dem Absenden der Kommandozeile einen RESET auf dem Arduinoboard durchzuführen.
Ein kurzes letzen der DTR Leitung auf HIGH bewirkt ein RESET. So ist es möglich eine .bat Datei zu erstellen mit folgendem Code: (com6 ist ein Virtueller USB Comport)
<pre>
mode com6 dtr=on
avrdude -c arduino -p m168 -P \\.\com6 -U flash:w:<filename>
if %ERRORLEVEL%==0 goto fertig
Pause
:fertig
exit
</pre>

=== mysmartUSB V2.11 und ATtiny 13 ===

mysmartUSB V2.11 verlangt -cavr910 als Programmer. Leider ist in avrdude
5.10 immer noch nich der ATtiny13 damit zu programmieren. Also in die
avrdude.conf folgendes mit unter ATtiny13 aufnehmen, so kann er dann
korrekt programmiert werden(inkl. Fuse Bits).
<pre>
#------------------------------------------------------------
# ATtiny13
#------------------------------------------------------------

part
id = "t13";
desc = "ATtiny13";
has_debugwire = yes;
flash_instr = 0xB4, 0x0E, 0x1E;
eeprom_instr = 0xBB, 0xFE, 0xBB, 0xEE, 0xBB, 0xCC, 0xB2, 0x0D,
0xBC, 0x0E, 0xB4, 0x0E, 0xBA, 0x0D, 0xBB, 0xBC,
0x99, 0xE1, 0xBB, 0xAC;
stk500_devcode = 0x14;
avr910_devcode = 0x55;
......
</pre>

Achtung! Programmieren geht auch mit -cavr911. Allerdings geht das Fuse
setzen nicht und man bekommt eine Fehlermeldung.(Programm läuft aber)
<pre>
Reading | ################################################## | 100%
0.12s

avrdude: verifying ...
avrdude: 226 bytes of flash verified
avrdude: reading input file "0x7a"
avrdude: writing lfuse (1 bytes):

Writing | ***failed;
################################################## | 100% 0.00s

avrdude: 1 bytes of lfuse written
avrdude: verifying lfuse memory against 0x7a:
avrdude: load data lfuse data from input file 0x7a:
avrdude: input file 0x7a contains 1 bytes
avrdude: reading on-chip lfuse data:

Reading | ################################################## | 100%
0.00s

avrdude: verifying ...
avrdude: 1 bytes of lfuse verified
avrdude: reading input file "0xff"
avrdude: writing hfuse (1 bytes):

Writing | ***failed;
</pre>

== Weblinks ==
* Offizielle AVRDUDE Homepage unter http://www.nongnu.org/avrdude/
* User Manual (engl.) unter http://www.nongnu.org/avrdude/user-manual/avrdude.html#Top
* Kompilierte Windows Version mit USB Support http://yuki-lab.jp/hw/avrdude-GUI/avrdude-5.5-win32-bin.zip
* Kompilierte Windows Version avrdude 5.10 mit USB Support http://www.mikrocontroller.net/topic/163675#1594689
* Wer Interesse an der modifizierten Version von AVRDUDE und des AVR910-Programmer hat, kann sich bei http://www.fischl.de/thomas/elektronik/avr910e/ informieren. Der Programmer bleibt auch mit der Modifikation weiterhin kompatibel zu anderer Programmiersoftware.
* [[Burn-o-mat|AVR Burn-O-Mat]] GUI (Graphic User Interface) für AVRDUDE http://burn-o-mat.net mit FUSE-Editor (Java, für Windows und Linux)
* [http://myavr.de/myForum/viewtopic.php?t=1913 mysmartusb AVR910-Devcodes] für moderne AVRs (Firmware 2.3). Kann zur Anpassung von AVRDUDE in avrdude.conf verwendet werden.
* [http://www.soft-land.de/index.php?page=avrburner AVRBurner] Ponyprog ähnliche Oberfläche für AVRDUDE.
* [http://www.microstar.ir/download/SinaProg.zip SinaProg] SinaProg - avrdude GUI mit AVR Fuse Calculator.

[[Kategorie:AVR-Programmer und -Bootloader]]
[[Kategorie:Entwicklungstools]]

AVRDUDE

2011-05-02T12:01:19Z

Jackfritt: "mysmartUSB V2.11 und ATtiny 13" hinzugefügt

== Beschreibung ==
AVRDUDE (http://www.nongnu.org/avrdude/) ist eine Programmiersoftware für Atmel [[AVR]] Controller.

Funktionen unter Anderem:

* Übertragen von Programmcode in den Flash-Speicher
* Auslesen ungeschützen Codes aus dem Flash
* Setzen und Lesen von Fuse- und Lockbits (Siehe auch: [[AVR_Fuses#Vergleich_der_Fuses_bei_verschiedenen_Programmen|Vergleich der Fuses bei verschiedenen Programmen]])
* Schreiben und Lesen des EEPROMs

AVRDUDE kann das [[STK500]] (auch mit Firmware 2.x als stk500v2), das Atmel AVRISP (auch mit Firmware 2.x als avrispv2 o.ä.), das Atmel AVRISP MKII (USB Ansteuerung mittels lib-usb bzw. lib-usb-W32), [[AVR_In_System_Programmer#USB | AVR910-kompatible]] Programmierer, den [[AVR Butterfly]]/AVR109-kompatible Bootloader, [[STK200]]-Programmierdongles und verschiedene andere Parallelport-Adapter sowie "serielle Statusportprogrammierer" (Siprog) ansteuern. Auch das Atmel JTAGICE (oder Nachbauten wie Bootice oder Evertool), Atmel JTAGICE-MKII und der AVR Dragon können als Programmierhardware genutzt werden.

Das Programm ist unter MS-Windows (Cygwin nicht erforderlich), Linux, BSD, Solaris und Mac OS X lauffähig. Die Version für MS-Windows ist im [[WinAVR]]-Paket enthalten. Der Quellcode ist frei verfügbar (Lizenz beachten).

Da alle AVRDUDE-Funktionen über Kommandozeilenparamter gesteuert werden können, eignet es sich gut zur Integration in Makefiles. Beispiele finden sich in der Makefile-Vorlage von [[WinAVR]] und Mfile.

Die gesamte Konfiguration liegt in einer Textdatei (avrdude.conf), so dass sich bei Bedarf ein beliebiger neuer Parallelport-Programmierdongle oder auch ein noch nicht unterstützter AVR-Controller ergänzen lassen. Die Syntax für die Definition eines AVR-Controllers lehnt sich an die Datenblatt-Tabelle für die serielle Programmierung an, so dass man praktisch nur das Datenblatt "intelligent" abtippen muss.

Für die Ansteuerung von Parallelport-Adaptern unter MS-Windows NT/2000/XP wird ein spezieller Porttreiber (giveio) mitgeliefert. Bei der Installation von [[WinAVR]] wird giveio bereits mitinstalliert.

Programmer mit üblicher serieller Schnittstelle (RS232) benötigen keine zusätzliche Software oder Treiber zum Betrieb mit AVRDUDE.

Für Hardware mit USB-Anschluss muss die lib-usb bzw. lib-usb-win32 installiert sein.

===GUIs===
Bei [[WinAVR]] wird die grafische Oberfläche avrdude-gui.exe mitgeliefert.

Für Windows, Linux und andere Betriebssysteme gibt zwei weitere GUIs: den in Java geschriebene [[Burn-o-mat|AVR Burn-O-Mat]] und den [http://www.soft-land.de/index.php?page=avrburner avrburner].

Für Mac OS X gibt es noch [http://www.vonnieda.org/software/avrfuses AVRFuses.app]. AVRFuses muss beim ersten Starten auf den verwendeten Programmer und den Speicherort von AVRDUDE eingestellt werden.

GUIs vereinfachen vor allem Programmieren der Fuses.

== Kurzanleitung für Linux und STK200 ==

Dazu muss erst ein Hardware-Link auf die Printerport-Treiber eingerichtet werden:
<pre>
su
mknod /dev/parport0 c 99 0
chmod a+rw /dev/parport0
avrdude -p m8535 -c stk200 -e -U qqtraff.hex
</pre>

Hinweis :
Bei USB Programmern ist zu beachten, dass diese durch das Betriebssystem auf einen anderen Port gelegt werden können, als im Beispiel angegeben.
Diesen Port kann man unter Anderem "im Terminal" mit dem Befehl
<pre>
user@server: dmesg
</pre>
ermitteln.
Alternativ kann man sich eine Auflistung der Ports, im Verzeichnis "/dev" anzeigen lassen:
<pre>
user@server: ls /dev/
</pre>
Sollte man nicht sicher sein, auf welchem Port der Programmer liegt, kann man den Programmer nochmals ausstecken und "ls /dev/" ausführen. Der nun Fehlende Port, ist der Programmerport.
Diesen Port muss man statt "parport0" in die oben beschriebenen Terminalkommandos einsetzen.

Siehe auch :
* [http://wiki.ctbot.de/index.php/AVR_ISP_Programmer#BlueMP3_bzw._STK200_kompatible_Flasher weitere Beispiele für avrdude Kommandos (http://wiki.ctbot.de/index.php)]
* [[AVR_In_System_Programmer#STK200-kompatibel]]
* http://www.mikrocontroller.net/topic/200390#new

== Tipps + Tricks ==

=== [[AVR_In_System_Programmer#Parallelport|Parallelport-Programmer]] an aktuellen PCs ===
Aktuelle PCs sind einfach zu schnell mit dem Bitgewackel an der parallelen Schnittstelle, vor allem für AVRs, die noch mit den 1 MHz im Auslieferungszustand laufen (maximal zulässiger ISP-Takt < 250 kHz). Neuere Versionen von avrdude unterstützen zu diesem Zweck eine Option '''-i <N>''', wobei <N> die Anzahl der Mikrosekunden bezeichnet, die beim Bitwackeln zusätzlich zu warten ist. Einfach mal mit -i 10 anfangen und dann entweder die Fuses auf die Ziel-Taktfrequenz umstellen (falls diese wesentlich höher sein wird als die 1 MHz), oder sukkzessive mit kleineren Werten testen ([http://www.mikrocontroller.net/topic/83524#699933 Forenbeitrag von Jörg]).

Die Option -i ist auch nützlich bei AVRs, die für einen langsamen Takt konfiguriert sind. Bei einem ATmega8, der mit einem 32.768 kHz Quarz läuft, kann es z.B. notwendig sein, die Option -i 90 zu verwenden. Den Zahlenwert ggf. ausprobieren.

Manche Programmer werten die Option -i manchmal nicht aus, dann sollte man einen anderen Programmer versuchen.

Beim USBTINY und USBASP kann man die Geschwindigkeit der SPI-Schnittstelle mit dem Parameter -B [Periodendauer in Mikrosekunden] begrenzen. Da beide Geräte durch Interrupts der Software-USB-Schnittstelle stark belastet werden, handelt es sich hier um die Maximalbitrate.

Unter WinXPsp2 auf einem Thinkpad T40 lies sich die "avrdude: AVR device not responding"-Meldung beheben durch Ändern von Gerätemanager-->Ltp1-->Eigenschaften-->Anschlusseinstellungen-->Interrupt-nie-verwenden in "Jeden dem Anschluss zugewiesenem Interrupt verwenden".

===USB Programmer===
Ein Selbstbau USB-Programmer ist unter
[http://www.rototron.info/?Page=USBAVR/USBAVR.aspx http://www.rototron.info]
zu finden. Er läuft auch unter VISTA und benötigt mit der neuesten AVRDUDE Version keinen Treiber, da er im HID-Modus betrieben wird.

==== libusb0.dll wird bei WinAvr 20070525 nicht gefunden====
[http://www.mikrocontroller.net/topic/83524#701461 Forenbeitrag von Paul]: Habe leider noch etwas zu bemängeln, und zwar meckerte avrdude, dass es die "libusb0.dll" nicht fand. Musste dann erst noch manuell den Pfad c:\winavr\utils\libusb\bin in die autoxecec.bat eintragen. Siehe auch [http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&p=373283 Diskussion bei www.avrfreaks.net]

====Aufruf unter Linux als user (non-root)====

Unter Linux kann häufig avrdude nur als user 'root' auf den USB-Programmer zugreifen. Als normaler User bekommt man eine Fehlermeldung wie:

<pre>
#avrdude -c usbtiny -p m8

avrdude: error: usbtiny_transmit:
error sending control message:
Operation not permitted
</pre>

Dies liegt daran, dass die device-nodes, die beim Einstecken des USB-Programmers von udev angelegt werden, root zugeordnet sind. Man kann dies ändern, indem man udev-Regeln für die verwendeten Programmer anlegt. Unter Debian muß man dazu nur eine neue Datei, z. B. 015_usbprog.rules unter /etc/udev/rules.d anlegen, z. B. mit folgenden Inhalt:

<pre>
# Atmel AVR ISP mkII
SUBSYSTEM=="usb", SYSFS{idVendor}=="03eb", SYSFS{idProduct}=="2104", GROUP="users", MODE="0660"

# usbprog bootloader
ATTRS{idVendor}=="1781", ATTRS{idProduct}=="0c62", GROUP="users", MODE="0660"

# USBasp programmer
ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="05dc", GROUP="users", MODE="0660"

# USBtiny programmer
ATTRS{idVendor}=="1781", ATTRS{idProduct}=="0c9f", GROUP="users", MODE="0660"
</pre>



Danach muss in der Regel der udev-Dienst neu gestartet werden, was -- je nach System -- mit einem der beiden folgenden Befehle funktionieren sollte (natürlich nur als root):


<pre>sudo /sbin/udevadm control --reload-rules</pre> bei aktueller udev-version, oder
<pre>sudo /sbin/udevcontrol --reload-rules</pre>, bei älteren udev-versionen.

Danach sollte der USB-Programmer erneut angeschlossen werden. Falls es immer noch nicht funktioniert kann es helfen, als GROUP "plugdev" statt "users" zu verwenden.

Hiermit werden der AVR ISP mkII, der usbprog Bootloader, USBasp und USBtiny bekannt gemacht, so daß alle User in der Gruppe "users" darauf zugreifen können.

Für weitere USB-Programmer muß man die entsprechende Zeile (mit ATTRS...) anlegen und die passenden Vendor und Product IDs eintragen.

Siehe auch:
* [http://www.reactivated.net/writing_udev_rules.html Writing udev rules]

=== Anzeige unterstützter AVRs ===
Wie die anderen Atmels bei avrdude heißen zeigt:
<pre>
avrdude -?
avrdude -p ?
</pre>

=== neuere AVRs hinzufügen ===
Manch neueres Silizium wird nicht erkannt da sich z.T. die IDs geändert haben. Um diese erfolgreich zu Programmieren empfiehlt sich ein eigenes config-File zu verwenden. Darin werden die 'fehlenden' CPUs ergänzt:

z.B. ATmega168P (Programmierung wie ATmega168): einfach den ATmega168 Teil duplizieren und die entsprechenden Änderungen (id, desc, signature) vornehmen
<pre>
#------------------------------------------------------------
# ATmega168P
#------------------------------------------------------------

part
id = "m168p";
desc = "ATMEGA168P";
has_debugwire = yes;
flash_instr = 0xB6, 0x01, 0x11;
eeprom_instr = 0xBD, 0xF2, 0xBD, 0xE1, 0xBB, 0xCF, 0xB4, 0x00,
0xBE, 0x01, 0xB6, 0x01, 0xBC, 0x00, 0xBB, 0xBF,
0x99, 0xF9, 0xBB, 0xAF;
stk500_devcode = 0x86;
# avr910_devcode = 0x;
signature = 0x1e 0x94 0x0b;

...
;
</pre>

danach kann, unter Angabe des neuen config-Files, auch ein ATmega168P programmiert werden, z.B.:

<pre>
avrdude -pm168p -C ~/.avrdude.config.neu -cstk500v2 -v -U flash:w:main.hex
</pre>

=== Anschluss an COM10 und höher (Windows) ===

Wenn AVRDUDE unter Windows an COM10 und höher betrieben werden soll, ist eine andere Schreibweise für die Schnittstelle in der Kommandozeile nötig. Beispiel:

<pre>
avrdude -c stk500v2 -p m16 -P \\.\com13 -uF -vvvv 2> logfile.txt
</pre>

In diesem Beispiel wird statt der gewohnten Schreibweise '''com13''' die spezielle Schreibweise '''\\.\com13''' verwendet und es wird mit ''-vvvv 2> logfile.txt'' eine ausführliche Debugausgabe für Fragen im Forum erzeugt. Näheres hierzu in der [http://www.mikrocontroller.net/topic/90401 Forumsdiskussion].

=== AVRISPmkII + AVRDUDE + Window Vista (32) ===

http://www.mikrocontroller.net/topic/126594#1157327

=== "avrdude was compiled without usb support" ===

Offenbar enthielt WinAVR-20100110 zunächst fälschlicherweise eine AVRDUDE Version ohne USB Support [http://www.mikrocontroller.net/topic/163022#1554907].

Abhilfe:

1. WinAVR deinstallieren, gleiches Release (WinAVR-20100110) nocheinmal herunterladen und installieren (mindestens seit Anfang März 2010 enthält dieses Release avrdude in der Version 5.10 und bringt USB-Support mit).

2. AVRDUDE selbst compilieren: http://www.mikrocontroller.net/topic/163675

3. Compilierte Version 5.10 downloaden: http://www.mikrocontroller.net/topic/163675#1594689

=== Textausgabe in Datei umleiten? ===

Die Windows-"Shell" ''cmd'' benutzt für die Ausgabeumleitung die gleiche Syntax wie die Bourne-Shell (und damit auch
Bash):

<pre>
programm >datei 2>&1
</pre>

zur Umleitung von STDOUT und STDERR in die gleiche Datei (Yalu in [http://www.mikrocontroller.net/topic/124509#1135568]).

Beispiel für Windows ([http://www.mikrocontroller.net/topic/124509#1136322], [http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx?mfr=true M$]):

<pre>
avrdude -c avrispmkII -p m8 -P usb:xx -v > "C:\output.txt" 2>&1
</pre>

oder nur STDERR in Datei umleiten:

<pre>
avrdude -c avrispmkII -p m8 -P usb:xx -v 2> "C:\output.txt"
</pre>

=== [http://www.franzis.de/elektronik/lernpakete-elektronik/lernpaket-mikrocontroller Franzis] bzw. [http://www.elo-web.de/elo/mikrocontroller-und-programmierung/avr-grundlagen/experimente-mit-dem-attiny13 ELO] Lernpaket Mikrocontroller (Attiny13) ===

Markus hat in [http://www.mikrocontroller.net/topic/169549#1649459] einen Weg beschrieben, wie man den einfachen Programmieradapter des Lernpakets mit AVRDUDE ansteuern kann.

Eine weitere Anleitung [http://www.elektronik-labor.de/AVR/AVRdude.html LP Mikrocontroller und Attiny45 mit Avrdude] gibt es von Ralf Beesner auf der Webseite des Entwicklers Burkhard Kainka. In ''avrdude.conf'' wird dabei ein neuer Programmieradapter namens ''burkhard'' hinzugefügt. Ein zweiter Eintrag ''burkhard2'' in dieser '''avrdude.conf''' ist für die Programmierung des Atmega8 auf dem Franzis Retro-Pong Bausatz mit Hilfe des "Mega8-ISP-Programmer" (Layout siehe ELO-Webseite) vorgesehen.

=== AVRDUDE mit Arduino Bootloader benutzen ===

Mit der Option ''-c stk500v1'' kann AVRDUDE den [[Bootloader]] in Arduino Boards ansprechen [http://www.mikrocontroller.net/topic/195963#1919654].

Es existieren auch modifizierte Versionen von AVRDUDE, die einen Programmer namens ''arduino'' kennen (avrdude.conf untersuchen!). Damit lautet die Kommandozeile für ein Arduinoboard mit Atmega168 beispielsweise [http://www.neuraladvance.com/2010/04/08/using-avrdude-with-the-arduino-duemilanove/]

<pre>
avrdude -c arduino -p m168 -P usb -U flash:w:<filename>
</pre>

Die Bootloader-Hacks von [http://www.ladyada.net/library/arduino/bootloader.html Ladyada] arbeiten nochmal etwas anders.

Gelegentlich gibt es unter Windows Probleme mit der allgemeinen AVRDUDE Version und deren Handling der DTR/RTS Leitung ([[RS232]]). Es kann helfen unmittelbar von dem Absenden der Kommandozeile einen RESET auf dem Arduinoboard durchzuführen.
Ein kurzes letzen der DTR Leitung auf HIGH bewirkt ein RESET. So ist es möglich eine .bat Datei zu erstellen mit folgendem Code: (com6 ist ein Virtueller USB Comport)
<pre>
mode com6 dtr=on
avrdude -c arduino -p m168 -P \\.\com6 -U flash:w:<filename>
if %ERRORLEVEL%==0 goto fertig
Pause
:fertig
exit
</pre>

== mysmartUSB V2.11 und ATtiny 13 ==

mysmartUSB V2.11 verlangt -cavr910 als Programmer. Leider ist in avrdude
5.10 immer noch nich der ATtiny13 damit zu programmieren. Also in die
avrdude.conf folgendes mit unter ATtiny13 aufnehmen, so kann er dann
korrekt programmiert werden(inkl. Fuse Bits).
<pre>
#------------------------------------------------------------
# ATtiny13
#------------------------------------------------------------

part
id = "t13";
desc = "ATtiny13";
has_debugwire = yes;
flash_instr = 0xB4, 0x0E, 0x1E;
eeprom_instr = 0xBB, 0xFE, 0xBB, 0xEE, 0xBB, 0xCC, 0xB2, 0x0D,
0xBC, 0x0E, 0xB4, 0x0E, 0xBA, 0x0D, 0xBB, 0xBC,
0x99, 0xE1, 0xBB, 0xAC;
stk500_devcode = 0x14;
avr910_devcode = 0x55;
......
</pre>

Achtung! Programmieren geht auch mit -cavr911. Allerdings geht das Fuse
setzen nicht und man bekommt eine Fehlermeldung.(Programm läuft aber)
<pre>
Reading | ################################################## | 100%
0.12s

avrdude: verifying ...
avrdude: 226 bytes of flash verified
avrdude: reading input file "0x7a"
avrdude: writing lfuse (1 bytes):

Writing | ***failed;
################################################## | 100% 0.00s

avrdude: 1 bytes of lfuse written
avrdude: verifying lfuse memory against 0x7a:
avrdude: load data lfuse data from input file 0x7a:
avrdude: input file 0x7a contains 1 bytes
avrdude: reading on-chip lfuse data:

Reading | ################################################## | 100%
0.00s

avrdude: verifying ...
avrdude: 1 bytes of lfuse verified
avrdude: reading input file "0xff"
avrdude: writing hfuse (1 bytes):

Writing | ***failed;
</pre>

== Weblinks ==
* Offizielle AVRDUDE Homepage unter http://www.nongnu.org/avrdude/
* User Manual (engl.) unter http://www.nongnu.org/avrdude/user-manual/avrdude.html#Top
* Kompilierte Windows Version mit USB Support http://yuki-lab.jp/hw/avrdude-GUI/avrdude-5.5-win32-bin.zip
* Kompilierte Windows Version avrdude 5.10 mit USB Support http://www.mikrocontroller.net/topic/163675#1594689
* Wer Interesse an der modifizierten Version von AVRDUDE und des AVR910-Programmer hat, kann sich bei http://www.fischl.de/thomas/elektronik/avr910e/ informieren. Der Programmer bleibt auch mit der Modifikation weiterhin kompatibel zu anderer Programmiersoftware.
* [[Burn-o-mat|AVR Burn-O-Mat]] GUI (Graphic User Interface) für AVRDUDE http://burn-o-mat.net mit FUSE-Editor (Java, für Windows und Linux)
* [http://myavr.de/myForum/viewtopic.php?t=1913 mysmartusb AVR910-Devcodes] für moderne AVRs (Firmware 2.3). Kann zur Anpassung von AVRDUDE in avrdude.conf verwendet werden.
* [http://www.soft-land.de/index.php?page=avrburner AVRBurner] Ponyprog ähnliche Oberfläche für AVRDUDE.
* [http://www.microstar.ir/download/SinaProg.zip SinaProg] SinaProg - avrdude GUI mit AVR Fuse Calculator.

[[Kategorie:AVR-Programmer und -Bootloader]]
[[Kategorie:Entwicklungstools]]

AVR - Die genaue Sekunde / RTC

2009-09-18T13:20:19Z

Jackfritt: /* RTC mit wenig Stromverbrauch */

== Einleitung ==
Oftmals sieht man Projekte, bei denen ein externer RTC-Baustein (engl. '''R'''eal '''T'''ime '''C'''lock, Echtzeituhr; z.B. PCF8583 mit [[I2C]]-Anschluss [http://www-us.semiconductors.philips.com/acrobat/datasheets/PCF8583_5.pdf Datenblatt (PDF)]) angeschlossen ist, ohne dessen Vorteil wirklich zu nutzen.
Der einzige Vorteil einer externen RTC ist nämlich nur, dass man die Zeitzählung während eines Ausfalls der Hauptstromversorgung über eine kleine Stützbatterie bei geringem Strombedarf fortsetzen kann.

Der Strombedarf eines externen RTC ist in der Regel etwas niedriger als die RTC Funktion eines Prozessors. Als Vergleich diene ein DS1302(300nA@2V) zu einem Mega32(5uA@2.7V) als nicht ganz neuer Vertreter, bzw. ein Mega324P(500nA@1.8V) als moderner Vertreter. Dieser Vorteil kommt bei Datenschreibern (engl. data logger) zum Tragen, welche die meiste Zeit inaktiv im [[Sleep Mode]] sind.

In allen anderen Fällen ist die zusätzliche Hardware völlig unnötig und man kann eine präzise Zeitbasis bequem mit dem Hauptquarz des Mikrokontrollers programmieren. Daraus ergeben sich sogar noch zusätzliche Vorteile, wie eine geringere Temperaturabhängigkeit und höhere Güte, die Quarze im MHz-Bereich gegenüber Quarzen im kHz-Bereich besitzen. Ich möchte hiermit die Angst vor dem bisschen Mathematik nehmen, welche zur Berechnung der Teilerfaktoren benötigt wird.

==Lösung==

Speziell für den AVR kommen Quarze im Bereich 1MHz bis 16MHz zum Einsatz, d.h. in einer Sekunde werden 1.000.000 bis 16.000.000 Zyklen durchlaufen (Zyklen pro Sekunde = Frequenz). Möchte man eine Sekunde messen, kann man somit die entsprechende Anzahl Zyklen von Null an hochzählen oder von dem entsprechenden Wert bis auf 0 runterzählen. Für das Zählen bietet sich im µC der Compare-Modus eines Timers an.

Die obigen Zahlen lassen sich jedoch nicht in einer 16 Bit Variablen ausdrücken da sie zu gross sind und somit ist ein direktes Setzen des Compare-Wertes des Timers T1 im AVR nicht möglich. Deshalb unterteilt man die Quarzfrequenz in zwei Faktoren; der erste (Softwareteiler) bestimmt die Periode des Timers T1 und der zweite den Reloadwert eines Registers, welches im Timerinterrupt runtergezählt wird.

==Beispiel==

Im Beispiel AVR wird ein 11,0592-MHz-Quarz verwendet, was einem üblichen [[Baudratenquarz]] entspricht, d.h. damit können die UART-Standardbaudraten erzeugt werden.

Der Softwareteiler wird mit 256 gewählt, d.h. 256 Timerinterrupts pro Sekunde, und kann somit mit nur einem einzigen Byte realisiert werden. Für größere Werte muß der Softwareteiler als int (2 Byte) deklariert werden. Bei kleineren Werten als 256 muss man beachten, dass der zweite Faktor immer noch in 2 Byte passt, um als Comparewert für den 16-Bit-Timer 1 verwendet werden zu können.

Die Timerroutine wird in einer Sekunde Softwareteiler-Mal aufgerufen. Mit diesen 256 Hz ergibt sich eine Timerinterruptzeit von ca. 4ms, die auch sehr gut zum Entprellen von Tasten benutzt werden kann. Eine Entprellroutine kann also bequem in den Timerinterrupt mit eingefügt werden. Beachten muss man nur noch, dass das Nullsetzen des Timers erst einen Zyklus nach dem Comparematch erfolgt. D.h. der Comparewert ist der gewünschte Teilerfaktor minus eins.

==Berechnung==

Die Berechnung des Comparewertes ist sehr einfach:

<c>
Comparewert OCR1A = 11059200 / 256 - 1 = 43199, Rest 0.
</c>

Da haben wir ja noch mal Glück gehabt, es gibt keinen Rest bei der Division und die Sekunde ist exakt
256 * 43200 = 11059200 Zyklen lang. 
Theoretisch. 
Denn selbst wenn auf dem Quarz eine Frequenz von 11,0592 Mhz aufgedruckt ist, so schwingt er doch auf
einer etwas anderen Frequenz. Der Grund dafür sind Fertigungstoleranzen und natürlich die Tatsache,
dass die Frequenz eines Quarzes auch von der Temperatur abhängig ist. Es gilt also zunächst einmal
herauszufinden, auf welcher Frequenz der Quarz wirklich schwingt.

Dazu wird eine Uhr programmiert und mit dem theoretischen Wert laufen gelassen. Nun habe ich die Uhr
einen Tag laufen lassen und festgestellt, dass sie 1,5 s nach geht (Dazu kann man beispielsweise die Tagesschau nutzen, welche jeden Tag um 20:00 (+einer konstanten Zeitverschiebung durch das Übertragungsmedium SAT,DVB-T, ...) beginnt und sogar eine Uhr dabei einblendet). D.h. die Quarzfrequenz beträgt in
Wirklichkeit:
<c>
11059200 * (1 - 1,5 / 24 / 60 / 60) = 11059008 Hz.
</c>
Ausführliche Rechnung:
<c>
(Zyklen in 24h - Zyklen Verspätung) / Sekunden pro 24h = korrekte Frequenz
((24 * 60 * 60 * 256 * 43200) - (1,5 * 256 * 43200)) / (24 * 60 * 60) = 11059008 Hz.
</c>

Also die ganze Rechnung nochmal:
<c>
OCR1A = 11059008 / 256 - 1 = 43198, Rest 64.
</c>
Nun haben wir einen Rest und es würden uns jede Sekunde 64 Zyklen fehlen. Das geht natürlich nicht.

Deshalb wird jedesmal, wenn der Softwareteiler Null ist und die Sekunde weitergezählt wird, ein
anderer Comparewert geladen. Dieser ist dann um den Rest größer. Und beim nächsten Timerinterrupt
wird dann wieder der Comparewert geladen, der das Ergebnis der Division war.

Es ergeben sich somit:
<c>
255 * (43198 + 1) + 1 * (43198 + 64 + 1) = 11059008 Zyklen
</c>
Exakt so, wie wir es wollten.

==Das Programm==

Nachfolgend nun das C-Programm. Da wir ja alle nicht gerne rechnen, lassen wir das einfach den C-Compiler erledigen. D.h. wir brauchen nur noch per Definition für XTAL den entsprechenden Wert eintragen und der Compiler rechnet alle nötigen Konstanten ganz alleine aus.

So ein Compiler ist auch ziemlich faul, der merkt sofort, wenn die Operanden für eine Berechnung alles Konstanten sind. Und ehe er sich damit abquält, extra Code für diese Berechnungen zu erzeugen, rechnet er es lieber selber aus und fügt das Ergebnis direkt in den Code ein.

Der Assembler kann auch 32-Bit Konstanten-Berechnungen ausführen. Allerdings muß man dann die entsprechenden Präprozessoroperationen benutzen. Man könnte auch eine Divisionsroutine aufrufen, aber dann würde ja echter Code erzeugt.

===Beispiel in C===

Wichtig: Ab Ver.1.4.0 haben sich Namen/Funktionen geändert: 

"There are currently two different styles present for naming the vectors. One form uses names starting with SIG_, followed by a relatively verbose but arbitrarily chosen name describing the interrupt vector. This has been the only available style in avr-libc up to version 1.2.x.

Starting with avr-libc version 1.4.0, a second style of interrupt vector names has been added, where a short phrase for the vector description is followed by _vect. The short phrase matches the vector name as described in the datasheet of the respective device (and in Atmel's XML files), with spaces replaced by an underscore and other non-alphanumeric characters dropped. Using the suffix _vect is intented to improve portability to other C compilers available for the AVR that use a similar naming convention...."

Quelle: http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html
<c>
/************************************************************************/
/* */
/* Precise 1 Second Timebase */
/* */
/* Author: Peter Dannegger */
/* danni@specs.de */
/* */
/************************************************************************/
// Target: Mega8, 2313

#include <io.h>
#include <interrupt.h>
#include <signal.h>

#ifndef OCR1A
#define OCR1A OCR1 // 2313 support
#endif

#ifndef WGM12
#define WGM12 CTC1 // 2313 support
#endif

#ifndef PINC
#define KEY_INPUT PIND // 2313
#else
#define KEY_INPUT PINC // Mega8
#endif
#define LED_DIR DDRB

//#define XTAL 11059201L // nominal value
#define XTAL 11059008L // after measuring deviation: 1.5s/d

#define DEBOUNCE 256L // debounce clock (256Hz = 4msec)

#define uchar unsigned char
#define uint unsigned int

uchar prescaler;
uchar volatile second; // count seconds

SIGNAL (SIG_OUTPUT_COMPARE1A)
{
/************************************************************************/
/* Insert Key Debouncing Here */
/************************************************************************/

#if XTAL % DEBOUNCE // bei rest
OCR1A = XTAL / DEBOUNCE - 1; // compare DEBOUNCE - 1 times
#endif
if( --prescaler == 0 ){
prescaler = (uchar)DEBOUNCE;
second++; // exact one second over
#if XTAL % DEBOUNCE // handle remainder
OCR1A = XTAL / DEBOUNCE + XTAL % DEBOUNCE - 1; // compare once per second
#endif
}
}

int main( void )
{
LED_DIR = 0xFF;
while( KEY_INPUT & 1 ); // start with key 0 pressed

TCCR1B = (1<<WGM12) | (1<<CS10); // divide by 1
// clear on compare
OCR1A = XTAL / DEBOUNCE - 1; // Output Compare Register
TCNT1 = 0; // Timmer startet mit 0
second = 0;
prescaler = (uchar)DEBOUNCE; //software teiler

TIMSK = 1<<OCIE1A; // beim Vergleichswertes Compare Match
// Interrupt (SIG_OUTPUT_COMPARE1A)
sei();

for(;;){
if( second == 60 )
second = 0;
PORTB = second; // display second (binary)
}
}
</c>

===Beispiel in Assembler===

<avrasm>
;************************************************************************/
;* */
;* Precise 1 Second Timebase */
;* */
;* Author: Peter Dannegger */
;* danni@specs.de */
;* */
;************************************************************************/
.nolist
.include "m8def.inc"

.equ xtal = 11059008
.equ debounce = 256
.equ remainder = xtal - xtal / debounce * debounce

.def isreg = r15
.def wr0 = r16
.def iwr0 = r17
.def prescaler = r18
.def second = r19

.list
rjmp init
.org OC1Aaddr
rjmp OC1Aint
;-------------------------------------------------------------------------
OC1Aint:
in isreg, sreg
;************************************************************************/
;* Insert Key Debouncing Here */
;************************************************************************/

ldi iwr0, high( xtal / debounce - 1 )
out ocr1ah, iwr0
ldi iwr0, low( xtal / debounce - 1 )
out ocr1al, iwr0

dec prescaler
brne _oci1

ldi prescaler, debounce
inc second

ldi iwr0, high( xtal / debounce + remainder - 1 )
out ocr1ah, iwr0
ldi iwr0, low( xtal / debounce + remainder - 1 )
out ocr1al, iwr0
_oci1:
out sreg, isreg
reti
;-------------------------------------------------------------------------
init:
ldi wr0, 0xFF
out ddrb, wr0
sbic pinc, 0
rjmp init

ldi wr0, high( ramend )
out sph, wr0
ldi wr0, low( ramend )
out spl, wr0

ldi wr0, 1<<WGM12^1<<CS10
out TCCR1B, wr0

ldi wr0, high( xtal / debounce - 1 )
out ocr1ah, wr0
ldi wr0, low( xtal / debounce - 1 )
out ocr1al, wr0
out tcnt1l, wr0
ldi prescaler, debounce

ldi wr0, 1<<OCIE1A
out TIMSK, wr0
sei
main:
ldi second, 0
_mai1:
cpi second, 60
breq main
out ddrb, second
rjmp _mai1
;------------------------------------
</avrasm>

===Verbesserte Version mit durchlaufendem Hardwarezähler===

Hier sind trotzdem kleine Verbesserungsvorschläge.

Wird im Timer die Option "Clear On Compare Match" verwendet, so verliert man den Overflow Interrupt. Oder möchte man nebenher noch eine Zeit mit dem Capture Interrupt messen, so benötigt man einen durchlaufenden Timer. Um dies zu erreichen, wird OCR1A nicht fest eingestellt, sondern bei jedem Aufruf um den gleichen Wert erhöht.

In Peters Code wurde der Rest auf einmal abgearbeitet. Damit erspart man sich bei jedem Interrupt einen Vergleich und die Verarbeitungszeit verkürzt sich in seinem Code. Der Unterschied zwischen kurzem und langem Interrupt ist hier der Rest. Bei den geänderten Codeschnipseln wird der Rest gleichmäßiger abgearbeitet. Der Unterschied zwischen kurzem und langem Interrupt beträgt 1 Takt.

ungetesteter Code für den durchlaufenden Timer:

<c>
SIGNAL (SIG_OUTPUT_COMPARE1A) {
/************************************************************************/
/* Insert Key Debouncing Here */
/************************************************************************/

if( --prescaler == 0 ){
prescaler = (uchar) DEBOUNCE;
second++; // exact one second over
}
#if XTAL % DEBOUNCE
if (prescaler <= XTAL % DEBOUNCE)
OCR1A += XTAL / DEBOUNCE +1; /* um 1 Takt längere Periode um den Rest abzutragen */
else
#endif
OCR1A += XTAL / DEBOUNCE; /* kurze Periode */
}
</c>

===Durchlaufender Hardwarezähler und fortlaufende Addition===

Gänzlich ohne Hin- und Hertogglen eines Bits kommt man aus, wenn irgendein Timer mit einer Überlauf-Interruptfrequenz > 1Hz arbeitet. Dann kann die ISR eine 32-bit-Konstante auf einen 32-bit-Akkumulator addieren; bei Überlauf ist eine Sekunde vergangen. Zugegeben, es gibt "lange" und "kurze" Sekunden, aber der Fehler summiert sich nicht, und der Code ist sehr einfach.

Hier ein Beispiel:

Es gibt ein Programm gettick(), das einen Wert holt. Dieser Wert wird von Zeit zu Zeit von der Hardware (Beispiel AVR: der Timer) oder dem Betriebssystem (Beispiel Linux: gettick ruft getmsec, getmsec ruft gettimeofday)

Dieser aufgerufene Wert sollte pro Sekunde um TICKPERSEC erhöht werden, was aber mit einer gewissen Ungenauigkeit geschieht.

Die Laufzeitkorrektur wird dadurch ausgeführt, dass der von gettick() zurückgegebene Wert mit einem Faktor TFAK multipliziert wird. Der Faktor sollte so gewählt werden, dass:

* Das Ergebnis actual_value immer in 32 Bit hineinpasst.
* Die Multiplikation durch Schiebeopertionen ersetzt werden kann, weil der Faktor eine 2-er-Potenz ist. (Das erledigt avr-gcc)

Immer wenn tsdaytim_calibrated() erkennt, dass eine Sekunde vergangen, wird last_value um die Zahl onesecond erhöht.

Der Zahlenwert onsecond wird mit TICKPERSEC*TFAK initalisiert und kann angezeigt oder neu eingegeben werden (Die Bedienung der seriellen Schnittstelle hierfür ist in diesem Beispiel nicht enthalten).

Wenn festgestellt wird, dass die Uhr pro Zeit (P) um (E) zu schnell geht, dann kann der Wert onsecond korrigiert werden.

c = d * (P+E)/P
Beispiel Pro 7 Tage 120 Sekunden zu viel:

7 Tage = 7*86400= 604800 sekunden
c = 992000000 * (604800+120)/604800=991803175
Dann wird die Uhr genauer gehen.

<c>
/****************************************************************/
/* File home/cc/qq/danclock.cpp */
/* Precise 1 Second Timebase */
/* */
/* Author: Peter Dannegger / Hjherbert */
/* danni@specs.de */
/* */
/****************************************************************/
// Target: atmega8, (2313?)

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

#ifndef OCR1A
#define OCR1A OCR1 // 2313 support
#endif

#ifndef WGM12
#define WGM12 CTC1 // 2313 support
#endif

#ifndef PINC
#define KEY_INPUT PIND // 2313
#else
#define KEY_INPUT PINC // Mega8
#endif

//#define F_CPU 11059201L // nominal value

#define DIVISOR 256

#define TICKPERSEC (F_CPU/DIVISOR)

uint8_t volatile second; // count seconds

// TFAK ? TICKPERSEC must not exceed 2^32
#define TM (0x7FFFFFFFUL/2/TICKPERSEC) // max of TFAK

#define TFAK ( ( (TM>>1) | (TM>>2) | (TM>>3) | (TM>>4) | (TM>>5) | (TM>>6) | (TM>>7) \
| (TM>>8) | (TM>>9) | (TM>>10) | (TM>>11) | (TM>>12) | (TM>>13) | (TM>>14) | (TM>>15) \
| (TM>>16) | (TM>>17) | (TM>>18) | (TM>>19) | (TM>>20) | (TM>>21) | (TM>>22) | (TM>>23) \
| (TM>>24) | (TM>>25) | (TM>>26) | (TM>>27) | (TM>>28) | (TM>>29) | (TM>>30) | (TM>>31) \
) + 1 )
// TFAK is a power the biggest power of two which is less than TM

uint32_t onesecond = 1*TICKPERSEC*TFAK ; // correct this value if see the clock is late / too fast
uint32_t last_value ;
uint32_t ticks ;

SIGNAL (SIG_OUTPUT_COMPARE1A)
{
++ticks ;
}

uint32_t gettick( void )
{
uint32_t l ;
cli();
l = ticks ;
sei();
return l ;
}

void tsdaytim_calibrated(void)
// Keep the time-of-the-day actual
// Add a second, if a second if gone
{
uint32_t actual_value ; // gettick() multiplied by factor 2^n

actual_value = gettick() * TFAK ; // because TFAK is a power of two
// The compiler will create some shift commands

if ( actual_value - last_value > onesecond )
{ // once per second
if ( ++second >= 60 )
{
second = 0 ;
}
last_value += onesecond ; // One second more
}
}

int main( void )
{
DDRB = 0xFF;
while( KEY_INPUT & 1 ); // start with key 0 pressed

TCCR1B = 1<<WGM12^1<<CS10; // divide by 1
// clear on compare
OCR1A = DIVISOR ; // Output Compare Register
TCNT1 = 0; // Timer start value
second = 0;

TIMSK = 1<<OCIE1A; // beim Vergleichswertes Compare Match
// Interrupt (SIG_OUTPUT_COMPARE1A)
sei();
last_value = gettick() * TFAK ;
for(;;)
{
tsdaytim_calibrated();
PORTB = second; // display second (binary)
}
}

</c>

== Echtzeituhr mit Uhrenquarz ==

=== RTC mit wenig Stromverbrauch ===

Das vorgestellte Verfahren ist leider nicht direkt anwendbar, wenn man eine RTC mit einem 32,768 KHz Uhrenquarz realisieren möchte. Dieser Weg ist dann notwendig, wenn der Controller [[Ultra low power | batteriebetrieben]] sehr lange laufen soll und durch Verwendung des [[Sleep Mode]] Strom gespart wird.

=== Begrenzung der Auflösung ===

Wo liegt das Problem? Das obige Verfahren nutzt recht hochfrequente Quarze mit 1 MHz und mehr. Wenn man die Frequenz eines Quarzes von 1 MHz = 1.000.000 Hz mit einer [[Auflösung und Genauigkeit| Auflösung]] von 1 Hz angibt, entspricht das einem maximalen Fehler von 1/1.000.000 oder 1ppm (engl. parts per million, millionstel Teil). Das ist sehr wenig. Eine RTC mit einem Fehler von 1ppm hat eine Gangabweichung von 86,4ms pro Tag, oder 2,5s pro Monat. Das ist ein sehr guter Wert. Wenn ich nun aber die Frequenz 32768 Hz mit 1 Hz Auflösung angebe, ist das schlimmstenfalls ein Fehler von 1/32768 = 30,5ppm, was einer Abweichung von 2,5s pro Tag und 75s pro Monat entspricht!

=== Uhrentakt genau messen und digital korrigieren ===

Wie kann man das Problem lösen? Die AVRs können im [[Sleep Mode]] den Uhrenquarz nur am Timer 2 betreiben, welcher ein 8 Bit Timer ist. D.H. ein Überlauf passiert alle 256 Takte, sprich 7,8125ms (=128 Hz). Man kann auch einen Prescaler verwenden, welcher das Problem aber nicht löst.

Wie bereits festgestellt, müssen wir die Frequenz des 32768Hz Uhrenquarzes genauer messen und darstellen. Wir wollen hier annehmen, dass wir die Frequenz auf 0,001Hz = 1mHz (Millihertz) auflösen, ein guter Frequenzzähler kann das problemlos und ist auch so [[Auflösung und Genauigkeit|'''genau''']]. Wir können beispielsweise feststellen, dass ein Quarz mit 32768,423Hz schwingt, das entspricht einem Fehler von

<math>F_r=(\frac{f_{ist}}{f_{soll}} -1 )\cdot 10^6=(\frac{32768,423}{32768} -1 )\cdot 10^6=12,9ppm</math>

Dabei ist zu beachten, daß diese Messung '''nicht''' direkt am Quarz erfolgen darf, auch nicht mit kapazitätsarmen 10:1 Tastköpfen! Denn so ein Quarz wird von kleinsten Kapazitäten im Bereich von weniger als ein pF messbar verstimmt. Darum muss man in so einem Fall den Uhrentakt auf ein anderes IO-Pin ausgeben und dort messen. Beim [[MSP430]] ist das einfach, man kann ACLK auf ein Pin direkt ausgeben. Der [[AVR]] kann das leider nicht. Hier muss man zu einem Trick greifen. Man benutzt die Output Compare Funktion, um mit Timer 2 einen 128 Hz Takt zu erzeugen. Dieser ist fest mit dem Uhrentakt verbunden und kann anstellte dessen gemessen werden, ohne den Quarz zu verstimmmen. Die Messung ergibt in diesem Fall eine Frequenz von 128,00165 Hz.

OK, jetzt haben wir den Takt gemessen, wir wissen, daß pro Sekunde 128 Timerüberläufe passieren (Prescaler =1). Wir wissen, dass unser Quarz pro Sekunde um 0,423 Takte zu schnell ist. Wir können aber keine halben Takte mehr oder weniger zählen? Doch! Mit [[Festkommaarithmetik]]! Denn nach 1000s ist unser Quarz um 423 Takte zu weit gelaufen und muss um diese Anzahl zurückgestellt werden. Also könnte man im ersten Ansatz nach 1000 Sekunden den Timer 2 um diesen Betrag korrigieren. Das Problem dabei ist nur, dass der Zähler nur 8 Bit breit ist. Ein Addieren oder Subtrahieren von 423 würde mehrfache Überläufe verursachen, welche programmtechnisch nur schwer zu handhaben wären. Also muss eine etwas bessere Methode her.

=== Bresenham für RTCs ===

Wenn man sich die Idee der [[Festkommaarithmetik]] mal eine Weile durch den Kopf gehen lässt, kommt man vielleicht auf folgende Idee. Der Frequenzfehler beträgt in unserem Beispiel 0,423 Hz, also Takte pro Sekunde. Oder aber 423 Tausendstel Takte pro Sekunde. Nach drei Sekunden sind es schon 1,269 Takte oder 1269 Tausendstel Takte. Moment! '''Einen''' Takt können wir korrigieren, indem wir den Zähler um 1 Takt zurück setzen. Den Restfehler von 269 Tausendstel merken wir uns und akkumulieren weiter. Wenn dann wieder die 1000er Marke überschritten wird machen wir das Gleiche. Analog dazu natürlich auch bei negativem Vorzeichen, sprich wenn der Quarz zu langsam schwingt wird er um einen Takt vorgestellt. É Voilà! Dieses Verfahren ist sehr ähnlich zum [http://de.wikipedia.org/wiki/Bresenham-Algorithmus Bresenham-Algorithmus] zum Zeichnen von Linien auf Computermonitoren.

=== Beispielprogramm ===

Das folgende Beispiel stellt eine RTC mit sehr niedrigem Stromverbrauch zur Verfügung. Laut Datenblatt beträgt die Stromaufnahme nur ca. 6µA bei 3V Versorgungsspannung, besser als einige kommerzielle RTCs! Möglich macht das die Nutzung des Power Save [[Sleep Mode]]s. Die Frequenz kann auf <math>10^{-5}</math> Hz genau abgeglichen werden, was in diesem Fall bei einer Messfrequenz von 128Hz einer Auflösung von 0,078ppm entspricht. Das bedeutet eine Abweichung von 6,7ms pro Tag, 0,2s pro Monat oder 2,46s pro Jahr!

Die Abweichung des Quarzes wird in einer vorzeichenbehafteten 16 Bit Variable in der Einheit <math>10^{-3}</math> Hz gespeichert. D.h. es kann ein Frequenzfehler von +/- 32,768 Hz korrigiert werden, das sind 1000ppm! Normale Quarze haben Abweichungen von max. 100ppm, meist viel weniger. Jede Sekunde wird der Frequenzfehler neu berechnet und in den darauffolgenden 128 Interrupts ggf. mehrfach korrigiert. Wichtig ist dabei, dass die Korrektur wirklich ganz am Anfang der ISR steht, weil hier das Timing wirklich kritisch ist. Denn innerhalb eines Uhrenquarztaktes von ~30us muss der Timer 2 neu beschrieben werden. Bei 1 MHz RC-Oszillatortakt sind das nur 30 Takte, wovon 6 zum Aufwachen und 4 zum Anspringen der ISR benötigt werden. Dazu kommen noch das Sichern einiger Register am Anfang der ISR, was man im C nicht direkt sieht. Sicherheitshalber sollte man auch einen höheren Takt einstellen, z.B. 2 MHz, dann ist das Timing wesentlich entspannter.

<c>
/*
************************************************************************
*
* Stromsparende Echtzeituhr mit 32768Hz Uhrenquarz
*
* ATmega88 mit internem 2 MHz Oszillator + 32,768 kHz Quarz
*
* Fuses bleiben auf Standardeistellungen
* LOW Fuse Byte = 0x62
* HIGH Fuse Byte = 0xDF
* EXT Fuse Byte = 0xF9
*
* LED mit 1K Vorwiderstand an PB5
* Kalibriertaktausgang an PB3
************************************************************************
*/

#define F_CPU 2000000L // Systemtakt in Hz
#define F_CAL 12800000L // gemessener Kalibriertakt in 10^-5 Hz
// Endung L ist wichtig!

#define LED_TOGGLE PORTB ^= (1<<PB5);

#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include <util/delay.h>

// EEPROM Daten

int16_t ee_rtc_cal EEMEM = (F_CAL-12800000)*256/100; // Kalibrierung für RTC, Frequenzfehler in 1/1000 Hz

// globale Variablen

// beidseitiger Zugriff durch ISR und Hauptprogramm

volatile uint32_t time; // 24h Zeitstempel, 1s Auflösung
volatile int16_t rtc_cal; // Kalibrierung des 32K Quarzes
volatile uint8_t flag_1s; // Flag für 1s Intervall

void long_delay(uint16_t ms) {
for (; ms>0; ms--) _delay_ms(1);
}

int main (void) {

// Clock divider auf /4

CLKPR = 0x80; // update enable
CLKPR = 2; // Prescaler /4

// IO konfigurieren

DDRB = (1<<PB3) | (1<<PB5);
PORTB = ~((1<<PB3) | (1<<PB5)); // Pull ups
PORTC = 0xFF;
PORTD = 0xFF;

// Analogcomparator ausschalten

ACSR = 0x80;

// Timer2 konfigurieren

ASSR = (1<< AS2); // Timer2 asynchron takten
long_delay(1000); // Einschwingzeit des 32kHz Quarzes
TCCR2A = (1<<COM2A1) | (1<<WGM21) | (1<<WGM20); // Fast PWM, non inverted
TCCR2B = 1; // Vorteiler 1 -> 7,8ms Überlaufperiode
OCR2A = 128; // PWM, Tastverhältnis 50%
while((ASSR & (1<< TCR2BUB))); // Warte auf das Ende des Zugriffs
TIFR2 &= ~(1<<TOV2); // Interrupts löschen
TIMSK2 |= (1<<TOIE2); // Timer overflow Interrupt freischalten

// EEPROM Werte auslesen

rtc_cal= eeprom_read_word(&ee_rtc_cal);

// Interrupts freigeben

sei();

// Endlose Hauptschleife

while(1) {

while((ASSR & (1<< OCR2AUB))); // Warte auf das Ende des Zugriffs
set_sleep_mode(SLEEP_MODE_PWR_SAVE);
sleep_mode(); // in den Schlafmodus wechseln

// hier wachen wir wieder auf, nach Ausführung des 7,8ms Timerinterupt

if (flag_1s) {
flag_1s =0;
LED_TOGGLE // Test
}

}
}

// Timer2 overflow Interrupt

ISR(TIMER2_OVF_vect) {
static uint8_t ticks; // Hilfsvariable für Messintervall
static int16_t time_error; // RTC Fehlerkompensation

// Zeitkritische Dinge, welche am Anfang der ISR stehen müssen!

OCR2A=128; // Dummy-Write zur Sicherung des Timings
// von Timer 2 im asynchronen Modus

// RTC Fehler korrigieren

if (time_error>999) { // RTC zu schnell
TCNT2 = 2; // Zähler einen Schritt zurück setzen (2 Takte Verzögerung!)
time_error -= 1000;
} else if (time_error<-999) { // RTC zu langsam
TCNT2 = 4; // Zähler einen Schritt vor setzen (2 Takte Verzögerung!)
time_error += 1000;
}

// ab hier ist es nicht mehr zeitkritisch

// Echtzeituhr
ticks++; // 1/128tel Sekunde
if (ticks==128) { // Sekundenintervall
time_error += rtc_cal; // RTC Fehler akkumulieren

// 24h Timer
time++;
if (time==86400) time=0; // 24h Überlauf

ticks=0;
flag_1s =1; // setzte Flag für 1s Verarbeitung in main Endlosschleife
}
}
</c>

=== Weitere Verbesserungen ===

Der Algorithmus ermöglicht eine sehr hochauflösende Kalibrierung der RTC. Allerdings heisst das leider noch lange nicht, daß die RTC dann auch wirklich so genau ist. Denn diese Kalibrierung gilt nur für eine exakte Temperatur! Auch ein Quarz hat eine Temperaturabhängigkeit der Schwingfrequenz. Wenn man nun eine sehr genaue RTC bauen möchte, welche über einen grossen Temperaturbereich genau läuft, muss man periodisch die Temperatur messen und in die Kalibrierung einbeziehen. Einen typischen Temperaturverlauf des Frequenzfehlers zeigt das folgende Bild.

[[bild:rtc_tk.gif|thumb|260px|left|Temperaturgang eines Uhrenquarzes]]
 

Weiterhin kann man natürlich die Kalibrierung ohne erneutes Kompilieren des Quelltextets vornehmen, indem man den Kalibrierwert per [[UART]] oder [[I2C]] an den AVR sendet und im [[Speicher#EEPROM | EEPROM]] speichert.

Kernpunkt der Kalibrierung ist natürlich die Messung der realen Quarzfrequenz. Die oben beschriebene Methode per Tagesschau und 1 Tag warten ist sehr zeitaufwändig und hat eine begrenzte Genauigkeit von ca. 1/2 Sekunde, das entspricht 5,8ppm. Hier muss zwangsläufig ein guter Frequenzzähler her. Da dieser nicht jedem Hobbybastler zur Verfügung steht, muss man sich in Lehrwerkstätten, Universitäten oder Firmen im Elektronikbereich umsehen und nachfragen, ob man einen Frequenzzähler vor Ort kurze Zeit nutzen kann.

== Links ==

* [http://www.maxim-ic.com/appnotes.cfm/an_pk/617 Real-Time-Clock Selection and Optimization, MAXIM Application Note (engl.)]
*[http://www.mikrocontroller.net/articles/Uhr Implementierung einer Uhr mit Siebensegmentausgabe auf einem AVR ATTiny2313]

[[Category:AVR]]
[[Category:Timer und Uhren]]

AVR-Tutorial: Mehrfachverzweigung

2009-09-18T13:02:28Z

Jackfritt: /* Lange Sprungtabelle */

== Einleitung ==

Oft ist es in einem Programm notwendig, eine Variable auf mehrere Werte zu prüfen und abhängig vom Ergebnis verschiedene Aktionen auszulösen. Diese Konstruktion nennt man Mehrfachverzweigung. In einem Struktogramm sieht das so aus.

[[bild:mv_struktogramm.png|350px]]

In C gibt es direkt dafür eine Konstruktion namens '''switch'''.

<c>
switch (variable) {
case 1: // Anweisungen für diesen Zweig, wenn variable == 1
break;
case 17: // Anweisungen für diesen Zweig, wenn variable == 17
break;
case 33: // Anweisungen für diesen Zweig, wenn variable == 33
break;
case 9: // Anweisungen für diesen Zweig, wenn variable == 9
break;
case 22: // Anweisungen für diesen Zweig, wenn variable == 22
break;
default: // Anweisungen wenn keine der oben definierten Bedingungen erfüllt ist
break;
}
</c>

In Assembler muss man so etwas "zu Fuß" programmieren. Die verschiedene Lösungen sollen hier betrachtet werden.

== Einfacher Ansatz ==

Im einfachsten Fall verwendet man eine lange Kette von '''cpi''' und '''breq''' Befehlen. Für jeden Zweig benötigt man zwei Befehle.

<avrasm>
; Mehrfachverzeigung Version A

; Einfacher Ansatz, mit vielen CPI

start_vergleich:

cpi r16,1
brne zweig_0

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=1

rjmp ende_vergleich
zweig_0:
cpi r16,17
brne zweig_1

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=17

rjmp ende_vergleich
zweig_1:
cpi r16,33
brne zweig_2

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=33

rjmp ende_vergleich
zweig_2:
cpi r16,9
brne zweig_3

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=9

rjmp ende_vergleich
zweig_3:
cpi r16,22
brne kein_Treffer

; hier stehen jetzt alle Anweisungen für diesen Zweig r16=22

rjmp ende_vergleich
kein_Treffer:

; hier stehen jetzt alle Anweisungen für den Fall, dass keiner der Vergleiche erfolgreich war

ende_vergleich:

rjmp ende_vergleich ; nur für Simulationszwecke! ENTFERNEN!
</avrasm>
'''Eigenschaften'''
* Programmspeicherbedarf: 6*N Bytes (N = Anzahl der Zweige)

'''Vorteile'''
* leicht verständlich
* Es können beliebige Vergleichswerte geprüft werden

'''Nachteile'''
* relativ hoher Programmspeicherbedarf
* die Größe der Zweige ist stark begrenzt, weil der Befehl '''breq''' maximal 63 Worte weit springen kann!
* die einzelnen Zweige haben unterschiedliche Durchlaufzeiten, der letzte Zweig ist am langsamsten
* nur bedingt übersichtlicher Quellcode

== Sprungtabelle ==

Oft liegen die einzelnen Vergleichswerte nebeneinander (z.B. 7..15), z.B. bei der Übergabe von Parametern, Zustandsautomaten, Menueinträgen etc. . In so einem Fall kann man mittels einer '''Sprungtabelle''' das Programm verkürzen, beschleunigen und übersichtlicher gestalten.

<avrasm>
.include "m8def.inc"

; Mehrfachverzweigung Version B

; Clevere Version mit Sprungtabelle
; minimum und maximum sind auf 0..255 begrenzt!

.equ minimum = 3
.equ maximum = 7

start_vergleich:

subi r16,minimum ; Nullpunkt verschieben
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
ldi ZL,low(Sprungtabelle) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle)
add ZL,r16 ; Index addieren, 16 Bit
ldi r16,0
adc ZH,r16
ijmp ; indirekter Sprung in Sprungtabelle

kein_treffer:

; hier stehen jetzt alle Anweisungen für den Fall, dass keiner der Vergleiche erfolgreich war

rjmp ende_vergleich

Sprungtabelle:
rjmp zweig_0
rjmp zweig_1
rjmp zweig_2
rjmp zweig_3
rjmp zweig_4

zweig_0:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

zweig_1:

; hier stehen jetzt alle Awneisungen für diesen Zweig

rjmp ende_vergleich

zweig_2:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

zweig_3:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

zweig_4:

; hier stehen jetzt alle Anweisungen für diesen Zweig

rjmp ende_vergleich

ende_vergleich:

; hier geht das Programm weiter

rjmp ende_vergleich ; nur für Simulationszwecke! ENTFERNEN!
</avrasm>

''' Programmbeschreibung ''' 
Wie ist dieses Programm nun zu verstehen? Das Prinzip beruht darauf, daß in einer gleichmässigen Tabelle Sprungbefehle auf einzelne Programmzweige abgelegt werden. Das ist praktisch genauso wie der AVR [[AVR-Tutorial: Interrupts | Interrupts]] verarbeitet. Über einen Index (0...N) wird ein Sprungbefehl ausgewählt und ausgeführt.Der entscheidende Befehl dazu ist '''ijmp'''.

Zunächst muss der Wertebereich, auf welchen die Variable geprüft werden soll (minimum bis maximum), normiert werden (0 bis (Maximum-Minimum)). Dazu wird einfach das Minimum subtrahiert.

<avrasm>
subi r16,minimum ; Nullpunkt verschieben
</avrasm>

Danach muss geprüft werden, ob der maximale Index nicht überschritten wird. Denn ein Sprung auf nichtexistierende Einträge oberhalb der Sprungtabelle wäre fatal!

<avrasm>
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
</avrasm>

Danach muss der indirekte Sprung vorbereitet werden. Dazu wird die Adresse der Sprungtabelle in das Z-Register geladen, welches ein 16 Bit Register ist und gleichbedeutend mit r30 und r31.

<avrasm>
ldi ZL,low(Sprungtabelle) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle)
</avrasm>

Danach muss der Index addiert werden, dies ist eine 16-Bit Addition.

<avrasm>
add ZL,r16 ; Index addieren, 16 Bit
ldi r16,0
adc ZH,r16
</avrasm>

Zu guter Letzt wird der indirekte Sprung in die Sprungtabelle ausgeführt.

<avrasm>
ijmp ; indirekter Sprung in Sprungtabelle
</avrasm>

In der Sprungtabelle wird dann zum jeweiligen Zweig verzweigt.
<avrasm>
Sprungtabelle:
rjmp zweig_0
rjmp zweig_1
rjmp zweig_2
rjmp zweig_3
rjmp zweig_4
</avrasm>

Der Zweig für einen ungültigen Index folgt direkt nach dem '''ijmp''', weil der Befehl '''brsh''' nur maximal 63 Worte weit springen kann.

'''Eigenschaften'''
* Programmspeicherbedarf: 2*N +18 Bytes (N = Anzahl der Zweige)
* maximale Gesamtgröße der Zweige wird durch den Befehl rjmp begrenzt (+/-4kB). Das sollte aber nur in sehr wenigen Fällen ein Problem sein (Man wird kaum einen AVR mit 8 kB FLASH mit einer einzigen Mehrfachverzweigung füllen!)

'''Vorteile'''
* relativ niedriger Programmspeicherbedarf
* die einzelnen Zweige haben unabhängig von der Grösse der Sprungtabelle eine konstante und kurze Durchlaufzeit von 12 Takten.
* übersichtlicher Quellcode

'''Nachteile'''
* Die Vergleichswerte müssen lückenlos aufeinander folgen

== Lange Sprungtabelle ==
Wenn man doch mal eine GIGA-Mehrfachverzweigung braucht, dann hilft die Version C.

<avrasm>
.include "m16def.inc"

; Mehrfachverzweigung Version C

; Clevere Version mit langer Sprungtabelle
; funktioniert nur mit AVRs mit mehr als 8KB FLASH
; minimum und maximum sind auf 0..127 begrenzt!

.equ minimum = 3
.equ maximum = 7

start_vergleich:

subi r16,minimum ; Nullpunkt verschieben
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
ldi ZL,low(Sprungtabelle*2) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle*2)
lsl r16 ; Index mit 2 multiplizieren
add zl,r16 ; Index addieren, 16 Bit
ldi r16,0
adc zh,r16
lpm r16,Z+ ; Low Byte laden und Pointer erhöhen
lpm ZH,Z ; zweites Byte laden
mov ZL,r16 ; erstes Byte in Z-Pointer kopieren
ijmp ; indirekter Sprung

kein_treffer:

; hier stehen jetzt alle Anweisungen für den Fall, dass keiner der Vergleiche erfolgreich war

jmp ende_vergleich

Sprungtabelle:
.dw zweig_0
.dw zweig_1
.dw zweig_2
.dw zweig_3
.dw zweig_4

zweig_0:

; hier stehen jetzt alle Anweisungen für diesen Zweig

jmp ende_vergleich

zweig_1:

; hier stehen jetzt alle Awneisungen für diesen Zweig

jmp ende_vergleich

zweig_2:

; hier stehen jetzt alle Anweisungen für diesen Zweig

jmp ende_vergleich

zweig_3:

; hier stehen jetzt alle Anweisungen für diesen Zweig

jmp ende_vergleich

zweig_4:

; hier stehen jetzt alle Anweisungen für diesen Zweig

ende_vergleich:

; hier geht das Programm weiter

jmp ende_vergleich ; nur für Simulationszwecke! ENTFERNEN!
</avrasm>

''' Programmbeschreibung ''' 
Diese Version ist der Version B sehr ähnlich. Der Unterschied besteht darin, daß in Version B die Sprungtabelle mit Sprungbefehlen gefüllt ist (rjmp) während in Version C die Startadressen der Funktionen ablegt sind. D.H. man kann nicht in die Sprungtabelle springen, sondern muss sich mit Hilfe des Index die richtige Adresse aus der Sprungtabelle lesen und mit '''ijmp''' anspringen. Klingt sehr ähnlich, ist aber dennoch verschieden.

Die ersten drei Befehle sind identisch, es wird der Index normiert und auf das Maximum geprüft.
<avrasm>
subi r16,minimum ; Nullpunkt verschieben
cpi r16,(maximum-minimum+1) ; Index auf Maximum prüfen
brsh kein_Treffer ; Index zu gross -> Fehler
</avrasm>
Die nächsten zwei Befehle laden wieder die Anfangsadresse der Sprungtabelle. Doch halt, hier wird die Adresse der Sprungtabelle mit zwei multipliziert. Des Rätsels Lösung gibt es weiter unten.
<avrasm>
ldi ZL,low(Sprungtabelle*2) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle*2)
</avrasm>
Der Index wird ebenfalls mit zwei multipliziert.
<avrasm>
lsl r16 ; Index mit 2 multiplizieren
</avrasm>
Danach erfolgt eine 16-Bit Addition.
<avrasm>
add zl,r16 ; Index addieren, 16 Bit
ldi r16,0
adc zh,r16
</avrasm>
Nun zeigt unser Z-Zeiger auf den richtigen Tabelleneintrag. Jetzt müssen zwei Bytes aus dem FLASH geladen werden. Das geschieht mit Hilfe des '''lpm'''-Befehls ('''L'''oad '''P'''rogram '''M'''emory). Hier wird die erweiterte Version des lpm-Befehls verwendet, wie sie nur auf grösseren AVRs verfügbar ist. Dabei wird ein Byte in Register r16 geladen und gleichzeitig der Z-Pointer um eins erhöht. Damit zeigt er wunderbar auf das nächste Byte, welches auch geladen werden muss.
<avrasm>
lpm r16,Z+ ; Low Byte laden und Zeiger erhöhen
</avrasm>
Der zweite lpm-Befehl ist etwas ungewöhnlich, denn er überschreibt einen Teil des Z-Pointers! In den meisten Programmen wäre das ein Schuss ins Knie (Programmierfehler!), da wir aber den Z-Pointer danach sowieso mit neuen Daten laden ist das OK.
<avrasm>
lpm ZH,Z ; zweites Byte laden
</avrasm>
Das zuerst gelesene Byte wird in den Z-Pointer kopiert. Nun steht die Startadresse des gewählten Zweigs im Z-Pointer.
<avrasm>
mov ZL,r16 ; erstes Byte in Z-zeiger kopieren
</avrasm>
Zu guter Letzt wird der indirekte Sprung ausgeführt und bringt uns direkt in den Programmzweig.
<avrasm>
ijmp ; indirekter Sprung direkt in den Programmzweig
</avrasm>

Der Zweig für einen ungültigen Index folgt direkt nach dem '''ijmp''', weil der Befehl '''brsh''' nur maximal 63 Worte weit springen kann.

'''Eigenschaften'''
* Programmspeicherbedarf: 2*N +26 Bytes (N = Anzahl der Zweige)
* unbegrenzte Sprungweite

'''Vorteile'''
* relativ niedriger Programmspeicherbedarf
* die einzelnen Zweige haben unabhängig von der Grösse der Sprungtabelle eine konstante und kurze Durchlaufzeit von 18 Takten
* übersichtlicher Quellcode

'''Nachteile'''
* Die Vergleichswerte müssen lückenlos aufeinander folgen
* geringfügig höherer Programmspeicherbedarf (8 Byte mehr) und grössere Durchlaufzeit (6 Takte mehr)als Version B

== Z-Pointer leicht verständlich ==

Auf den ersten Blick scheint es sonderbar, daß Version B die Adresse der Sprungtabelle direkt lädt, während Version C sowohl Anfangsadresse als auch Index mit zwei multipliziert. Warum ist das so?

Version B verwendet nur den Befehl '''ijmp'''. Dieser erwartet im Z-Register eine Adresse zur Programmausführung, eine '''Wort-Adresse'''. Da der Programmspeicher des AVR 16 Bit breit ist (=1 Wort = 2 Bytes), werden nur Worte adressiert, nicht jedoch Bytes! Genauso arbeitet der Assembler. Jedes Label entspricht einer Wort-Adresse. Damit kann man mit einer 12 Bit-Adresse 4096 Worte adressieren (=8192 Bytes). Wenn man sich die Befehle der einzelnen AVRs anschaut wird klar, daß alle AVRs mit 8KB und weniger FLASH nur die Befehle rjmp und rcall besitzen. Denn sie brauchen nicht mehr! (Hinweis: Der Atmega8 besitzt die Befehle ijmp und icall).

Mit 12 Adressbits, welche direkt in einem Wort im Befehl rjmp bzw. rcall kodiert sind, kann der gesamte Programmspeicher erreicht werden. Größere AVRs besitzen call und jmp, dort ist die Adresse als 22 bzw. 16 Bit Zahl kodiert, deshalb brauchen diese Befehle auch 2 Worte Programmspeicher.

Der Befehl '''lpm''' dient zum Laden einzelner Bytes aus dem Programmspeicher. Das ist vor allem für Tabellen mit konstanten Werten sehr nützlich (7-Segmentdekoder, Zeichensätze, Kennlinien, Parameter Texte, etc.) Doch wie kommt man nun in dem wortweise adressierten Programmspeicher an einzelne Bytes? Ganz einfach. Der AVR "mogelt" hier und erwartet im Z-Register eine '''Byte-Adresse'''. Von dieser Adresse bilden die Bits 15..1 die Wortadresse, welche zur Adressierung des Programmspeichers verwendet wird. Bit 0 entscheidet dann, ob das hoch- oder niederwertige Byte in das Zielregister kopiert werden soll (0=niederwertiges Byte; 1=höherwertiges Byte).

Darum muss bei Verwendung des Befehls lpm die Anfangsadresse immer mit zwei multipliziert werden.
<avrasm>
ldi ZL,low(Sprungtabelle*2) ; Tabellenzeiger laden, 16 Bit
ldi ZH,high(Sprungtabelle*2)
</avrasm>
In Version C muss zusätzlich der Index mit zwei multipliziert werden, weil jeder Tabelleneintrag (Adresse des Programmzweigs) ein Wort breit ist. Damit wird aus einem Index von 0,1,2,3,4 ein Offset von 0,2,4,6,8.

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

[[Category:AVR-Tutorial]]