Mikrocontroller.net - Benutzerbeiträge [de]

Diskussion:Motoransteuerung mit PWM

2023-10-28T20:50:45Z

Elektroschlumpf:

Vielleicht sollte noch erwähnt werden, dass es sich um Gleichstrommaschinen handelt(auch wenn man das im Schaltplan durchaus erkennen kann)

Warum sollte man ein Pfeiffen beim Motor höhren? Ist das die Wellenwirkung oder vibriert da irgendwas in den / um die Spulen?
: Natürlich ist es der Motor. Im Prinzip Anker und Welle. Gfs sind es auch die Spulen selber, wenn nicht gut gedämpft. Im Einzelfall ist es aber die Elektronik. Konkret Kondensatoren.

Motoransteuerung mit PWM

2023-10-28T20:49:19Z

Elektroschlumpf: /* Wahl der PWM-Frequenz */

==Allgemeines==

Bei der Dimensionierung der Strombelastbarkeit der Bauteile muss man vor allem 2 Werte betrachten:
* Stromaufnahme des Motors im normalen Betrieb (also mit der Last)
* Stromaufnahme bei blockiertem Motor, bzw. Anlaufstrom. Hier wird der Strom nur durch den ohmschen Widerstand im Stromkreis begrenzt, er kann also je nach Motor schnell den 2-3 stelligen Amperebereich erreichen.

Die übliche Dimensionierung richtet sich vor allem nach dem ersten Wert und plant entsprechende Reserven ein (für ein paar Sekunden Faktor 2-5 des Stromes), da der zweite Wert in der Praxis aus Kostengründen meist nur schwer realisierbar und unnötig ist. Daher umgeht man das Problem entweder über eine schnelle Strombegrenzung oder über einen Sanftanlauf indem man die [[PWM]] langsam hoch fährt. Dadurch wird der maximale Strom auf einen deutlich niedrigeren Wert begrenzt, so dass die Bauteile schwächer und kostengünstiger ausfallen können.

Die Spannung am Motor und somit näherungsweise die Leerlaufdrehzahl ist proportional zu dem Tastverhältnis:

:<math>\text{Motorspannung} = \text{Betriebsspannung} \cdot \mathrm{Tastverh\ddot{a}ltnis}</math>

==Schaltungsvarianten==

===Mosfet mit Freilaufdiode, 1-Quadrantensteller===

[[Datei:Motor_PWM_1.gif|thumb|300px|1-Quadrantensteller]]
Die einfachste Schaltung besteht nur aus Transistor T1, dem Motor, der Freilaufdiode D1, dem Kondensator C1, sowie der eigentlichen [[PWM]]-Erzeugung und dem [[MOSFET-Übersicht#Mosfet-Treiber | Mosfettreiber]].

In der Einschaltphase von T1 liegt am Motor die gesamte Betriebsspannung an. Die Differenz zwischen der vom sich drehenden Motor erzeugten Generatorspannung und der Betriebsspannung fällt am Wicklungswiderstand sowie der Wicklungsinduktivität ab. Man hat es also mit einer RL Reihenschaltung zu tun. Da der Wicklungswiderstand recht klein ist, steigt der Strom näherungsweise linear an, bis T1 abschaltet. Dann übernimmt D1 den Stromfluss und schließt den Stromkreis solange, bis T1 den Strom wieder übernimmt (oder der Strom abgeklungen ist = lückender Betrieb). Obwohl keine Energie mehr von außen zugeführt wird, wird der Motor weiterhin durch die in der Wicklung gespeicherten Energie versorgt. Der Strom fällt nun wieder linear ab, bis T1 wieder durchsteuert und wieder Energie zuführt.

Der Strom durch die Diode D1 ist von der Amplitude her genauso groß wie der Strom durch T1, je nach Tastverhältnis ist der Effektivwert aber kleiner als der durch T1 (bei über 50% Tastverhältnis), gleich (bei 50% Tastverhältnis) oder sogar größer (bei einem Tastverhältnis kleiner 50%). Daher muss die Diode genauso stark dimensioniert werden wie der Transistor (möglichst eine schnelle Schaltdiode (z.B. Schottky) verwenden, keine langsamen Gleichrichterdioden wie 1N400x). Der Kondensator C1 ist notwendig, um den durch die PWM gepulsten Strom zu glätten, da aufgrund der steilen Flanken ansonsten in den Zuleitungen ein Spannungsabfall bzw. Spannungsspitzen auftreten würden (am besten 2 oder mehrere Kondensatoren unterschiedlicher Kapazität und Bauart verwenden, meistens ein Folienkondensator mit einigen Mikrofarad parallel zu einem Aluminiumelektrolytkondensator).

Der Transistor, die Diode und der Kondensator sollen möglichst nahe zusammen plaziert werden (kürzeste Verbindungen). Wenn die Diode am Motor angebracht wird, strahlt die Zuleitung massiv Störungen ab. Die Leitungen sollten am besten verdrillt werden.

===Synchrongleichrichtung, 2-Quadrantensteller===

[[Datei:Motor_PWM_2.gif|thumb|300px|2-Quadrantensteller]]
Um die Verluste in der Freilaufdiode zu verringern kann man diese durch einen zweiten Mosfet ersetzen, der immer dann eingeschaltet wird, wenn der andere abgeschaltet ist.

Da dieser Mosfet im Gegensatz zu einer Diode in beide Richtungen Strom leitet, ist es damit möglich den Motor kurzzuschließen und so den Motor zu bremsen. Allgemein kann man sagen: Ist die durch die PWM erzeugte mittlere Spannung größer als die Generatorspannung des Motors, wird dieser beschleunigt. Ist die Spannung kleiner, wird der Motor abgebremst. Durch T2 wird der Motor dabei kurzgeschlossen, so dass sich durch die Generatorspannung zunächst der Strom in der Motorwicklung ab- und dann in umgekehrter Richtung wieder aufbaut. Beim Abschalten von T2 und Einschalten von T1 fließt dieser Strom über T1 in C1 und somit die Spannungsquelle zurück. Die Energie wird beim Bremsen also nicht vernichtet, sondern wieder in elektrische Energie zurückverwandelt. Dies sollte man bedenken wenn man eine große Masse abbremst, denn die Spannungsquelle muss die Energie aufnehmen können. Sollte die Spannungsquelle z. B. aus einem Transformator mit Gleichrichter bestehen, kann dieser die Energie nicht aufnehmen sondern nur C1, was dazu führt, dass die Betriebsspannung ansteigt bis eventuell einer der Transistoren zerstört wird. Um dies zu verhindern ist eine Überspannungsbegrenzung in Form eines Bremswiderstands vorzusehen (Bremschopper). In einfachen Fällen reicht auch eine Leistung-Z-Diode oder ein passende Nachbildung aus Z-Diode und Leistungstransistor. Besteht die Spannungsquelle z. B. aus einem Akku dann nimmt dieser die Energie auf und wird beim Bremsen wieder etwas geladen.
Dies funktioniert allerdings nur, wenn das Tastverhältnis nicht 0% beträgt, also T2 und T1 abwechselnd schalten, so dass nicht die gesamte Energie in der Motorwicklung sowie T2 verheizt wird. Man sollte es daher vermeiden das Tastverhältnis schnell in eine der beiden Richtungen zu ändern, da dies zu einem hohen Strom führt.

Die Ansteuerschaltung muss weiterhin verhindern, dass T1 und T2 gleichzeitig leitend werden können, denn dies würde zu einem Kurzschluss der Betriebsspannung führen. Ein fertig aufgebauter Mosfet-Treiber verhindert dies.

===H-Brücke, 4-Quadrantensteller===

[[Datei:Motor_PWM_3.gif|thumb|300px|4-Quadrantensteller]]
Die H-Brücke, bzw. der 4-Quadrantensteller ist eine Erweiterung des 2-Quadrantenstellers durch eine zweite Halbbrücke. Diese ermöglicht neben dem Beschleunigen und Bremsen des Motors auch eine Umkehr der Drehrichtung. Dafür gibt es mehrere Ansteuerverfahren
#Das effizienteste ist, eine Hälfte wie beim 2-Quadrantensteller zu betreiben und mit der anderen den zweiten Motoranschluss an die Betriebsspannung zu legen. Für die andere Drehrichtung wechselt man einfach die Hälften, legt also den anderen Anschluss an die Betriebsspannung und verwendet die andere Hälfte als 2-Quadrantensteller.
#Das andere Verfahren steuert abwechselnd T1 und T4 oder T2 und T3 durch, legt also immer eine Spannung an den Motor. Ist das Tastverhältnis 50% fließt im Mittel ein Strom von 0A, da der Motor für jeweils die Hälfte der Zeit eine positive und eine negative Spannung erhält, der Motor steht also. Je nachdem ob man das Tastverhältnis darüber oder darunter wählt, legt man die Drehrichtung fest. Dieses Verfahren ist Ansteuertechnisch einfacher, erzeugt aber auch im Stillstand Schaltverluste in den Transistoren und Verluste im Motor.

=== Zusammenfassung der Eigenschaften ===

1 Quadrantensteller
* Drehzahlvorgabe in eine Richtung

2 Quadrantensteller
* Drehzahlvorgabe in eine Richtung
* Aktives Bremsen möglich
* Energierückspeisung vom Motor in die Stromversorgung möglich (engl. recuperation)
* etwas geringere Verluste als 1 Quadrantensteller

4 Quadrantensteller
* Drehzahlvorgabe in zwei Richtungen
* Aktives Bremsen in zwei Richtungen möglich
* Energierückspeisung vom Motor in die Stromversorgung möglich (engl. recuperation)
* etwa doppelt so große Verluste wie 2 Quadrantensteller

==Beispielschaltungen==

===1-Quadrantensteller mit diskretem Mosfettreiber===

[[Datei:Motor_PWM1_real.gif|thumb|300px|Einfacher 1-Quadrantensteller]]
Diese Schaltung eignet sich für Motoren bis etwa 35V und 10A Dauerstrom.
Q1 und Q2 zusammen mit deren Beschaltung dienen als [[Pegelwandler]] von 3,3 oder 5V Digitalsignalen auf 12V für das Mosfet Gate. Die Schaltung arbeitet dabei invertierend, der Mosfet schaltet also bei einem Low am Eingang ein.
Sperrt Q1, wird Q2 über R1 durchgesteuert und liefert etwa 11-11,5V ans Gate des Mosfets. R2 begrenzt dabei den Strom.
Das Abschalten des Mosfets geschieht über den Pfad Q1 und D1. Gleichzeitig wird Q2 die Basisspannung weggenommen, so dass dieser sperrt.
D2 zwischen Basis und Kollektor von Q1 verhindert, dass dieser in die Sättigung kommt, so dass dieser nahezu verzögerungsfrei sperrt, sobald der Eingang auf Low wechselt. Ab ein paar Ampere benötigt die Freilaufdiode D3 einen kleinen [[Kühlkörper]], ebenso Q3. Sollte die Betriebsspannung V+ des Motors bei etwa 10-16V liegen, dann kann diese Spannung auch für die Mosfetansteuerung verwendet werden. Ansonsten sollte dafür eine getrennte Spannung mit etwa 12-15V verwendet werden.

===1-Quadrantensteller mit diskretem Highside-Mosfettreiber===

[[Datei:Motor_PWM1b_real.gif|thumb|300px|Einfacher 1-Quadrantensteller mit P-Kanal Mosfet]]

Diese Schaltung eignet sich für Motoren mit etwa 15-40V Betriebsspannung und mit bis zu 10A Dauerstrom. Schaltungen mit P-Kanal Mosfets sollte man wenn möglich vermeiden, da N-Kanal Mosfets prinzipbedingt um Faktor 3 bessere Werte aufweisen als P-Kanal Mosfets. Allerdings wird manchmal ein auf Masse bezogener Ausgang gefordert, dann ist diese Schaltung hier die richtige. Das Problem bei der Highsideansteuerung ist, dass man die Gate-Sourcespannung irgendwie auf max. 20V begrenzen muss, was hier durch eine zusätzliche Hilfsspannung von 12V wie bei der vorigen Schaltung, nicht so einfach geht. Daher wird hier ein anderer Weg eingeschlagen. Q1 und R2 bilden eine [[Konstantstromquelle]]. Dadurch, dass an der Basis eine feste Logikspannung ansteht, steuert Q1 so stark durch, bis er sich durch den Spannungsabfall an R2 selbst die Basisspannung reduziert. Der fließende Strom beträgt dabei (Logikpegel am Eingang - 0,6V Basis-Emitterspannung)/R2. Ein guter Wert für den Strom sind etwa 10-15mA. Bei der Dimensionierung sollte man auch die Verlustleistung beachten: 40V * 15mA = 0,6W. Dies ist für einen Transistor im TO92 Gehäuse deutlich zu viel. Dadurch, dass Q1 im Linearbetrieb arbeitet, kommt er nicht in die Sättigung, und es kann auf die Diode wie in der vorherigen Schaltung verzichtet werden. Ebenso ist ein Basiswiderstand unnötig bzw. sogar hier fehl am Platz. Da nun bekannt ist, dass im durchgesteuerten Zustand von Q1 bei 5V Logikspannung (5V-0,6V)/330Ω= 13,3mA fließen, kann man damit den Spannungsabfall an R1 berechnen, bzw. aus der gewünschten Spannung R1:
U(R1)=13,3mA*1kOhm=13,3V. Im eingeschalteten Zustand ist die Spannung am Kollektor von Q1 also um 13,3V negativer als V+ und das unabhängig von der Betriebsspannung! Da diese Spannung durch die als Emitterfolger geschalteten Transistor Q2 und Q3 gepuffert auch an das Gate des Mosfets gelegt werden, bekommt dieser also rund 13V Gatespannung im eingeschalteten Zustand. Dies passt gut, denn für die meisten Mosfets sollte man einen Wert zwischen 10 und 15V verwenden. Durch den Spannungsteiler aus R1 und R2 ergibt sich allerdings auch eine untere Grenze der Betriebsspannung, damit die Schaltung sauber funktioniert: Um die 13,3V über R2 zu erhalten, bzw. die 4,4V über R1 sind mindestens 17,7V für V+ notwendig.

===2-Quadrantensteller mit Halbbrücken Mosfettreiber===

[[Datei:Motor_PWM2_real.gif|thumb|300px|Einfacher 2-Quadrantensteller]]

Diese Schaltung eignet sich für Motoren bis etwa 35V und 20A Dauerstrom.
Um den Aufwand zu minimieren wird für die Halbbrücke ein fertiger Halbbrückentreiber IR2184 verwendet. Dieser besitzt eine integrierte Totzeit (engl. dead time) von 500ns zwischen dem Umschalten der Mosfets, so dass ein gleichzeitiges Einschalten beider Mosfets ausgeschlossen ist. Da der Mosfet gegen V+ angeschlossen ist, arbeitet auch diese Schaltung invertierend. Der Grund, warum der Motor nicht gegenüber GND angeschlossen ist, ist folgender:
Für die Ansteuerung des Highside Mosfets Q2 ist eine Spannung von etwa 10V mehr als die Betriebsspannung V+ notwendig. Diese wird über die Bootstrapschaltung aus C2 und D1 erzeugt. Ist Q1 durchgesteuert, läd sich C2 über D1 auf. Schaltet anschließend Q1 ab und Q2 ein, wird dessen Ansteuerspannung aus C2 entnommen. Da Q2 nun VS mit V+ verbindet, steigt auch das Potential an C2 an. An dem VB Pin stehen nun etwa V+ + 12V-0,7V (12V Betriebsspannung-Flusspannung von D1) an. Aufgrund von Leckströmen, entläd sich C2 allerdings innerhalb einiger Millisekunden. Daher ist die maximale Einschaltdauer von Q2 begrenzt. 100% Einschaltdauer wären daher nicht möglich. Um dieses Problem zu umgehen ist der Motor gegen V+ geschaltet, so dass für 100% Einschaltdauer Q1 eingeschaltet werden muss, was kein Problem ist, denn dessen Treiber wird direkt auf den 12V versorgt. Ist Q1 dagegen dauerhaft aus, Q2 also an, bremst der Motor, bzw. er steht, so dass kein Strom durch die Mosfets fließt. Daher ist es auch nicht weiter schlimm, wenn Q2 nach einer kurzen Zeit wieder abschaltet. Das einzige was nicht möglich ist, ist ein dauerhaftes Bremsen des Motors mittels Q2, aber dies wird in der Praxis auch nur in den seltensten Fällen benötigt. Über den IN Pin, wird das invertierte PWM Signal mit Logikpegeln eingespeist. Über den SD\ Pin, lassen sich beide Mosfets gemeinsam abschalten. Damit ist ein ungebremstes Auslaufen lassen des Motors möglich (Freilauf). Ab etwa 5Ampere benötigen die Mosfets einen kleinen [[Kühlkörper]].

==Wahl der PWM-Frequenz==

Bei der Wahl der PWM Frequenz muss man mehrere Faktoren berücksichtigen und einen Kompromiss eingehen:
* Die Motorinduktivität L glättet den Strom, der Wicklungswiderstand R führt zu einem Abfallen des Stromes, daraus ergibt sich die elektrische Zeitkonstante des Motors <math>t=\frac{L}{R}</math>. Bei vielen Motoren liegt diese um 1ms. Bei hochwertigen Motoren sollte diese Angabe im Datenblatt zu finden sein. Um den Stromripple gering, also das Drehmoment konstant zu halten, sollte die Periodendauer der PWM diese Zeit nicht überschreiten. Vor allem im 2 bzw. 4-Quadratentebetrieb ist dies wichtig, denn dort kann der Strom auch seine Richtung ändern, was zu einem Abbremsen, somit zu einem deutlichen Ruckeln und zu Vibrationen des Motors und zu unnötigen Verlusten führt.
* Frequenzen zwischen 100Hz und 10kHz erzeugen hörbare Pfeifgeräusche im Motor
* Mit zunehmender Frequenz steigen die Schaltverluste in den Transistoren sowie die Verluste in der Ankerwicklung sowie in deren Kern.
* Einfache Gleichstrommotoren (Bürstenmotoren) mit eingebauten Entstörkondensatoren können nur mit relativ niedrigen PWM-Frequenzen von ca. 30-200 Hz betrieben werden. Bei höheren Frequenzen kommt es zu starken Schaltverlusten durch das Umladen der Entstörkondensatoren, wie man in diesem [https://www.mikrocontroller.net/topic/393784#new Beitrag] sehen kann.

=== Ideale Frequenz ===
Die aus elektrischer Sicht ideale PWM Frequenz liegt für kleine Motoren daher meist bei 1-2kHz. Allerdings ist dies genau der Bereich, in dem das Gehör am empfindlichsten ist. Wenn das Pfeifen des Motors nicht stört, ist dies also der ideale Bereich.
Da die untere Frequenz durch die elektrische Zeitkonstante des Motors begrenzt ist, kann man nur nach oben ausweichen. Ein Kompromiss ist daher der Bereich 5-15kHz in dem das Gehör deutlich unempfindlicher ist und sich die Verluste dennoch in Grenzen halten. Verwendet man die einfache Schaltung mit der Freilaufdiode und legt keinen Wert auf einen runden Lauf, bzw. hat eine hohe Masse am Motor, so dass dieser träge ist, dann kann man als Alternative zu den >5kHz die PWM Frequenz auch bis auf 200Hz reduzieren um das Geräusch erträglicher zu machen. Allerdings reduziert sich dann der Wirkungsgrad aufgrund des hohen Stromripples. Bei Hochstromanwendungen sind sonders die Umschaltverluste ein zusätlzliches Problem.

== Siehe auch ==

*[[PWM]]
*[[Treiber]]
*[[MOSFET-Übersicht#MOSFET-Treiber | Mosfet-Treiber]]
*[[H-Brücken Übersicht]]
*[https://www.ramser-elektro.at/pwm-regelung-von-ventilatoren-oder-motoren/ Projekt: PWM Regelung von Ventilatoren oder Motoren]
*[http://www.mikrocontroller.net/topic/103116#900247 Forumsbeitrag]: Highside Mosfetansteuerung mit diskretem Treiber
* [http://www.mikrocontroller.net/topic/191616#1870643 Forumsbeitrag]: Zur Erklärung der PWM Steuerung, Bremsen und Unterschied zum Relais
* [http://www.mikrocontroller.net/topic/280480#2960070 Forumsbeitrag]: Clevere MOSFET-Treiber mit kleinsten Trafos
*[https://www.mikrocontroller.net/topic/370476#4182456 Forumsbeitrag]: PWM Regler mit Strombegrenzer
*[https://www.mikrocontroller.net/topic/397337?goto=4590784#4575721 Forumsbeitrag]: H-Bridge 50Hz Sinus - LC Filter dimensionieren
*[https://www.mikrocontroller.net/topic/550961?goto=7353503#7353503 Forumsbeitrag]: Frage zu H-Brücken Treiber
*[https://www.mikrocontroller.net/topic/546882#7279816 Forumsbeitrag]: 12V Motor mir automatischer Umschaltung z.B. mit Lichtschranke

==Links==

*[http://de.wikipedia.org/wiki/Zweiquadrantensteller Zweiquadrantensteller] bei Wikipedia
*[http://de.wikipedia.org/wiki/Vierquadrantensteller Vierquadrantensteller] bei Wikipedia
*[http://homepages.which.net/~paul.hills/SpeedControl/SpeedControllersBody.html Grundlagen zum Thema Motoransteuerung (englisch)]
*[https://de.wikipedia.org/wiki/Nutzbremse Nutzbremse] bei Wikipedia
* [https://www.amazon.de/Electric-Motors-Drives-Fundamentals-Applications/dp/0080983324/ref=sr_1_1?ie=UTF8&qid=1507632012&sr=8-1&keywords=motors+drives Electric Motors and Drives: Fundamentals, Types and Applications] (Taschenbuch, Englisch, ISBN-10 0080983324)

[[Kategorie:Leistungselektronik]]
[[Kategorie:Motoren]]

LED-Fading

2023-10-28T20:46:20Z

Elektroschlumpf: /* Die Theorie */

== Das Problem ==

Eine [[LED]] soll mittels [[PWM]] in ihrer Helligkeit gesteuert werden. Zudem möchte man sie eventuell weich aufleuchten lassen, d.h. langsam heller und dunkler machen, was (engl.) fading genannt wurde. Es zeigt sich aber recht schnell ein Problem: Wenn man eine 8-Bit-PWM linear zwischen 0..255 hochlaufen lässt, wird die LED nicht optisch linear gedimmt. Sie wird oberhalb eines bestimmten Tastverhältnisses vergleichsweise schnell hell und bleibt auch lange hell. Dieses Verhalten hat einerseits mit dem Durchbruchverhalten der Diode und andererseits mit der nichtlinearen Lichtausbeute zu tun. D.h. weder ist der Strom linear zur Spannung, noch ist das Licht linear zum Strom.

== Die Theorie ==

Des Rätsels Lösung liegt in der Kennline des menschlichen Auges. Diese ist nichtlinear, genauer gesagt: sie ist nahezu logarithmisch. Das ermöglicht die Wahrnehmung eines sehr großen Helligkeitsbereichs, angefangen von Vollmond mit ~1/4 [http://de.wikipedia.org/wiki/Lux_%28Einheit%29 Lux] über eine normale Schreibtischbeleuchtung mit ca. 750 Lux bis zu einem hellen Sommertag mit bis zu 100.000 Lux. Solche hochdynamischen Signale sind nur mit einer logarithmischen Kennlinie in den Griff zu kriegen, auch von Mutter Natur und Erfinder Papa.

=== Die Kennlinie des Auges genau betrachtet ===

Ein weiteres Problem ist das Verhalten des menschlichen Auges: Dies ist annähernd logarithmisch, was bereits früh durch das [http://de.wikipedia.org/wiki/Weber-Fechner-Gesetz Weber-Fechner-Gesetz] beschrieben wurde. Genauere Untersuchungen zur [http://de.wikipedia.org/wiki/Gammakorrektur Gammakorrektur] führten später zur [http://de.wikipedia.org/wiki/Stevenssche_Potenzfunktion Stevenschen Potenzfunktion], die die Empfindlichkeit des Auges noch etwas besser beschreibt. (s. auch [[Talk:LED-Fading#Diskussion wissenschaftl.-technischer Hintergrund|Diskussionsseite]]). Die Unterschiede sind jedoch marginal.

Praktisch heißt das, dass wir unserem Auge vergleichsweise große physikalische Helligkeitsunterschiede präsentieren müssen, damit es diese als linearen Helligkeitsverlauf erkennt. Etwas wissenschaftlicher formuliert heißt das, wir müssen durch Verkettung der logarithmischen Kennlinie des Auges mit einer exponentiellen Kennlinie eine physiologisch lineare Helligkeitsverteilung erzielen. Des weiteren muss unter Beachtung der Diodenkennlinien die richtige Spannung eingeprägt werden.

Eine einfache Möglichkeit der praktischen Umsetzung besteht im Nutzen einer Tabelle, in welcher die Funktionen abgebildet sind. Berechnet werden kann eine passende Tabelle beispielsweise mit z.B. folgender Funktion:

:<math>y=\frac{b^{\,x/r_x}-1}{b-1}\cdot r_y</math>

Dabei sind x und y die Ein-, bzw. Ausgabewerte der Funktion, jeweils im Bereich von 0 bis r–1. b ist die Basis der Exponentialfunktion und bestimmt, wann und wie stark die Kurve ansteigen soll. Hier ist etwas Ausprobieren erforderlich, gute Ergebnisse liefern Werte im Bereich 10–100.

== Das Demoprogramm ==

Das folgende Beispielprogramm demonstriert die Wirkung verschiedener PWM-Auflösungen. Eine 8-Bit PWM wird mit 4/8/16 und 32 nichtlinearen Stufen betrieben, welche über eine Exponentialfunktion berechnet wurden. Dazu dient die [[media:pwm_table.zip|Exceltabelle]]<ref>Anmerkung: Bitte die Exceltabelle nochmal erklären, die Werte in der Tabelle stimmen nicht mit denen im Programm überein</ref> - überarbeitet, inkl. neuer Varianten der Berechnung als [[media:pwm_table-r101.ods|LibreOffice Calc Sheet]] / [[media:pwm_table-r101.pdf|PDF Vorschau]]<ref>Download alternativ von ftp://ftp.fl.priv.at/pub/mikrocontroller.net/led-fading/</ref>. Die einzelnen, benachbarten Werte haben zueinander ein konstantes Verhältnis, das in der Exceltabelle als ''Factor'' berechnet wird. Ausserdem werden eine 10-Bit PWM mit 64 Stufen sowie eine 16-Bit PWM mit 256 Stufen betrieben.

Eine neue [[media:LED-PWM.xlsm|Excel 2000 Tabelle]] ist ebenfalls verfügbar. Die Schaltflächen kopieren die Arraywerte in die Zwischenablage.

Das Programm ist ursprünglich auf einem [[AVR]] vom Typ ATmega32 entwickelt und getestet worden. Aber es ist leicht auf jeden AVR portierbar, welcher eine PWM zur Verfügung hat. Der AVR muss mit etwa 8 MHz getaktet werden, egal ob mit internem Oszillator oder von aussen mit Quarz. Man muss nur noch eine [[LED]] mittels Vorwiderstand von ca. 1 kΩ an Pin D5 anschliessen und los gehts. Es sollte hier noch erwähnt werden, dass das Programm mit eingeschalteter Optimierung compiliert werden muss, sonst stimmen die Zeiten der Warteschleifen aus <tt>util/delay.h</tt> nicht.

Bei Verwendung der LEDs auf dem STK500 bzw. bei der Verwendung von invertierenden Treiberstufen ist das
#define STK500 0
durch
#define STK500 1
zu ersetzen.

Das Programm durchläuft alle 6 PWMs und lässt dabei die LED jeweils 3 mal glimmen. Mit 4 Schritten Auflösung ist das natürlich ruckelig, mit 8 schon wesentlich besser. Mit 16 Stufen sieht man bei langsamen Änderungen noch Stufen, dreht man die Ein- und Ausblendzeiten runter, ist der Übergang schon recht flüssig. Die 8-Bit PWM mit 32 Stufen unterscheidet sich praktisch nicht von der 10-Bit PWM mit 64 Stufen, es sei denn, man macht extrem langsame Einblendungen. Hier schlägt die Stunde der 16-Bit PWM. Diese wird bewußt sehr langsam ausgeführt um zu demonstrieren, daß hiermit praktisch keine Stufen mehr sichtbar sind, egal wie langsam gedimmt wird. Wie man auch sieht sind die drei höherauflösenden PWMs im unteren Bereich an ihrer Auflösungsgrenze, da einige PWM-Werte mehrfach vorkommen. Da heißt gleichzeitig, daß eine Steigerung der Stufenanzahl relativ sinnlos ist.

<syntaxhighlight lang="c">
//**************************************************************************
//*
//* LED fading test
//* uses exponential PWM settings to achive visual linear brightness
//*
//* ATmega32 @ 8 MHz
//*
//**************************************************************************

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

#define F_CPU 8000000L
#include <util/delay.h>

#define STK500 0

#if STK500
// inverted PWM on OC1A for STK500
#define INVERT_PWM (1 << COM1A0)
#else
// non-inverted PWM on OC1A
#define INVERT_PWM 0
#endif // STK500

const uint16_t pwmtable_8A[4] PROGMEM = { 0, 16, 64, 255 };
const uint16_t pwmtable_8B[8] PROGMEM =
{
0, 4, 8, 16, 32, 64, 128, 255
};

const uint16_t pwmtable_8C[16] PROGMEM =
{
0, 2, 3, 4, 6, 8, 11, 16, 23, 32, 45, 64, 90, 128, 181, 255
};

const uint16_t pwmtable_8D[32] PROGMEM =
{
0, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 10, 11, 13, 16, 19, 23,
27, 32, 38, 45, 54, 64, 76, 91, 108, 128, 152, 181, 215, 255
};

const uint16_t pwmtable_10[64] PROGMEM =
{
0, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 9, 10,
11, 12, 13, 15, 17, 19, 21, 23, 26, 29, 32, 36, 40, 44, 49, 55,
61, 68, 76, 85, 94, 105, 117, 131, 146, 162, 181, 202, 225, 250,
279, 311, 346, 386, 430, 479, 534, 595, 663, 739, 824, 918, 1023
};

const uint16_t pwmtable_16[256] PROGMEM =
{
0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7,
7, 7, 8, 8, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15,
15, 16, 17, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
31, 32, 33, 35, 36, 38, 40, 41, 43, 45, 47, 49, 52, 54, 56, 59,
61, 64, 67, 70, 73, 76, 79, 83, 87, 91, 95, 99, 103, 108, 112,
117, 123, 128, 134, 140, 146, 152, 159, 166, 173, 181, 189, 197,
206, 215, 225, 235, 245, 256, 267, 279, 292, 304, 318, 332, 347,
362, 378, 395, 412, 431, 450, 470, 490, 512, 535, 558, 583, 609,
636, 664, 693, 724, 756, 790, 825, 861, 899, 939, 981, 1024, 1069,
1117, 1166, 1218, 1272, 1328, 1387, 1448, 1512, 1579, 1649, 1722,
1798, 1878, 1961, 2048, 2139, 2233, 2332, 2435, 2543, 2656, 2773,
2896, 3025, 3158, 3298, 3444, 3597, 3756, 3922, 4096, 4277, 4467,
4664, 4871, 5087, 5312, 5547, 5793, 6049, 6317, 6596, 6889, 7194,
7512, 7845, 8192, 8555, 8933, 9329, 9742, 10173, 10624, 11094,
11585, 12098, 12634, 13193, 13777, 14387, 15024, 15689, 16384,
17109, 17867, 18658, 19484, 20346, 21247, 22188, 23170, 24196,
25267, 26386, 27554, 28774, 30048, 31378, 32768, 34218, 35733,
37315, 38967, 40693, 42494, 44376, 46340, 48392, 50534, 52772,
55108, 57548, 60096, 62757, 65535
};

/*

Diese Tabellen sind nicht nach der Theorie (s. oben) berechnet, sondern wie folgt:
a = Anzahl an Schritte (4, 8, 16, 32, 64, 256)
b = Auflösung des PWM's (256, 1024, 65536)
y = Errechneter Wert an einer stelle x
y = 0 wenn x = 0
y = pow(2, log2(b-1) * (x+1) / a) wenn x > 0

Gerne wird auch diese alternative Formel genutzt:
y = pow(2, log2(b) * (x+1) / a) - 1

Obige Funktionen wurden in den LibreOffice Calc Sheet eingearbeitet.
*/

// long, variable delays

void my_delay (uint16_t milliseconds)
{
for (; milliseconds > 0; milliseconds--)
_delay_ms (1);
}

void pwm_up_down (const uint16_t pwm_table[], int16_t size, uint16_t delay)
{
int16_t tmp;

for (tmp = 0; tmp < size; tmp++)
{
OCR1A = pgm_read_word (& pwm_table[tmp]);
my_delay (delay);
}

for (tmp = size-1; tmp >= 0; tmp--)
{
OCR1A = pgm_read_word (& pwm_table[tmp]);
my_delay (delay);
}
}

// 8-Bit PWM with only 4 different settings

void pwm_8_4 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << CS12) | (0 << CS11) | (0 << CS10);

pwm_up_down (pwmtable_8A, 4, delay);
}

// 8-Bit PWM with 8 different settings

void pwm_8_8 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << CS12) | (0 << CS11) | (0 << CS10);

pwm_up_down (pwmtable_8B, 8, delay);
}

// 8-Bit PWM with 16 different settings

void pwm_8_16 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << CS12) | (0 << CS11) | (0 << CS10);

pwm_up_down (pwmtable_8C, 16, delay);
}

// 8-Bit PWM with 32 different settings

void pwm_8_32 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << CS12) | (0 << CS11) | (0 << CS10);

pwm_up_down (pwmtable_8D, 32, delay);
}

// 10-Bit PWM with 64 different settings

void pwm_10_64 (uint16_t delay)
{
// 10 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 64 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (0 << CS12) | (1 << CS11) | (1 << CS10);

pwm_up_down (pwmtable_10, 64, delay);
}

// 16-Bit PWM with 256 different settings

void pwm_16_256 (uint16_t delay)
{
// 16 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B1) | INVERT_PWM;
// stop timer
TCCR1B = 0;
// TOP for PWM, full 16 Bit
ICR1 = 0xFFFF;
// prescaler 1 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << WGM13) | (0 << CS12) | (0 << CS11) | (1 << CS10);

pwm_up_down (pwmtable_16, 256, delay);
}

int main (void)
{
int8_t i;
// delay in milliseconds for one fading step
int16_t step_time = 400;

// LED uses OC1A
DDRD |= 1 << PD5;

// test all fading routines

while (1)
{
for (i=0; i<3; i++) pwm_8_4 (step_time);
my_delay (1000);

for (i=0; i<3; i++) pwm_8_8 (step_time/2);
my_delay (1000);

for (i=0; i<3; i++) pwm_8_16 (step_time/4);
my_delay (1000);

for (i=0; i<3; i++) pwm_8_32 (step_time/8);
my_delay (1000);

for (i=0; i<3; i++) pwm_10_64 (step_time/16);
my_delay (1000);

for (i=0; i<3; i++) pwm_16_256 (step_time/16);
my_delay (1000);
}

return 0;
}
</syntaxhighlight>

== FAQ ==

; Wieso geht die LED nie ganz aus?: Es ist normal, dass die LED selbst bei OCR1A = 0 immer noch ganz schwach leuchtet. Die Hardware-PWM funktioniert so, dass bei einem Timerwert von 0 auf jeden Fall der Ausgang eingeschaltet wird. Danach kommt der Compare Match bei 0 und schaltet gleich wieder aus. Daher ist der Ausgang für einen PWM-Takt eingeschaltet. Um das zu ändern, muss man entweder invertierte PWM nutzen, dann ist allerdings der Ausgang nie zu 100% High, sondern hat immer einen Takt Low beim maximalem PWM-Wert. Oder man schaltet bei 0 einfach die PWM-Funktion ab und setzt den Ausgang normal auf Low. [http://www.mikrocontroller.net/topic/200173#1965686].

; Wieso dimmt man eine LED nicht besser mit einer variablen Stromquelle?: Nur so ist es möglich, die LEDs von nahezu 0 bis 100% zu dimmen, ohne dass es zu Farbänderungen kommt, was besonders bei RGB-Anwendungen wichtig ist.

; Wie stimmen die Werte im LibreOffice Calc Sheet mit denen im Programm überein?: Basis = (Max/Factor)^(1/(Steps-1)) pwmtable_xx[0] = 0 pwmtable_xx[Index] = Round(Factor * Basis^Index); for Index=1..Steps-1 pwmtable_8A - Max=255,   Steps=4,   Factor=4 pwmtable_8B - Max=255,   Steps=8,   Factor=2 pwmtable_8C - Max=255,   Steps=16,   Factor=1.435 pwmtable_8D - Max=255,   Steps=32,  Factor=1.21 pwmtable_10 - Max=1023,  Steps=64,  Factor=1.118 pwmtable_16 - Max=65535, Steps=256, Factor=1.04427 Anmerkung 1: Dies ist nur ein Reverse-Engineering, es ist derzeit nicht bekannt, warum der jeweilige Faktor so gewählt wurde wie oben angeführt. Anmerkung 1.1: Mit der gefitteten Funktion Faktor(Steps) = 0,983118 + 18,061952 / ( 1+ (LOG10(steps)/0,3515028)^2,985948 ) lassen sich die Faktor-Werte für beliebige Schrittzahlen ausreichend genau berechnen, auch wenn sie keinen zusätzlichen Erklärungsgehalt bietet. Anmerkung 2: Für das LibreOffice Calc Sheet siehe oben [[#Das_Demoprogramm|Das Demoprogramm]]. Anmerkung 3: Der für die Tabelle benötigte EEPROM-Speicher entspricht log_2(MAX+1)*steps bit.

== Fußnoten ==
<references/>

== Siehe auch ==
* [[PWM]]
* [[AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe#PWM (Pulsweitenmodulation)|AVR-GCC-Tutorial: PWM]]
* [[Soft-PWM]] - optimierte Software-PWM in C
* [http://www.b-kainka.de/bastel108.htm Eine LED weich blinken lassen ohne Mikrocontroller]
* [http://www.solstice.de/cms/upload/pdf/Veroeffentlichungen/Weber-Fechner-PHidS-1994.pdf [PDF<nowiki>]</nowiki> "Experimente zur logarithmischen Empfindlichkeitsskala - Das Weber-Fechnersche Gesetz"] - Download Nr. 50 von [http://www.solstice.de/initiatoren/werner-schneider/veroeffentlichungen.html Solstice - Veröffentlichungen von Prof. Dr. Werner B. Schneider]

[[Category:AVR-Projekte]]
[[Category:Displays und Anzeigen]]

LED-Fading

2023-10-28T20:40:47Z

Elektroschlumpf: /* Das Problem */

== Das Problem ==

Eine [[LED]] soll mittels [[PWM]] in ihrer Helligkeit gesteuert werden. Zudem möchte man sie eventuell weich aufleuchten lassen, d.h. langsam heller und dunkler machen, was (engl.) fading genannt wurde. Es zeigt sich aber recht schnell ein Problem: Wenn man eine 8-Bit-PWM linear zwischen 0..255 hochlaufen lässt, wird die LED nicht optisch linear gedimmt. Sie wird oberhalb eines bestimmten Tastverhältnisses vergleichsweise schnell hell und bleibt auch lange hell. Dieses Verhalten hat einerseits mit dem Durchbruchverhalten der Diode und andererseits mit der nichtlinearen Lichtausbeute zu tun. D.h. weder ist der Strom linear zur Spannung, noch ist das Licht linear zum Strom.

== Die Theorie ==

Des Rätsels Lösung liegt in der Kennline des menschlichen Auges. Diese ist nichtlinear, genauer gesagt: sie ist nahezu logarithmisch. Das ermöglicht die Wahrnehmung eines sehr großen Helligkeitsbereichs, angefangen von Vollmond mit ~1/4 [http://de.wikipedia.org/wiki/Lux_%28Einheit%29 Lux] über eine normale Schreibtischbeleuchtung mit ca. 750 Lux bis zu einem hellen Sommertag mit bis zu 100.000 Lux. Solche hochdynamischen Signale sind nur mit einer logarithmischen Kennlinie in den Griff zu kriegen, auch von Mutter Natur und Erfinder Papa.

=== Die Kennlinie des Auges genau betrachtet ===

Die Kennlinie des menschlichen Auges ist annähernd logarithmisch. Das wurde vor langer Zeit durch das [http://de.wikipedia.org/wiki/Weber-Fechner-Gesetz Weber-Fechner-Gesetz] beschrieben. Genauere Untersuchungen zur [http://de.wikipedia.org/wiki/Gammakorrektur Gammakorrektur] führten jedoch zur [http://de.wikipedia.org/wiki/Stevenssche_Potenzfunktion Stevenschen Potenzfunktion]. Diese beschreibt das menschliche Auge etwas besser. (s. auch [[Talk:LED-Fading#Diskussion wissenschaftl.-technischer Hintergrund|Diskussionsseite]]). Die Unterschiede sind jedoch marginal.

Praktisch heißt das, dass wir unserem Auge große physikalische Helligkeitsunterschiede präsentieren müssen, damit es das als lineare Helligkeitsteigerung erkennt. Etwas wissenschaftlicher formuliert heißt das, wir müssen durch Verkettung der logarithmischen Kennlinie des Auges mit einer exponentiellen Kennlinie eine physiologisch lineare Helligkeitsverteilung erzielen.

Berechnet werden kann eine passende Tabelle beispielsweise mit folgender Funktion:

:<math>y=\frac{b^{\,x/r_x}-1}{b-1}\cdot r_y</math>

Dabei sind x und y die Ein-, bzw. Ausgabewerte der Funktion, jeweils im Bereich von 0 bis r–1. b ist die Basis der Exponentialfunktion und bestimmt, wann und wie stark die Kurve ansteigen soll. Hier ist etwas Ausprobieren erforderlich, gute Ergebnisse liefern Werte im Bereich 10–100.

== Das Demoprogramm ==

Das folgende Beispielprogramm demonstriert die Wirkung verschiedener PWM-Auflösungen. Eine 8-Bit PWM wird mit 4/8/16 und 32 nichtlinearen Stufen betrieben, welche über eine Exponentialfunktion berechnet wurden. Dazu dient die [[media:pwm_table.zip|Exceltabelle]]<ref>Anmerkung: Bitte die Exceltabelle nochmal erklären, die Werte in der Tabelle stimmen nicht mit denen im Programm überein</ref> - überarbeitet, inkl. neuer Varianten der Berechnung als [[media:pwm_table-r101.ods|LibreOffice Calc Sheet]] / [[media:pwm_table-r101.pdf|PDF Vorschau]]<ref>Download alternativ von ftp://ftp.fl.priv.at/pub/mikrocontroller.net/led-fading/</ref>. Die einzelnen, benachbarten Werte haben zueinander ein konstantes Verhältnis, das in der Exceltabelle als ''Factor'' berechnet wird. Ausserdem werden eine 10-Bit PWM mit 64 Stufen sowie eine 16-Bit PWM mit 256 Stufen betrieben.

Eine neue [[media:LED-PWM.xlsm|Excel 2000 Tabelle]] ist ebenfalls verfügbar. Die Schaltflächen kopieren die Arraywerte in die Zwischenablage.

Das Programm ist ursprünglich auf einem [[AVR]] vom Typ ATmega32 entwickelt und getestet worden. Aber es ist leicht auf jeden AVR portierbar, welcher eine PWM zur Verfügung hat. Der AVR muss mit etwa 8 MHz getaktet werden, egal ob mit internem Oszillator oder von aussen mit Quarz. Man muss nur noch eine [[LED]] mittels Vorwiderstand von ca. 1 kΩ an Pin D5 anschliessen und los gehts. Es sollte hier noch erwähnt werden, dass das Programm mit eingeschalteter Optimierung compiliert werden muss, sonst stimmen die Zeiten der Warteschleifen aus <tt>util/delay.h</tt> nicht.

Bei Verwendung der LEDs auf dem STK500 bzw. bei der Verwendung von invertierenden Treiberstufen ist das
#define STK500 0
durch
#define STK500 1
zu ersetzen.

Das Programm durchläuft alle 6 PWMs und lässt dabei die LED jeweils 3 mal glimmen. Mit 4 Schritten Auflösung ist das natürlich ruckelig, mit 8 schon wesentlich besser. Mit 16 Stufen sieht man bei langsamen Änderungen noch Stufen, dreht man die Ein- und Ausblendzeiten runter, ist der Übergang schon recht flüssig. Die 8-Bit PWM mit 32 Stufen unterscheidet sich praktisch nicht von der 10-Bit PWM mit 64 Stufen, es sei denn, man macht extrem langsame Einblendungen. Hier schlägt die Stunde der 16-Bit PWM. Diese wird bewußt sehr langsam ausgeführt um zu demonstrieren, daß hiermit praktisch keine Stufen mehr sichtbar sind, egal wie langsam gedimmt wird. Wie man auch sieht sind die drei höherauflösenden PWMs im unteren Bereich an ihrer Auflösungsgrenze, da einige PWM-Werte mehrfach vorkommen. Da heißt gleichzeitig, daß eine Steigerung der Stufenanzahl relativ sinnlos ist.

<syntaxhighlight lang="c">
//**************************************************************************
//*
//* LED fading test
//* uses exponential PWM settings to achive visual linear brightness
//*
//* ATmega32 @ 8 MHz
//*
//**************************************************************************

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

#define F_CPU 8000000L
#include <util/delay.h>

#define STK500 0

#if STK500
// inverted PWM on OC1A for STK500
#define INVERT_PWM (1 << COM1A0)
#else
// non-inverted PWM on OC1A
#define INVERT_PWM 0
#endif // STK500

const uint16_t pwmtable_8A[4] PROGMEM = { 0, 16, 64, 255 };
const uint16_t pwmtable_8B[8] PROGMEM =
{
0, 4, 8, 16, 32, 64, 128, 255
};

const uint16_t pwmtable_8C[16] PROGMEM =
{
0, 2, 3, 4, 6, 8, 11, 16, 23, 32, 45, 64, 90, 128, 181, 255
};

const uint16_t pwmtable_8D[32] PROGMEM =
{
0, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 10, 11, 13, 16, 19, 23,
27, 32, 38, 45, 54, 64, 76, 91, 108, 128, 152, 181, 215, 255
};

const uint16_t pwmtable_10[64] PROGMEM =
{
0, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 9, 10,
11, 12, 13, 15, 17, 19, 21, 23, 26, 29, 32, 36, 40, 44, 49, 55,
61, 68, 76, 85, 94, 105, 117, 131, 146, 162, 181, 202, 225, 250,
279, 311, 346, 386, 430, 479, 534, 595, 663, 739, 824, 918, 1023
};

const uint16_t pwmtable_16[256] PROGMEM =
{
0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7,
7, 7, 8, 8, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15,
15, 16, 17, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
31, 32, 33, 35, 36, 38, 40, 41, 43, 45, 47, 49, 52, 54, 56, 59,
61, 64, 67, 70, 73, 76, 79, 83, 87, 91, 95, 99, 103, 108, 112,
117, 123, 128, 134, 140, 146, 152, 159, 166, 173, 181, 189, 197,
206, 215, 225, 235, 245, 256, 267, 279, 292, 304, 318, 332, 347,
362, 378, 395, 412, 431, 450, 470, 490, 512, 535, 558, 583, 609,
636, 664, 693, 724, 756, 790, 825, 861, 899, 939, 981, 1024, 1069,
1117, 1166, 1218, 1272, 1328, 1387, 1448, 1512, 1579, 1649, 1722,
1798, 1878, 1961, 2048, 2139, 2233, 2332, 2435, 2543, 2656, 2773,
2896, 3025, 3158, 3298, 3444, 3597, 3756, 3922, 4096, 4277, 4467,
4664, 4871, 5087, 5312, 5547, 5793, 6049, 6317, 6596, 6889, 7194,
7512, 7845, 8192, 8555, 8933, 9329, 9742, 10173, 10624, 11094,
11585, 12098, 12634, 13193, 13777, 14387, 15024, 15689, 16384,
17109, 17867, 18658, 19484, 20346, 21247, 22188, 23170, 24196,
25267, 26386, 27554, 28774, 30048, 31378, 32768, 34218, 35733,
37315, 38967, 40693, 42494, 44376, 46340, 48392, 50534, 52772,
55108, 57548, 60096, 62757, 65535
};

/*

Diese Tabellen sind nicht nach der Theorie (s. oben) berechnet, sondern wie folgt:
a = Anzahl an Schritte (4, 8, 16, 32, 64, 256)
b = Auflösung des PWM's (256, 1024, 65536)
y = Errechneter Wert an einer stelle x
y = 0 wenn x = 0
y = pow(2, log2(b-1) * (x+1) / a) wenn x > 0

Gerne wird auch diese alternative Formel genutzt:
y = pow(2, log2(b) * (x+1) / a) - 1

Obige Funktionen wurden in den LibreOffice Calc Sheet eingearbeitet.
*/

// long, variable delays

void my_delay (uint16_t milliseconds)
{
for (; milliseconds > 0; milliseconds--)
_delay_ms (1);
}

void pwm_up_down (const uint16_t pwm_table[], int16_t size, uint16_t delay)
{
int16_t tmp;

for (tmp = 0; tmp < size; tmp++)
{
OCR1A = pgm_read_word (& pwm_table[tmp]);
my_delay (delay);
}

for (tmp = size-1; tmp >= 0; tmp--)
{
OCR1A = pgm_read_word (& pwm_table[tmp]);
my_delay (delay);
}
}

// 8-Bit PWM with only 4 different settings

void pwm_8_4 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << CS12) | (0 << CS11) | (0 << CS10);

pwm_up_down (pwmtable_8A, 4, delay);
}

// 8-Bit PWM with 8 different settings

void pwm_8_8 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << CS12) | (0 << CS11) | (0 << CS10);

pwm_up_down (pwmtable_8B, 8, delay);
}

// 8-Bit PWM with 16 different settings

void pwm_8_16 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << CS12) | (0 << CS11) | (0 << CS10);

pwm_up_down (pwmtable_8C, 16, delay);
}

// 8-Bit PWM with 32 different settings

void pwm_8_32 (uint16_t delay)
{
// 8 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 256 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << CS12) | (0 << CS11) | (0 << CS10);

pwm_up_down (pwmtable_8D, 32, delay);
}

// 10-Bit PWM with 64 different settings

void pwm_10_64 (uint16_t delay)
{
// 10 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B1) | (1 << COM1B0) | INVERT_PWM;
// prescaler 64 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (0 << CS12) | (1 << CS11) | (1 << CS10);

pwm_up_down (pwmtable_10, 64, delay);
}

// 16-Bit PWM with 256 different settings

void pwm_16_256 (uint16_t delay)
{
// 16 Bit Fast PWM
TCCR1A = (1 << COM1A1) | (1 << COM1B1) | INVERT_PWM;
// stop timer
TCCR1B = 0;
// TOP for PWM, full 16 Bit
ICR1 = 0xFFFF;
// prescaler 1 -> ~122 Hz PWM frequency
TCCR1B = (1 << WGM12) | (1 << WGM13) | (0 << CS12) | (0 << CS11) | (1 << CS10);

pwm_up_down (pwmtable_16, 256, delay);
}

int main (void)
{
int8_t i;
// delay in milliseconds for one fading step
int16_t step_time = 400;

// LED uses OC1A
DDRD |= 1 << PD5;

// test all fading routines

while (1)
{
for (i=0; i<3; i++) pwm_8_4 (step_time);
my_delay (1000);

for (i=0; i<3; i++) pwm_8_8 (step_time/2);
my_delay (1000);

for (i=0; i<3; i++) pwm_8_16 (step_time/4);
my_delay (1000);

for (i=0; i<3; i++) pwm_8_32 (step_time/8);
my_delay (1000);

for (i=0; i<3; i++) pwm_10_64 (step_time/16);
my_delay (1000);

for (i=0; i<3; i++) pwm_16_256 (step_time/16);
my_delay (1000);
}

return 0;
}
</syntaxhighlight>

== FAQ ==

; Wieso geht die LED nie ganz aus?: Es ist normal, dass die LED selbst bei OCR1A = 0 immer noch ganz schwach leuchtet. Die Hardware-PWM funktioniert so, dass bei einem Timerwert von 0 auf jeden Fall der Ausgang eingeschaltet wird. Danach kommt der Compare Match bei 0 und schaltet gleich wieder aus. Daher ist der Ausgang für einen PWM-Takt eingeschaltet. Um das zu ändern, muss man entweder invertierte PWM nutzen, dann ist allerdings der Ausgang nie zu 100% High, sondern hat immer einen Takt Low beim maximalem PWM-Wert. Oder man schaltet bei 0 einfach die PWM-Funktion ab und setzt den Ausgang normal auf Low. [http://www.mikrocontroller.net/topic/200173#1965686].

; Wieso dimmt man eine LED nicht besser mit einer variablen Stromquelle?: Nur so ist es möglich, die LEDs von nahezu 0 bis 100% zu dimmen, ohne dass es zu Farbänderungen kommt, was besonders bei RGB-Anwendungen wichtig ist.

; Wie stimmen die Werte im LibreOffice Calc Sheet mit denen im Programm überein?: Basis = (Max/Factor)^(1/(Steps-1)) pwmtable_xx[0] = 0 pwmtable_xx[Index] = Round(Factor * Basis^Index); for Index=1..Steps-1 pwmtable_8A - Max=255,   Steps=4,   Factor=4 pwmtable_8B - Max=255,   Steps=8,   Factor=2 pwmtable_8C - Max=255,   Steps=16,   Factor=1.435 pwmtable_8D - Max=255,   Steps=32,  Factor=1.21 pwmtable_10 - Max=1023,  Steps=64,  Factor=1.118 pwmtable_16 - Max=65535, Steps=256, Factor=1.04427 Anmerkung 1: Dies ist nur ein Reverse-Engineering, es ist derzeit nicht bekannt, warum der jeweilige Faktor so gewählt wurde wie oben angeführt. Anmerkung 1.1: Mit der gefitteten Funktion Faktor(Steps) = 0,983118 + 18,061952 / ( 1+ (LOG10(steps)/0,3515028)^2,985948 ) lassen sich die Faktor-Werte für beliebige Schrittzahlen ausreichend genau berechnen, auch wenn sie keinen zusätzlichen Erklärungsgehalt bietet. Anmerkung 2: Für das LibreOffice Calc Sheet siehe oben [[#Das_Demoprogramm|Das Demoprogramm]]. Anmerkung 3: Der für die Tabelle benötigte EEPROM-Speicher entspricht log_2(MAX+1)*steps bit.

== Fußnoten ==
<references/>

== Siehe auch ==
* [[PWM]]
* [[AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe#PWM (Pulsweitenmodulation)|AVR-GCC-Tutorial: PWM]]
* [[Soft-PWM]] - optimierte Software-PWM in C
* [http://www.b-kainka.de/bastel108.htm Eine LED weich blinken lassen ohne Mikrocontroller]
* [http://www.solstice.de/cms/upload/pdf/Veroeffentlichungen/Weber-Fechner-PHidS-1994.pdf [PDF<nowiki>]</nowiki> "Experimente zur logarithmischen Empfindlichkeitsskala - Das Weber-Fechnersche Gesetz"] - Download Nr. 50 von [http://www.solstice.de/initiatoren/werner-schneider/veroeffentlichungen.html Solstice - Veröffentlichungen von Prof. Dr. Werner B. Schneider]

[[Category:AVR-Projekte]]
[[Category:Displays und Anzeigen]]

Pulsweitenmodulation

2023-10-28T20:35:35Z

Elektroschlumpf: /* Leistungsberechnung */ genauer

== Einleitung ==

Bei der '''Pulsweitenmodulation''' (engl. Pulse Width Modulation, abgekürzt '''PWM'''), teilweise auch Puls-Dauer-Modulation, wird das Verhältnis zwischen der Einschaltzeit und Periodendauer eines Rechtecksignals bei fester Grundfrequenz variiert. Das Verhältnis zwischen der Einschaltzeit <math>t_{ein}</math> und der Periodendauer <math> T = t_{ein} + t_{aus} </math> wird als das Tastverhältnis '''p''' bezeichnet. (laut DIN IEC 60469-1: Tastgrad) (engl. Duty Cycle, meist abgekürzt DC, nicht zu verwechseln mit Direct Current = Gleichstrom ).

Die Pulsweitenmodulation für ein Signal <math> x(t) </math> ist für die Dauer einer Periode im Intervall [0,T] wie folgt definiert:

<math> x(t) = \left\{\begin{array}{l l}
0 & \quad t < t_1 \\
1 & \quad t \ge t_1 \\
0 & \quad t > T
\end{array} \right.
</math>

[[Bild:pwmdoc.png]]

<math> p = \dfrac{t_{ein}}{T} = \dfrac{t_{ein}}{t_{ein}+t_{aus}} </math>

Der Wert des Tastverhältnis '''p''' kann dabei Werte zwischen 0 und 100% annehmen.

Der zeitliche '''Mittelwert''' der Spannung <math>U(t)</math> innerhalb eines Intervalls [0,T] ist unten stehend beschrieben.

:<math>U_m = \frac{1}{T} \int_0^T u(t)dt = \frac{1}{T}\int_0^{t_{ein}} U_{ein}dt + \frac{1}{T} \int_{t_{ein}}^T U_{aus}dt</math>

:<math>U_m = U_{aus} + (U_{ein} - U_{aus}) \cdot \frac{t_{ein}}{t_{ein}+t_{aus}}</math>

<math>U_{aus}</math> ist dabei normalerweise 0V, <math>U_{ein}</math> die Betriebsspannung <math>V_{CC}</math>, z. B. 5V. Deshalb kann man vereinfacht schreiben:

:<math>U_m = V_{CC} \cdot \frac{t_{ein}}{t_{ein}+t_{aus}} = V_{CC} \cdot DC</math>.

=== Beispiele ===

Die folgenden Beispiele zeigen PWM-Signale mit einem Tastverhältnis von 75% bzw. 25%.

<table border="1"><tr><td style="padding: 10px;">
'''Beispiel 1'''

<math>U_{ein}=5\,\mathrm{V}</math> 
<math>U_{aus}=0\,\mathrm{V}</math> 
<math>t_{ein}=3\,\mathrm{ms}</math> 
<math>t_{aus}=1\,\mathrm{ms}</math> 

:<math>U_m = 0\,\mathrm{V} + (5\,\mathrm{V} - 0\,\mathrm{V}) \cdot \frac{3\,\mathrm{ms}}{3\,\mathrm{ms}+1\,\mathrm{ms}} = 3,75\,\mathrm{V}</math>

[[Bild:Pwm1.png]]

</td></tr><tr><td style="padding: 10px;">

'''Beispiel 2'''

<math>U_{ein}=5\,\mathrm{V}</math> 
<math>U_{aus}=0\,\mathrm{V}</math> 
<math>t_{ein}=1\,\mathrm{ms}</math> 
<math>t_{aus}=3\,\mathrm{ms}</math> 

:<math>U_m = 0\,\mathrm{V} + (5\,\mathrm{V} - 0\,\mathrm{V}) \cdot \frac{1\,\mathrm{ms}}{1\,\mathrm{ms}+3\,\mathrm{ms}} = 1,25\,\mathrm{V}</math> 

[[Bild:Pwm2.png]]
</td></tr></table>
 

Die blaue Linie in der Grafik zeigt den mathematischen Mittelwert der sich einstellenden Spannung, wenn jeweils eine volle Periode der PWM betrachtet wird. In der Realität schwankt der Wert je nach Beobachtungsfester und in der praktischen Umsetzung besonders, da es keine perfekte Mittelung gibt.

=== Leistungsberechnung ===

Steuert man mit einem pulsweitenmodulierten Signal direkt einen ohmschen Verbraucher an (z. B. Heizdraht), so ist darauf zu achten, dass man zur Bestimmung der Leistung '''nicht''' einfach

:<math>P = \frac{{U_m}^2}{R}</math>

rechnen darf, sondern die Leistung während der Ein- und Ausschaltzeit getrennt betrachten muss:

:<math>P = \frac{{U_{ein}}^2}{R} \cdot \frac{t_{ein}}{t_{ein} + t_{aus}} +
\frac{{U_{aus}}^2}{R} \cdot \frac{t_{aus}}{t_{ein} + t_{aus}}</math>

Da vereinfacht gilt <math>U_{aus}=0V</math> sowie <math>U_{ein}=V_{CC}</math>

kann man schreiben und damit rechnen. Mit Regelfall muss die Verlustleistung des Schaltelementes mitberücksichtigt werden. Bei Halbleitern ist das jeweils abhängig von Ron / Roff und den sich ergebenden Differenzen zur Rail-Spannung.

:<math>P = \frac {{V_{CC}}^2}{R} \cdot DC = P_{max} \cdot DC</math>

Für die Spannung muss der Effektivwert berechnet werden, mit der kann man dann auch wieder die Leistung direkt berechnen.

:<math>U_{eff} = V_{CC} \cdot \sqrt{DC} </math>.
:<math>P = \frac{{U_{eff}}^2}{R}</math>

== Anwendungen (Kleinsignal) ==

=== AD-Wandlung mit PWM ===
Der folgende Tipp stammt noch aus der Zeit, als es keinen Mikroprozessor mit AD-Wandler gab.

Einen recht billigen und einfachen AD-Wandler mit "1-Draht Kommunikation" kann man mit dem IC 556 (NE556 o.ä.) realisieren: der eine Timer des 556 arbeitet als 50% duty-cycle Rechteckgenerator bei beispielsweise 1 kHz und steuert den zweiten Timer an. Dieser besitzt einen Steuereingang zu Beeinflussung des Tastverhältnisses und auf diesen Pin gibt man das analoge Signal. Ein angeschlossener µC oder PC misst bei jedem Impuls die Impulslänge und man erhält so das Messergebnis. Bei einer Frequenz von >10 kHz liesse sich sogar Sprache digital übertragen oder speichern. Allerdings ist dafür eine Auflösung von wenigstens 8 Bit nötig, wodurch 256 Stufen und eine entsprechemde Abstatfrequenz durch den Chip gefordert sind. Ohne Chip lässt sich dies nur mit eimem Logikbaustein und etwas Signalverarbeitung lösen, siehe [[Analog-IO mit digitalen Bausteinen]].

Für anspruchsvollere Aufgaben verwendet man jedoch besser die [[Pulsdichtemodulation]].

=== DA-Wandlung mit PWM ===

Die meisten Mikrocontroller haben keine DA-Wandler integriert, da diese relativ aufwändig sind. Allerdings kann man mittels eines PWM-Ausgangs auch eine DA-Wandlung vornehmen und eine Gleichspannung bereitstellen. Wird ein PWM-Signal über einen Tiefpass gefiltert (geglättet), entsteht eine Gleichspannung mit Wechselanteil, deren Mittelwert dem des PWM-Signals entspricht und dessen Wechselanteil von der Beschaltung abhängig ist. Nun bleibt das Problem der Dimensionierung des Tiefpasses. Ein Beispiel:

PWM-Takt 1 MHz, 8 Bit Auflösung (256 Stufen), 0/5V.
-> 3906 Hz PWM Frequenz

RC-Tiefpass 22nF, 100kΩ
-> 72 Hz Grenzfrequenz

(Die Grenzfrequenz errechnet sich über <math>f_c=\frac{1}{2\,\pi\,R\cdot C}</math> .)

[[bild:pwm_filter_1.png]]

Bei diesem Tiefpass mit 72 Hz Bandbreite verbleibt am Ausgang noch ein Ripple auf der Gleichspannung, da die PWM nie ideal gefiltert werden kann. Eine Rechnung bzw. Simulation in PSPICE zeigen ca. 150mV Ripple. Das ist ziemlich viel, da ein idealer 8-Bit DA-Wandler bei 5V Referenzspannung eine Auflösung von 20mV hat. Wir haben hier also ein Störsignal von 150mV/20mv=7,5 LSB. Um den Ripple bis auf die Auflösungsgrenze von 20mV zu reduzieren, muss die Grenzfrequenz auf ca. 10 Hz reduziert werden. Es ist somit effektiv nur ein 390tel der PWM-Frequenz nutzbar. Das ist für einige Anwendungen ausreichend, wo praktisch nur statische Gleichspannungen erzeugt werden sollen, z. B. für programmierbare Netzteile. Für Anwendungen, in denen schneller ändernde Gleichspannungen generiert werden sollen, muss die PWM-Frequenz entsprechend erhöht werden oder ein steilerer Tiefpaß verwendet werden.

==== RC-Filter dimensionieren ====

Allgemein kann man den Ripple eines einfachen RC-Tiefpasses so abschätzen:

Kritischster Punkt ist eine PWM mit 50% Tastverhältnis. Dabei tritt der
stärkste absolute Ripple auf, weil hier die - am weinigsten gefilterte - Grundschwigung die höchste Amplitude besitzt. Bei diesem Tastverhältnis ist der Kondensator auf 1/2 VCC aufgeladen. Somit liegt auch 1/2 VCC über dem R an und lädt C annähernd mit Konstantstrom.

<math>I = \frac{\frac{1}{2}Vcc}{R}</math>

Über die Definition des Kondensators kann man den Ripple berechnen.

<math>C = \frac{I \cdot t}{U}; [F = \frac{As}{V}]</math>

<math>U = \frac{I \cdot t}{C}</math>

Die Ladung in As (Amperesekunden) ergeben sich aus der halben PWM-Periode mal I. Damit kann man brauchbar den Ripple abschätzen.

<math>V_{Ripple} = \frac{\frac {\frac{1}{2}Vcc}{R} \cdot \frac{1}{2}T_{PWM}}{C} = \frac{ Vcc \cdot T_{PWM}}{4RC}</math>

Die Einschwingzeit <math>\!\,t_S</math> des Signals bei einem neuen PWM-Wert beträgt etwa <math>\!\,5RC</math>.

Die Abschätzung gilt aber nur dann, wenn der Ausgang des RC-Filter kaum belastet ist, wie z. B. durch einen Operationsverstärker oder einen andern hochohmigen IC-Eingang.

Beispiel:

100 Hz PWM Frequenz(T_PWM=10ms), R=100kΩ, C=1μF, Vcc=5V

<math>V_{Ripple} = \frac{5V \cdot 10ms}{4 \cdot 100k\Omega \cdot 1 \mu F} = 125 mV</math> 
<math>t_s=5RC=5 \cdot 100k \Omega \cdot 1 \mu F = 500ms</math>

Um die Bandbreite besser auszunutzen wird ein besseres Filter benötigt. Das Problem des einfachen RC-Tiefpasses ist der relativ langsame Anstieg der Dämpfung oberhalb der Grenzfrequenz. Genauer gesagt steigt die Dämpfung mit 20dB/Dekade. Das heisst, dass ein Signal mit der 10fachen Frequenz (Dekade) um den Faktor 10 (20dB) gedämpft wird. Will man nun eine höhere Dämpfung ereichen, müssen mehrere Tiefpässe in Reihe geschaltet werden. Bei dem gleichen Beispiel erreicht man mit zwei Tiefpässen mit 6,8nF/100kΩ eine Grenzfrequenz von ca. 70 Hz, bei gleicher Dämpfung des Ripples auf 20mV. Die Dämpfung dieses sogenannten Tiefpasses 2. Ordnung beträgt 40dB/Dekade. Das heisst, ein Signal mit zehnfacher Frequenz (Dekade) wird um den Faktor 100 (40dB) gedämpft! Damit erzielt man hier bereits die 7fache Bandbreite! Zum Schluss muss beachtet werden, dass die passiven Tiefpässe nur sehr schwach belastet werden können. Hier ist fast immer ein Operationsverstärker als Spannungsfolger nötig, falls der Eingangswiderstand der nachfolgenden Schaltung in der Größenordnung der beiden Widerstände des Filters ist. Der kann auch genutzt werden, um das gefilterte Signal weiter zu verstärken (nichtinvertierender Verstärker).

[[bild:pwm_filter_2.png]]

Geschickter wäre hier eine Widerstandsdimensionierung, bei der R3 etwas größer ist als R2, da somit das zweite RC-Glied das erste weniger belastet.

Mehr Informationen zur Restwelligkeit bei RC Tiefpässen kann man [http://www.mikrocontroller.net/topic/181033#1747063 diesem] Thread entnehmen.

Das Spiel kann noch um einiges gesteigert werden, wenn man Tiefpässe dritter, vierter und noch höherer Ordung einsetzt. Das wird vor allem im Audiobereich gemacht. Dazu werden praktisch Operationsverstärker eingesetzt. In der [[AVR]] Application-Note [http://www.atmel.com/dyn/resources/prod_documents/doc1456.pdf AVR335: Digital Sound Recorder with AVR and DataFlash] wird zum Beispiel ein mit Operationsverstärkern aufgebauter Chebychev-Tiefpass fünfter Ordnung verwendet. Man findet im Audiobereich gelegentlich auch Schaltungen ohne expliziten Tiefpass. Dabei wird der Ausgang eines Class-D Verstärkers (der nichts anderes als ein PWM-Signal erzeugt) über einen Widerstand auf einen Lautsprecher gegeben. Die mechanische Trägheit und die Induktivität der Lautsprecherspule bilden mit dem Widerstand einen Tiefpass.

==== Vollintegrierte Lösungen ====

Wer all den Aufwand nicht betreiben will kauft einen fix und fertigen IC wie z.B.

*[http://www.linear.com/product/LTC2644 LTC2644] von Linear Technology
*[http://www.linear.com/product/LTC2645 LTC2645] von Linear Technology

== Anwendungen (Leistung) ==
Bei geeigneten Verstärkerstufen können PWM-Signale auch direkt zur Versorgung und Steuerung von Verbrauchern genutzt werden:

=== Schaltnetzteil (Generator)===
PWM-Stufen sind ein integraler Bestandteil praktisch aller heute verfügbarer Schaltnetzteile. Nur durch die digitale, pulsartige Entnahme der Ladung aus dem Versorgungsnetz lassen sich mittlere und höhere Leistungen noch effektiv und verlustarm beziehen. Die PWM wird dabei von einer Steuereinheit getrieben, welche die aktuelle Versorgungspannung in Betracht zieht, bzw. auch den Strombedarf des angeschlossenen Verbrauchers berücksichtigt. Damit lassen sich sowohl einfach passive und aktive Phasenanschnittversorgungen realisieren, aber auch voll geregelte Leistungsnetzteile mit sehr geringen effektiven Innenwiderständen aufbauen.

=== Heizung (ohmscher Verbraucher)===
Eine Heizung (Beispiel) mit 10Ω-Widerstand soll mit bis zu 12 V angesteuert werden. Dazu wird ein 13 V-Netzteil sowie ein linearer Verstärker verwendet (ein linearer Verstärker braucht immer eine etwas höhere Betriebsspannung als die maximale Ausgangsspannung).

Sollen nun 12 V auf die Heizung gegeben werden, fällt (fast) die gesamte Spannung über der Heizung selber ab, der Verstärker "verbraucht" nur 1 V. Es fließen ca. 1,2 A, es werden ca. 14,4 W in der Heizung in Wärme umgesetzt, im Verstärker ca. 1,2 W, der Wirkungsgrad beträgt 92%.

Wenn jetzt aber nur noch 6 V an der Heizung anliegen sollen, muss der lineare Verstärker die "übrigen" 7 V verbrauchen, d.h. von den 13 V, welche konstant vom Netzteil geliefert werden, fallen 7 V über dem Verstärker und 6 V über der Heizung ab. Die Transistoren des linearen Verstärkers sind nur halb durchgesteuert. Es fließt ein Strom von ca. 600 mA, in der Heizung werden ca. 3,6 W in Wärme umgesetzt. Allerdings werden auch 4,2 W im Verstärker in Wärme umgesetzt! Der Wirkungsgrad ist nur noch 46%!

Im Gegensatz dazu sind bei einer PWM die Transistoren des digitalen Verstärkers immer nur entweder voll durchgesteuert oder gar nicht durchgesteuert. Im ersteren Fall fällt nur eine geringe Verlustleistung über dem Transistor ab, da die Sättigungsspannung <math>V_{SAT}</math> sehr gering ist (meist weniger als 1 V). Im zweiten Fall fällt gar keine Verlustleistung über dem Transistor ab, da kein Strom fließt (P=U*I). Im Fall der 6 V an der Heizung beträgt das notwendige Tastverhältnis 0,23. D.h. nur während 23% der PWM-Periode wird Verlustleistung im digitalen Verstärker erzeugt und zwar ca.

:<math>P_V=DC \cdot \frac {V_{CC}}{R} \cdot V_{SAT} = 0{,}23 \cdot \frac {12V}{10\Omega} \cdot 1V = 0{,}28 W</math>

Der Wirkungsgrad liegt bei 92%!

=== Lautsprecher (induktiv) ===
Immer häufiger werden Lautsprecher direkt an digitalen Leistungsverstärkern betrieben. Dabei wird Impedanz des Verbrauchers als Tiefpass verwednet. Diese besteht hauptsächlich aus der Induktivität und den geringen ohmschen Widerständen des Ausgangstreibers, der Leitungen und der Wicklungen im Lautsprecher. Bei PWM-Signalen müssen hierbei jedoch sehr hohe Frequenzen gewählt werden, um Audiosignale in akzeptabler Qualität zu repräsentieren. Auch muss das Signal oft nichtlinear vorverzerrt werden, um zu einem letzlich linearen Verhalten des Verbrauchers zu führen (siehe 1-Bit-Audio). Für professionelle Audioanwendungen greift man bei digitalen Verstärkern daher auf andere Modulationsverfahren wie COM oder ADPCM (Pulsdichtemodulation) zurück. Für einfache Applikationen und geringe Leistungen ist dies aber eine sehr interessante Option.

=== Motorsteuerung (ohmsch-Induktiv) ===
Eine der wichtigsten Anwendungen für PWM-Stufen ist die direkte Ansteuerung von Motoren. Der große Vorteil von PWM ist auch hier wieder der hohe Wirkungsgrad. Würde man stattdessen einen Digital-Analog-Wandler mit einem nachgeschalteten analogen Verstärker zur Ansteuerung verwenden, würde im Verstärker eine höhere Verlustleistung in Wärme umgewandelt werden. Ein digitaler Verstärker mit PWM hat dagegen geringere Verluste. Die Nachteile der Oberwellen im Signal spielen bei der Motorentechnik in der Regel keine Rolle, da hier noch mechanische Trägheiten zur effektiven Glättung beitragen. Die verwendete Frequenz liegt meist im Bereich von einigen 10kHz. Zur Berechnung der Drehzahl eines Motors kann im Normalfall der Mittelwert der PWM-Spannung als Betriebsspannung angenommen werden.

Bei Leistungsanwendungen spielen die Transienten der ansteuernden Rechteckimpulse jedoch dahingehend eine Rolle, dass sie die Verluste der Schaltelemente (MOSFETs) in die Höhe treiben und die ungefilterten Anteile in den Motoren zu Schwingungen führen, weil Resonanzen angeregt werden können.

=== Dimmen von Leuchtmitteln (ohmsch - kapazitiv) ===
Eine spezielle Form der PWM-Anwendung ist die Helligkeitssteuerung. Bei kapazitiven Verbauchern wie Leuchtstoffröhren müssen besondere Randbedingungen beachtet werden, um ein Dimmen zu erzielen. So sind besondere Frequenzen und Anlaufphasen zu applizieren. Mache Verbaucher lassen sich trotzdem überhaupt nicht dimmen. Bei überwiegend ohmschen Verbrauchen wie z.B. Glühbirnen oder Halbleiter-Leuchtdioden, sind die PWM-Signale aber ohne große Regelung anwendbar.

Siehe Artikel:
* [[LED-Fading]] - LED dimmen mit PWM

== Oft gestellte Fragen (FAQ) ==

=== Mit welcher Frequenz dimmt man? ===

Eine gegebene Antwort dazu war: Bei Glühlampen kannst Du alles über 20Hz nehmen. Die sind derart träge... Über 9kHz sollte man wegen [[EMV]] nicht gehen. Für [[LED]]s ist alles über 1kHz und unter 9kHz gut. (Autor: Travel Rec. (travelrec), Datum: 27.12.2008 11:32)

Dazu ist jedoch zu sagen, daß PWM-Steuerungen bei Glühlampen meisten verwendet werden, um die 50Hz-Thematik zu umgehen. Dabei ist das Brummen relevant und auch ein Blinken bei sehr geringen Frequenzen. Typischerweise wird man daher eher 200Hz aufwärts verwenden. Umgekehrt sind Stromkabel nicht geschirmt und besitzen eine gewisse Kapazität, was Frequenzen im kHz-Bereich nicht sinnvoll erscheinen läßt. Auch LEDs wirken bei hohen Frequenzen kapazitiv, was zu einer unnötigen Strombelastung führt. Ist die LED für Belichtungsaufgaben relevant ist die Dimmungsfrequenz genügend hoch zu wählen, um gegenüber kurzen Belichtungen irrelvant zu sein. Dies ist in der Regel ab 10kHz der Fall. Um bei hohen Strömen einen unnötigen Stossstrom zu vermeiden und damit die LEDs besser ausnutzen zu können - kann eine Drossel mit geringer Induktivität sinnvoll sein, die die Anstiege begrenzt.

=== Wie schätze ich die Verlustleistung am MOSFET im PWM Betrieb ab? ===

[http://www.mikrocontroller.net/topic/190878#1862634 Beitrag von Falk]:

Vereinfacht kann man sagen, dass während der Umschaltzeit die Verlustleistung am MOSFET = 1/4 der Verlustleistung am Verbraucher ist, wenn der eingeschaltet ist (Leistungsanpassung).

Beispiel: 150 Hz PWM = 6,6ms, Schaltzeit 500ns, Verbraucher 60W. Macht 15W Verlust während der zwei Umschaltungen pro Takt, sprich 2x500ns = 1µs. Aber das nur alle 6,6ms, Im Mittel macht das 1us/6,6ms*15W = 2,2mW. Glück gehabt ;-) Bei hohen PWM-Frequenzen im Bereich 20-500kHz, wie sie heute bei Schaltnetzteilen üblich sind, kommt da aber schon richtig viel zusammen.

Etwas genauer: [https://www.mikrocontroller.net/articles/FET#Schalt-Verluste Schaltverluste beim FET]

== Siehe auch ==
* [[Pulsdichtemodulation]]
* [[AVR-Tutorial: PWM]]
* [[AVR-GCC-Tutorial#PWM (Pulsweitenmodulation)|AVR-GCC-Tutorial: PWM]]
* [[Soft-PWM]]
* [[Motoransteuerung mit PWM]]
* [[LED-Fading]]
* [[AVR PWM]]
* [[Ambilight in Hardware]]
* [[Glättungsfilter für 1-Bit DA-Wandlung|1-Bit Digital-Analog-Wandlung]]
* [https://www.mikrocontroller.net/topic/361429#4054456 Forumsbeitrag]: Audioausgabe mit PWM
* [https://www.mikrocontroller.net/topic/291069?goto=3098563#3101588 Forumsbeitrag]: SPWM auf Atmega8, bitte um Feedback hinsichtlich Optimierung
* [https://www.mikrocontroller.net/topic/397337?goto=4590784#4575721 Forumsbeitrag]: H-Bridge 50Hz Sinus - LC Filter dimensionieren
* [https://www.mikrocontroller.net/topic/385654#4410160 Forumsbeitrag]: Arduino Mega 11 PWM-Pins mit 1kHz
* [https://www.mikrocontroller.net/topic/453218#5454730 Forumsbeitrag]: Sprung in der PWM-Kennlinie beim ATtiny85 und Timer 1
* [https://www.mikrocontroller.net/topic/455707?goto=5494022#5494022 Forumsbeitrag]: PWM Filter für 480 Hz aus dem Arduino
* [https://www.mikrocontroller.net/topic/533766?goto=7013634#7013634 Forumsbeitrag]: Arduino Micro SPWM

[[Kategorie:Signalverarbeitung]]
[[Kategorie:Leistungselektronik]]

== Weblinks ==
*[http://www.solar-webshop.de/blog/pwm-puls-weiten-modulation-solar/ Was bedeutet PWM?]
*[http://pic-projekte.de/wiki/index.php?title=PIC_Tutorial#Pulsweitenmodulation_.28PWM.29 PWM Modul am PIC]
*[http://www.batsocks.co.uk/readme/art_bcm_1.htm Binary Code Modulation] - Eine Alternative zu PWM?
*[https://www.youtube.com/watch?v=98si4uLcCpc Was ist PWM ? Mit Review], Video (deutsch)
*[https://www.youtube.com/watch?v=SfSI3L5M94A Ripple cancelation in PWM DAC], Video (englisch)

Pulsweitenmodulation

2023-10-28T20:32:46Z

Elektroschlumpf: werbung des mitbewerbers entfernt

== Einleitung ==

Bei der '''Pulsweitenmodulation''' (engl. Pulse Width Modulation, abgekürzt '''PWM'''), teilweise auch Puls-Dauer-Modulation, wird das Verhältnis zwischen der Einschaltzeit und Periodendauer eines Rechtecksignals bei fester Grundfrequenz variiert. Das Verhältnis zwischen der Einschaltzeit <math>t_{ein}</math> und der Periodendauer <math> T = t_{ein} + t_{aus} </math> wird als das Tastverhältnis '''p''' bezeichnet. (laut DIN IEC 60469-1: Tastgrad) (engl. Duty Cycle, meist abgekürzt DC, nicht zu verwechseln mit Direct Current = Gleichstrom ).

Die Pulsweitenmodulation für ein Signal <math> x(t) </math> ist für die Dauer einer Periode im Intervall [0,T] wie folgt definiert:

<math> x(t) = \left\{\begin{array}{l l}
0 & \quad t < t_1 \\
1 & \quad t \ge t_1 \\
0 & \quad t > T
\end{array} \right.
</math>

[[Bild:pwmdoc.png]]

<math> p = \dfrac{t_{ein}}{T} = \dfrac{t_{ein}}{t_{ein}+t_{aus}} </math>

Der Wert des Tastverhältnis '''p''' kann dabei Werte zwischen 0 und 100% annehmen.

Der zeitliche '''Mittelwert''' der Spannung <math>U(t)</math> innerhalb eines Intervalls [0,T] ist unten stehend beschrieben.

:<math>U_m = \frac{1}{T} \int_0^T u(t)dt = \frac{1}{T}\int_0^{t_{ein}} U_{ein}dt + \frac{1}{T} \int_{t_{ein}}^T U_{aus}dt</math>

:<math>U_m = U_{aus} + (U_{ein} - U_{aus}) \cdot \frac{t_{ein}}{t_{ein}+t_{aus}}</math>

<math>U_{aus}</math> ist dabei normalerweise 0V, <math>U_{ein}</math> die Betriebsspannung <math>V_{CC}</math>, z. B. 5V. Deshalb kann man vereinfacht schreiben:

:<math>U_m = V_{CC} \cdot \frac{t_{ein}}{t_{ein}+t_{aus}} = V_{CC} \cdot DC</math>.

=== Beispiele ===

Die folgenden Beispiele zeigen PWM-Signale mit einem Tastverhältnis von 75% bzw. 25%.

<table border="1"><tr><td style="padding: 10px;">
'''Beispiel 1'''

<math>U_{ein}=5\,\mathrm{V}</math> 
<math>U_{aus}=0\,\mathrm{V}</math> 
<math>t_{ein}=3\,\mathrm{ms}</math> 
<math>t_{aus}=1\,\mathrm{ms}</math> 

:<math>U_m = 0\,\mathrm{V} + (5\,\mathrm{V} - 0\,\mathrm{V}) \cdot \frac{3\,\mathrm{ms}}{3\,\mathrm{ms}+1\,\mathrm{ms}} = 3,75\,\mathrm{V}</math>

[[Bild:Pwm1.png]]

</td></tr><tr><td style="padding: 10px;">

'''Beispiel 2'''

<math>U_{ein}=5\,\mathrm{V}</math> 
<math>U_{aus}=0\,\mathrm{V}</math> 
<math>t_{ein}=1\,\mathrm{ms}</math> 
<math>t_{aus}=3\,\mathrm{ms}</math> 

:<math>U_m = 0\,\mathrm{V} + (5\,\mathrm{V} - 0\,\mathrm{V}) \cdot \frac{1\,\mathrm{ms}}{1\,\mathrm{ms}+3\,\mathrm{ms}} = 1,25\,\mathrm{V}</math> 

[[Bild:Pwm2.png]]
</td></tr></table>
 

Die blaue Linie in der Grafik zeigt den mathematischen Mittelwert der sich einstellenden Spannung, wenn jeweils eine volle Periode der PWM betrachtet wird. In der Realität schwankt der Wert je nach Beobachtungsfester und in der praktischen Umsetzung besonders, da es keine perfekte Mittelung gibt.

=== Leistungsberechnung ===

Steuert man mit einem pulsweitenmodulierten Signal direkt einen ohmschen Verbraucher an (z. B. Heizdraht), so ist darauf zu achten, dass man zur Bestimmung der Leistung '''nicht''' einfach

:<math>P = \frac{{U_m}^2}{R}</math>

rechnen darf, sondern die Leistung während der Ein- und Ausschaltzeit getrennt betrachten muss:

:<math>P = \frac{{U_{ein}}^2}{R} \cdot \frac{t_{ein}}{t_{ein} + t_{aus}} +
\frac{{U_{aus}}^2}{R} \cdot \frac{t_{aus}}{t_{ein} + t_{aus}}</math>

Da praktisch fast immer gilt <math>U_{aus}=0V</math> sowie <math>U_{ein}=V_{CC}</math>

kann man vereinfacht schreiben und damit rechnen.

:<math>P = \frac {{V_{CC}}^2}{R} \cdot DC = P_{max} \cdot DC</math>

Für die Spannung muss der Effektivwert berechnet werden, mit der kann man dann auch wieder die Leistung direkt berechnen.

:<math>U_{eff} = V_{CC} \cdot \sqrt{DC} </math>.
:<math>P = \frac{{U_{eff}}^2}{R}</math>

== Anwendungen (Kleinsignal) ==

=== AD-Wandlung mit PWM ===
Der folgende Tipp stammt noch aus der Zeit, als es keinen Mikroprozessor mit AD-Wandler gab.

Einen recht billigen und einfachen AD-Wandler mit "1-Draht Kommunikation" kann man mit dem IC 556 (NE556 o.ä.) realisieren: der eine Timer des 556 arbeitet als 50% duty-cycle Rechteckgenerator bei beispielsweise 1 kHz und steuert den zweiten Timer an. Dieser besitzt einen Steuereingang zu Beeinflussung des Tastverhältnisses und auf diesen Pin gibt man das analoge Signal. Ein angeschlossener µC oder PC misst bei jedem Impuls die Impulslänge und man erhält so das Messergebnis. Bei einer Frequenz von >10 kHz liesse sich sogar Sprache digital übertragen oder speichern. Allerdings ist dafür eine Auflösung von wenigstens 8 Bit nötig, wodurch 256 Stufen und eine entsprechemde Abstatfrequenz durch den Chip gefordert sind. Ohne Chip lässt sich dies nur mit eimem Logikbaustein und etwas Signalverarbeitung lösen, siehe [[Analog-IO mit digitalen Bausteinen]].

Für anspruchsvollere Aufgaben verwendet man jedoch besser die [[Pulsdichtemodulation]].

=== DA-Wandlung mit PWM ===

Die meisten Mikrocontroller haben keine DA-Wandler integriert, da diese relativ aufwändig sind. Allerdings kann man mittels eines PWM-Ausgangs auch eine DA-Wandlung vornehmen und eine Gleichspannung bereitstellen. Wird ein PWM-Signal über einen Tiefpass gefiltert (geglättet), entsteht eine Gleichspannung mit Wechselanteil, deren Mittelwert dem des PWM-Signals entspricht und dessen Wechselanteil von der Beschaltung abhängig ist. Nun bleibt das Problem der Dimensionierung des Tiefpasses. Ein Beispiel:

PWM-Takt 1 MHz, 8 Bit Auflösung (256 Stufen), 0/5V.
-> 3906 Hz PWM Frequenz

RC-Tiefpass 22nF, 100kΩ
-> 72 Hz Grenzfrequenz

(Die Grenzfrequenz errechnet sich über <math>f_c=\frac{1}{2\,\pi\,R\cdot C}</math> .)

[[bild:pwm_filter_1.png]]

Bei diesem Tiefpass mit 72 Hz Bandbreite verbleibt am Ausgang noch ein Ripple auf der Gleichspannung, da die PWM nie ideal gefiltert werden kann. Eine Rechnung bzw. Simulation in PSPICE zeigen ca. 150mV Ripple. Das ist ziemlich viel, da ein idealer 8-Bit DA-Wandler bei 5V Referenzspannung eine Auflösung von 20mV hat. Wir haben hier also ein Störsignal von 150mV/20mv=7,5 LSB. Um den Ripple bis auf die Auflösungsgrenze von 20mV zu reduzieren, muss die Grenzfrequenz auf ca. 10 Hz reduziert werden. Es ist somit effektiv nur ein 390tel der PWM-Frequenz nutzbar. Das ist für einige Anwendungen ausreichend, wo praktisch nur statische Gleichspannungen erzeugt werden sollen, z. B. für programmierbare Netzteile. Für Anwendungen, in denen schneller ändernde Gleichspannungen generiert werden sollen, muss die PWM-Frequenz entsprechend erhöht werden oder ein steilerer Tiefpaß verwendet werden.

==== RC-Filter dimensionieren ====

Allgemein kann man den Ripple eines einfachen RC-Tiefpasses so abschätzen:

Kritischster Punkt ist eine PWM mit 50% Tastverhältnis. Dabei tritt der
stärkste absolute Ripple auf, weil hier die - am weinigsten gefilterte - Grundschwigung die höchste Amplitude besitzt. Bei diesem Tastverhältnis ist der Kondensator auf 1/2 VCC aufgeladen. Somit liegt auch 1/2 VCC über dem R an und lädt C annähernd mit Konstantstrom.

<math>I = \frac{\frac{1}{2}Vcc}{R}</math>

Über die Definition des Kondensators kann man den Ripple berechnen.

<math>C = \frac{I \cdot t}{U}; [F = \frac{As}{V}]</math>

<math>U = \frac{I \cdot t}{C}</math>

Die Ladung in As (Amperesekunden) ergeben sich aus der halben PWM-Periode mal I. Damit kann man brauchbar den Ripple abschätzen.

<math>V_{Ripple} = \frac{\frac {\frac{1}{2}Vcc}{R} \cdot \frac{1}{2}T_{PWM}}{C} = \frac{ Vcc \cdot T_{PWM}}{4RC}</math>

Die Einschwingzeit <math>\!\,t_S</math> des Signals bei einem neuen PWM-Wert beträgt etwa <math>\!\,5RC</math>.

Die Abschätzung gilt aber nur dann, wenn der Ausgang des RC-Filter kaum belastet ist, wie z. B. durch einen Operationsverstärker oder einen andern hochohmigen IC-Eingang.

Beispiel:

100 Hz PWM Frequenz(T_PWM=10ms), R=100kΩ, C=1μF, Vcc=5V

<math>V_{Ripple} = \frac{5V \cdot 10ms}{4 \cdot 100k\Omega \cdot 1 \mu F} = 125 mV</math> 
<math>t_s=5RC=5 \cdot 100k \Omega \cdot 1 \mu F = 500ms</math>

Um die Bandbreite besser auszunutzen wird ein besseres Filter benötigt. Das Problem des einfachen RC-Tiefpasses ist der relativ langsame Anstieg der Dämpfung oberhalb der Grenzfrequenz. Genauer gesagt steigt die Dämpfung mit 20dB/Dekade. Das heisst, dass ein Signal mit der 10fachen Frequenz (Dekade) um den Faktor 10 (20dB) gedämpft wird. Will man nun eine höhere Dämpfung ereichen, müssen mehrere Tiefpässe in Reihe geschaltet werden. Bei dem gleichen Beispiel erreicht man mit zwei Tiefpässen mit 6,8nF/100kΩ eine Grenzfrequenz von ca. 70 Hz, bei gleicher Dämpfung des Ripples auf 20mV. Die Dämpfung dieses sogenannten Tiefpasses 2. Ordnung beträgt 40dB/Dekade. Das heisst, ein Signal mit zehnfacher Frequenz (Dekade) wird um den Faktor 100 (40dB) gedämpft! Damit erzielt man hier bereits die 7fache Bandbreite! Zum Schluss muss beachtet werden, dass die passiven Tiefpässe nur sehr schwach belastet werden können. Hier ist fast immer ein Operationsverstärker als Spannungsfolger nötig, falls der Eingangswiderstand der nachfolgenden Schaltung in der Größenordnung der beiden Widerstände des Filters ist. Der kann auch genutzt werden, um das gefilterte Signal weiter zu verstärken (nichtinvertierender Verstärker).

[[bild:pwm_filter_2.png]]

Geschickter wäre hier eine Widerstandsdimensionierung, bei der R3 etwas größer ist als R2, da somit das zweite RC-Glied das erste weniger belastet.

Mehr Informationen zur Restwelligkeit bei RC Tiefpässen kann man [http://www.mikrocontroller.net/topic/181033#1747063 diesem] Thread entnehmen.

Das Spiel kann noch um einiges gesteigert werden, wenn man Tiefpässe dritter, vierter und noch höherer Ordung einsetzt. Das wird vor allem im Audiobereich gemacht. Dazu werden praktisch Operationsverstärker eingesetzt. In der [[AVR]] Application-Note [http://www.atmel.com/dyn/resources/prod_documents/doc1456.pdf AVR335: Digital Sound Recorder with AVR and DataFlash] wird zum Beispiel ein mit Operationsverstärkern aufgebauter Chebychev-Tiefpass fünfter Ordnung verwendet. Man findet im Audiobereich gelegentlich auch Schaltungen ohne expliziten Tiefpass. Dabei wird der Ausgang eines Class-D Verstärkers (der nichts anderes als ein PWM-Signal erzeugt) über einen Widerstand auf einen Lautsprecher gegeben. Die mechanische Trägheit und die Induktivität der Lautsprecherspule bilden mit dem Widerstand einen Tiefpass.

==== Vollintegrierte Lösungen ====

Wer all den Aufwand nicht betreiben will kauft einen fix und fertigen IC wie z.B.

*[http://www.linear.com/product/LTC2644 LTC2644] von Linear Technology
*[http://www.linear.com/product/LTC2645 LTC2645] von Linear Technology

== Anwendungen (Leistung) ==
Bei geeigneten Verstärkerstufen können PWM-Signale auch direkt zur Versorgung und Steuerung von Verbrauchern genutzt werden:

=== Schaltnetzteil (Generator)===
PWM-Stufen sind ein integraler Bestandteil praktisch aller heute verfügbarer Schaltnetzteile. Nur durch die digitale, pulsartige Entnahme der Ladung aus dem Versorgungsnetz lassen sich mittlere und höhere Leistungen noch effektiv und verlustarm beziehen. Die PWM wird dabei von einer Steuereinheit getrieben, welche die aktuelle Versorgungspannung in Betracht zieht, bzw. auch den Strombedarf des angeschlossenen Verbrauchers berücksichtigt. Damit lassen sich sowohl einfach passive und aktive Phasenanschnittversorgungen realisieren, aber auch voll geregelte Leistungsnetzteile mit sehr geringen effektiven Innenwiderständen aufbauen.

=== Heizung (ohmscher Verbraucher)===
Eine Heizung (Beispiel) mit 10Ω-Widerstand soll mit bis zu 12 V angesteuert werden. Dazu wird ein 13 V-Netzteil sowie ein linearer Verstärker verwendet (ein linearer Verstärker braucht immer eine etwas höhere Betriebsspannung als die maximale Ausgangsspannung).

Sollen nun 12 V auf die Heizung gegeben werden, fällt (fast) die gesamte Spannung über der Heizung selber ab, der Verstärker "verbraucht" nur 1 V. Es fließen ca. 1,2 A, es werden ca. 14,4 W in der Heizung in Wärme umgesetzt, im Verstärker ca. 1,2 W, der Wirkungsgrad beträgt 92%.

Wenn jetzt aber nur noch 6 V an der Heizung anliegen sollen, muss der lineare Verstärker die "übrigen" 7 V verbrauchen, d.h. von den 13 V, welche konstant vom Netzteil geliefert werden, fallen 7 V über dem Verstärker und 6 V über der Heizung ab. Die Transistoren des linearen Verstärkers sind nur halb durchgesteuert. Es fließt ein Strom von ca. 600 mA, in der Heizung werden ca. 3,6 W in Wärme umgesetzt. Allerdings werden auch 4,2 W im Verstärker in Wärme umgesetzt! Der Wirkungsgrad ist nur noch 46%!

Im Gegensatz dazu sind bei einer PWM die Transistoren des digitalen Verstärkers immer nur entweder voll durchgesteuert oder gar nicht durchgesteuert. Im ersteren Fall fällt nur eine geringe Verlustleistung über dem Transistor ab, da die Sättigungsspannung <math>V_{SAT}</math> sehr gering ist (meist weniger als 1 V). Im zweiten Fall fällt gar keine Verlustleistung über dem Transistor ab, da kein Strom fließt (P=U*I). Im Fall der 6 V an der Heizung beträgt das notwendige Tastverhältnis 0,23. D.h. nur während 23% der PWM-Periode wird Verlustleistung im digitalen Verstärker erzeugt und zwar ca.

:<math>P_V=DC \cdot \frac {V_{CC}}{R} \cdot V_{SAT} = 0{,}23 \cdot \frac {12V}{10\Omega} \cdot 1V = 0{,}28 W</math>

Der Wirkungsgrad liegt bei 92%!

=== Lautsprecher (induktiv) ===
Immer häufiger werden Lautsprecher direkt an digitalen Leistungsverstärkern betrieben. Dabei wird Impedanz des Verbrauchers als Tiefpass verwednet. Diese besteht hauptsächlich aus der Induktivität und den geringen ohmschen Widerständen des Ausgangstreibers, der Leitungen und der Wicklungen im Lautsprecher. Bei PWM-Signalen müssen hierbei jedoch sehr hohe Frequenzen gewählt werden, um Audiosignale in akzeptabler Qualität zu repräsentieren. Auch muss das Signal oft nichtlinear vorverzerrt werden, um zu einem letzlich linearen Verhalten des Verbrauchers zu führen (siehe 1-Bit-Audio). Für professionelle Audioanwendungen greift man bei digitalen Verstärkern daher auf andere Modulationsverfahren wie COM oder ADPCM (Pulsdichtemodulation) zurück. Für einfache Applikationen und geringe Leistungen ist dies aber eine sehr interessante Option.

=== Motorsteuerung (ohmsch-Induktiv) ===
Eine der wichtigsten Anwendungen für PWM-Stufen ist die direkte Ansteuerung von Motoren. Der große Vorteil von PWM ist auch hier wieder der hohe Wirkungsgrad. Würde man stattdessen einen Digital-Analog-Wandler mit einem nachgeschalteten analogen Verstärker zur Ansteuerung verwenden, würde im Verstärker eine höhere Verlustleistung in Wärme umgewandelt werden. Ein digitaler Verstärker mit PWM hat dagegen geringere Verluste. Die Nachteile der Oberwellen im Signal spielen bei der Motorentechnik in der Regel keine Rolle, da hier noch mechanische Trägheiten zur effektiven Glättung beitragen. Die verwendete Frequenz liegt meist im Bereich von einigen 10kHz. Zur Berechnung der Drehzahl eines Motors kann im Normalfall der Mittelwert der PWM-Spannung als Betriebsspannung angenommen werden.

Bei Leistungsanwendungen spielen die Transienten der ansteuernden Rechteckimpulse jedoch dahingehend eine Rolle, dass sie die Verluste der Schaltelemente (MOSFETs) in die Höhe treiben und die ungefilterten Anteile in den Motoren zu Schwingungen führen, weil Resonanzen angeregt werden können.

=== Dimmen von Leuchtmitteln (ohmsch - kapazitiv) ===
Eine spezielle Form der PWM-Anwendung ist die Helligkeitssteuerung. Bei kapazitiven Verbauchern wie Leuchtstoffröhren müssen besondere Randbedingungen beachtet werden, um ein Dimmen zu erzielen. So sind besondere Frequenzen und Anlaufphasen zu applizieren. Mache Verbaucher lassen sich trotzdem überhaupt nicht dimmen. Bei überwiegend ohmschen Verbrauchen wie z.B. Glühbirnen oder Halbleiter-Leuchtdioden, sind die PWM-Signale aber ohne große Regelung anwendbar.

Siehe Artikel:
* [[LED-Fading]] - LED dimmen mit PWM

== Oft gestellte Fragen (FAQ) ==

=== Mit welcher Frequenz dimmt man? ===

Eine gegebene Antwort dazu war: Bei Glühlampen kannst Du alles über 20Hz nehmen. Die sind derart träge... Über 9kHz sollte man wegen [[EMV]] nicht gehen. Für [[LED]]s ist alles über 1kHz und unter 9kHz gut. (Autor: Travel Rec. (travelrec), Datum: 27.12.2008 11:32)

Dazu ist jedoch zu sagen, daß PWM-Steuerungen bei Glühlampen meisten verwendet werden, um die 50Hz-Thematik zu umgehen. Dabei ist das Brummen relevant und auch ein Blinken bei sehr geringen Frequenzen. Typischerweise wird man daher eher 200Hz aufwärts verwenden. Umgekehrt sind Stromkabel nicht geschirmt und besitzen eine gewisse Kapazität, was Frequenzen im kHz-Bereich nicht sinnvoll erscheinen läßt. Auch LEDs wirken bei hohen Frequenzen kapazitiv, was zu einer unnötigen Strombelastung führt. Ist die LED für Belichtungsaufgaben relevant ist die Dimmungsfrequenz genügend hoch zu wählen, um gegenüber kurzen Belichtungen irrelvant zu sein. Dies ist in der Regel ab 10kHz der Fall. Um bei hohen Strömen einen unnötigen Stossstrom zu vermeiden und damit die LEDs besser ausnutzen zu können - kann eine Drossel mit geringer Induktivität sinnvoll sein, die die Anstiege begrenzt.

=== Wie schätze ich die Verlustleistung am MOSFET im PWM Betrieb ab? ===

[http://www.mikrocontroller.net/topic/190878#1862634 Beitrag von Falk]:

Vereinfacht kann man sagen, dass während der Umschaltzeit die Verlustleistung am MOSFET = 1/4 der Verlustleistung am Verbraucher ist, wenn der eingeschaltet ist (Leistungsanpassung).

Beispiel: 150 Hz PWM = 6,6ms, Schaltzeit 500ns, Verbraucher 60W. Macht 15W Verlust während der zwei Umschaltungen pro Takt, sprich 2x500ns = 1µs. Aber das nur alle 6,6ms, Im Mittel macht das 1us/6,6ms*15W = 2,2mW. Glück gehabt ;-) Bei hohen PWM-Frequenzen im Bereich 20-500kHz, wie sie heute bei Schaltnetzteilen üblich sind, kommt da aber schon richtig viel zusammen.

Etwas genauer: [https://www.mikrocontroller.net/articles/FET#Schalt-Verluste Schaltverluste beim FET]

== Siehe auch ==
* [[Pulsdichtemodulation]]
* [[AVR-Tutorial: PWM]]
* [[AVR-GCC-Tutorial#PWM (Pulsweitenmodulation)|AVR-GCC-Tutorial: PWM]]
* [[Soft-PWM]]
* [[Motoransteuerung mit PWM]]
* [[LED-Fading]]
* [[AVR PWM]]
* [[Ambilight in Hardware]]
* [[Glättungsfilter für 1-Bit DA-Wandlung|1-Bit Digital-Analog-Wandlung]]
* [https://www.mikrocontroller.net/topic/361429#4054456 Forumsbeitrag]: Audioausgabe mit PWM
* [https://www.mikrocontroller.net/topic/291069?goto=3098563#3101588 Forumsbeitrag]: SPWM auf Atmega8, bitte um Feedback hinsichtlich Optimierung
* [https://www.mikrocontroller.net/topic/397337?goto=4590784#4575721 Forumsbeitrag]: H-Bridge 50Hz Sinus - LC Filter dimensionieren
* [https://www.mikrocontroller.net/topic/385654#4410160 Forumsbeitrag]: Arduino Mega 11 PWM-Pins mit 1kHz
* [https://www.mikrocontroller.net/topic/453218#5454730 Forumsbeitrag]: Sprung in der PWM-Kennlinie beim ATtiny85 und Timer 1
* [https://www.mikrocontroller.net/topic/455707?goto=5494022#5494022 Forumsbeitrag]: PWM Filter für 480 Hz aus dem Arduino
* [https://www.mikrocontroller.net/topic/533766?goto=7013634#7013634 Forumsbeitrag]: Arduino Micro SPWM

[[Kategorie:Signalverarbeitung]]
[[Kategorie:Leistungselektronik]]

== Weblinks ==
*[http://www.solar-webshop.de/blog/pwm-puls-weiten-modulation-solar/ Was bedeutet PWM?]
*[http://pic-projekte.de/wiki/index.php?title=PIC_Tutorial#Pulsweitenmodulation_.28PWM.29 PWM Modul am PIC]
*[http://www.batsocks.co.uk/readme/art_bcm_1.htm Binary Code Modulation] - Eine Alternative zu PWM?
*[https://www.youtube.com/watch?v=98si4uLcCpc Was ist PWM ? Mit Review], Video (deutsch)
*[https://www.youtube.com/watch?v=SfSI3L5M94A Ripple cancelation in PWM DAC], Video (englisch)