Mikrocontroller.net - Benutzerbeiträge [de]

LED-Fading

2010-05-16T20:30:11Z

91.19.247.16: /* Das Demoprogramm */

== Das Problem ==

Die Aufgabe klingt eigentlich recht einfach. Eine [[LED]] soll mittels [[PWM]] in ihrer Helligkeit gesteuert werden. Und weils so schön ist, möchte man sie geheimnisvoll aufleuchten lassen, sprich langsam heller und dunkler werden lassen. Der Fachmann nennt das Fading. Das Problem zeigt sich allerdings recht schnell. Wenn man eine 8-Bit PWM linear zwischen 0..255 laufen lässt, dann scheint die LED nicht linear gedimmt zu werden. Sie wird relativ schnell hell und bleibt lange hell.

== Die Erklärung ==

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 Kennline 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 duch das [http://de.wikipedia.org/wiki/Weber-Fechner-Gesetz Weber-Fechner-Gesetz] beschrieben. Genauere Untersuchungen zur [http://de.wikipedia.org/wiki/Gamma-Korrektur Gammakorrektur] führten jedoch zur [http://de.wikipedia.org/wiki/Stevenssche_Potenzfunktion Stevenschen Potenzfunktion]. Diese beschreibt das menschliche Auge etwas besser. Die Unterschiede sind jedoch marginal. Vorsicht! Der Artikel Gamma-Korrektur in Wikipedia verweist fälschlicherweise auf das Weber-Fechner Gesetz.

Praktisch heißt das, daß 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^{\frac{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 wird in dem unten gezeigten Beispielprogramm gemacht. Dabei wird die Wirkung verschiedener PWM-Auflösungen demonstriert. 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]] (Anmerkung: Bitte die Exceltabelle nochmal erklären, die Werte in der Tabelle stimmen nicht mit denen im Programm überein). 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, als die Königsklasse, eine 16-Bit PWM mit 256 Stufen betrieben.

Das Programm ist ursprünglich auf einem [[AVR]] vom Typ '''ATmega32''' entwickelt und getestet. 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 kOhm an Pin PD5 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 nicht.

Bei Verwendung der LEDs auf dem STK500 bzw. bei der Verwendung von invertierenden Treiberstufen ist das "#define STK500 false" durch "#define STK500 true" 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.

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

#define F_CPU 8000000L

#define true 1
#define false 0

#define STK500 false

#include <inttypes.h>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>

// global variables

uint16_t pwmtable_8A[4] PROGMEM = {0, 16, 64, 255};
uint16_t pwmtable_8B[8] PROGMEM = {0, 4, 8, 16, 32, 64, 128, 255};
uint16_t pwmtable_8C[16] PROGMEM = {0, 2, 3, 4, 6, 8, 11, 16, 23, 32, 45, 64,
90, 128, 181, 255};
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};

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};

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};

// long delays

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

// 8-Bit PWM with only 4 different settings

void pwm_8_4(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC1; // inverted PWM on OC1A, 8 Bit Fast PWM
#else
TCCR1A = 0x81; // non-inverted PWM on OC1A, 8 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 4; // precaler 256 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=3; tmp++){
OCR1A = pgm_read_word(pwmtable_8A+tmp);
my_delay(delay);
}

for(tmp=3; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_8A+tmp);
my_delay(delay);
}
}

// 8-Bit PWM with 8 different settings

void pwm_8_8(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC1; // inverted PWM on OC1A, 8 Bit Fast PWM
#else
TCCR1A = 0x81; // non-inverted PWM on OC1A, 8 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 4; // precaler 256 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=7; tmp++){
OCR1A = pgm_read_word(pwmtable_8B+tmp);
my_delay(delay);
};

for(tmp=7; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_8B+tmp);
my_delay(delay);
}
}

// 8-Bit PWM with 16 different settings

void pwm_8_16(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC1; // inverted PWM on OC1A, 8 Bit Fast PWM
#else
TCCR1A = 0x81; // non-inverted PWM on OC1A, 8 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 4; // precaler 256 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=15; tmp++){
OCR1A = pgm_read_word(pwmtable_8C+tmp);
my_delay(delay);
}

for(tmp=15; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_8C+tmp);
my_delay(delay);
}
}

// 8-Bit PWM with 32 different settings

void pwm_8_32(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC1; // inverted PWM on OC1A, 8 Bit Fast PWM
#else
TCCR1A = 0x81; // non-inverted PWM on OC1A, 8 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 4; // precaler 256 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=31; tmp++){
OCR1A = pgm_read_word(pwmtable_8D+tmp);
my_delay(delay);
}

for(tmp=31; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_8D+tmp);
my_delay(delay);
}
}

// 10-Bit PWM with 64 different settings

void pwm_10_64(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC3; // inverted PWM on OC1A, 10 Bit Fast PWM
#else
TCCR1A = 0x83; // non-inverted PWM on OC1A, 10 Bit Fast PWM
#endif
TCCR1B = 0x08;

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 3; // precaler 64 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=63; tmp++){
OCR1A = pgm_read_word(pwmtable_10+tmp);
my_delay(delay);
}

for(tmp=63; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_10+tmp);
my_delay(delay);
}
}

// 16-Bit PWM with 256 different settings

void pwm_16_256(uint16_t delay){

int16_t tmp;

#if STK500
TCCR1A = 0xC2; // inverted PWM on OC1A, 16 Bit Fast PWM
#else
TCCR1A = 0x82; // non-inverted PWM on OC1A, 16 Bit Fast PWM
#endif
TCCR1B = 0x18;
ICR1 = 0xFFFF; // TOP for PWM, full 16 Bit

TCCR1B &= ~0x7; // clear clk setting
TCCR1B |= 1; // precaler 1 -> ~122 Hz PWM frequency

for(tmp=0; tmp<=255; tmp++){
OCR1A = pgm_read_word(pwmtable_16+tmp);
my_delay(delay);
}

for(tmp=255; tmp>=0; tmp--){
OCR1A = pgm_read_word(pwmtable_16+tmp);
my_delay(delay);
}
}

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

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

// 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;
}
</c>

== Siehe auch ==
* [[PWM]]
* [[AVR-GCC-Tutorial#PWM (Pulsweitenmodulation)|AVR-GCC-Tutorial: PWM]]
* [[Soft-PWM]] - optimierte Software-PWM in C

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

Soft-PWM

2010-05-16T20:29:03Z

91.19.247.16: /* Siehe auch */

== Einleitung ==
[[PWM]] ist eine oft verwendete Funktion auf dem Gebiet der Mikrocontroller. Damit lassen sich vielfältige Aufgaben lösen, wie beispielsweise die Leistungssteuerung von Motoren, Helligkeitssteuerung von [[LED-Fading | LEDs]], [[DA-Wandler | Digital-Analog Wandlung]] und vieles mehr. Die meisten Mikrocontroller haben ein oder mehrere PWM-Module eingebaut, womit ohne CPU-Belastung eine PWM generiert werden kann. Jedoch kommt es bisweilen vor, daß die Anzahl der verfügbaren PWM-Kanäle nicht ausreicht. Dann muß eine Softwarelösung gefunden werden, bei der die CPU die PWM-Generierung vornimmt, allgemein Soft-PWM genannt.

'''Achtung:''' Wenn man für eine PWM aussschliesslich 8 Bit breite Datentypen verwendet, dann steht für den Parameter für die Pulsbreite nur der Bereich 0..255 zur Verfügung. Da bei einer vollständigen PWM mit N Schritten aber N+1 mögliche Fälle auftreten können (0/N bis N/0), ist mit dem hier gezeigten Code eine solche PWM nur für N <= 255 realisierbar.

== Einfacher Lösungsansatz ==

Ein sehr einfacher Lösungsansatz findet sich im [[AVR-Tutorial: PWM]]. Hier wird schon ein [[AVR-Tutorial: Timer | Timer]] benutzt, um in regelmäßigen Abständen die PWM-Generierung durchzuführen. Damit verbleibt noch Rechenzeit für andere Aufgaben, außerdem wird die Programmierung wesentlich vereinfacht. Allerdings ist das Beispiel in ASM, hier soll das ganze in [[C]] gemacht werden.

Es soll nun eine 8 Bit PWM mit 100 Hz (PWM-Zyklus 10ms) und acht Kanälen generiert werden. Der verwendete Controller ist ein [[AVR]] vom Typ ATmega32, welcher mit dem internen RC-Oszillator auf 8 MHz getaktet wird. Das Programm kann jedoch problemlos an so ziemlich jeden anderen AVR angepaßt werden. Die Programme wurden mit dem Optimierungsgrad -Os compiliert.

=== Erster Versuch ===

Das Programm ist recht kurz und übersichtlich. Im Hauptprogramm wird der Timer 1 initialisiert und der Output Compare 1A als variabler Timer verwendet, wobei die Output Compare Funktion nicht mit dem IO-Pin verbunden ist. Im Interrupt, welcher regelmäßig aufgerufen wird, werden nun in einer Schleife alle acht Kanäle geprüft. Alle Kanäle werden auf HIGH gesetzt, welche eine PWM-Einstellung größer als der aktuelle Zykluszähler haben. Sinnvollerweise werden erst alle Kanäle geprüft und das Ergebnis zwischengespeichert, am Ende erfolgt nur ein Zugriff auf den Port.

<c>
/*
Eine 8-kanalige PWM mit einfachem Lösungsansatz

ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L // Systemtakt in Hz
#define F_PWM 100 // PWM-Frequenz in Hz
#define PWM_STEPS 255 // PWM-Schritte pro Zyklus(1..255)
#define PWM_PORT PORTD // Port für PWM
#define PWM_DDR DDRD // Datenrichtungsregister für PWM

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt

#if (T_PWM<(152+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

#if PWM_STEPS > 255
#error PWM_STEPS zu gross
#endif

// includes

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

// globale Variablen

volatile uint8_t pwm_setting[8]; // Einstellungen für die einzelnen PWM-Kanäle

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
static uint8_t pwm_cnt=0;
uint8_t tmp=0, i=0, j=1;

OCR1A += (uint16_t)T_PWM;

for (; i<8; i++) {
if (pwm_setting[i] > pwm_cnt) tmp |= j;
j<<=1;
}
PWM_PORT = tmp; // PWMs aktualisieren
if (pwm_cnt==(uint8_t)(PWM_STEPS-1))
pwm_cnt=0;
else
pwm_cnt++;
}

int main(void) {

// PWM einstellen

PWM_DDR = 0xFF; // Port als Ausgang

// Timer 1 OCRA1, als variablem Timer nutzen

TCCR1B = 1; // Timer läuft mit vollem Systemtakt
TIMSK |= (1<<OCIE1A); // Interrupt freischalten

sei(); // Interrupts gloabl einschalten

/*********************************************************************/
// nur zum Testen, im Anwendungsfall löschen

volatile uint8_t tmp;
const uint8_t t1[8]={27, 40, 3, 17, 150, 99, 5, 9};
const uint8_t t2[8]={27, 40, 3, 0, 150, 99, 5, 9};
const uint8_t t3[8]={27, 40, 3, 17, 3, 99, 3, 0};
const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t t5[8]={0, 0, 0, 0, 0, 0, 0, 9};
const uint8_t t6[8]={33, 33, 33, 33, 33, 33, 33, 33};

// Messung der Interruptdauer
tmp =0;
tmp =0;
tmp =0;

// Debug

memcpy(pwm_setting, t1, 8);

memcpy(pwm_setting, t2, 8);

memcpy(pwm_setting, t3, 8);

memcpy(pwm_setting, t4, 8);

memcpy(pwm_setting, t5, 8);

memcpy(pwm_setting, t6, 8);

/*********************************************************************/

return 0;
}
</c>

Im [[AVR-Studio]] kann man den Code simulieren. Wichtig ist hier vor allem die Ausführungszeit des Interrupts. Bei 100 Hz PWM-Frequenz und 256 Schritten pro PWM-Zyklus wird diese Funktion immerhin 25600 mal pro Sekunde aufgerufen (PWM-Takt 25,6 kHz), bei 8MHz Taktfrequenz stehen damit maximal 312 Takte zur Verfügung. Glücklicherweise ist die Funktion relativ kurz und der GCC leistet gute Arbeit. Der Interrupt benötigt hier 152 Takte, es verbleiben also jeweils 160 Takte zur Bearbeitung anderer Aufgaben. Das entspricht einer CPU-Belastung von ~49%. Das Programm benötigt 284 Byte Programmspeicher. Nicht schlecht für den Anfang.

=== Zweiter Versuch ===

Wo gibt es in diesem Programm noch Optimierungsmöglichkeiten? Nur im Interrupt, denn das ganze Programm besteht ja praktisch nur aus der Interruptroutine. Betrachten wir die Schleifen genauer müssen wir feststellen, daß die Indizierung von pwm_setting[] etwas Rechenzeit benötigt. Ebenso die Schiebeoperation von tmp, auch wenn das nur acht mal ein Takt ist. Wir können jetzt per Hand das machen, was der Compiler auch manchmal macht. Die Rede ist vom Loop-Unrolling. Dabei wird die Schleife durch mehrere diskrete Befehle ersetzt (entrollt). Der Vorteil dabei ist, daß die Befehle zur Berechnung und Prüfung der Zählvariable entfallen, außerdem können ggf. Werte im Voraus berechnet werden. Als Ergebnis hat man zwar ein etwas größeres Programm, doch das wird schneller ausgeführt! Ausserdem orientiert sich diese Version mehr am Original der Assemblerversion. Dadurch wird sie zusätzlich ein wenig kürzer und schneller.

<c>
/*
Eine 8-kanalige PWM mit verbessertem Lösungsansatz

ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L // Systemtakt in Hz
#define F_PWM 100 // PWM-Frequenz in Hz
#define PWM_STEPS 256 // PWM-Schritte pro Zyklus(1..256)
#define PWM_PORT PORTD // Port für PWM
#define PWM_DDR DDRD // Datenrichtungsregister für PWM

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt

#if (T_PWM<(93+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

// includes

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

// globale Variablen

volatile uint8_t pwm_setting[8]; // Einstellungen für die einzelnen PWM-Kanäle

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
static uint8_t pwm_cnt=0;
uint8_t tmp=0;

OCR1A += (uint16_t)T_PWM;

if (pwm_setting[0] > pwm_cnt) tmp |= (1<<0);
if (pwm_setting[1] > pwm_cnt) tmp |= (1<<1);
if (pwm_setting[2] > pwm_cnt) tmp |= (1<<2);
if (pwm_setting[3] > pwm_cnt) tmp |= (1<<3);
if (pwm_setting[4] > pwm_cnt) tmp |= (1<<4);
if (pwm_setting[5] > pwm_cnt) tmp |= (1<<5);
if (pwm_setting[6] > pwm_cnt) tmp |= (1<<6);
if (pwm_setting[7] > pwm_cnt) tmp |= (1<<7);
PWM_PORT = tmp; // PWMs aktualisieren
if (pwm_cnt==(uint8_t)(PWM_STEPS-1))
pwm_cnt=0;
else
pwm_cnt++;
}

int main(void) {

// PWM einstellen

PWM_DDR = 0xFF; // Port als Ausgang

// Timer 1 OCRA1, als variablem Timer nutzen

TCCR1B = 1; // Timer läuft mit vollem Systemtakt
TIMSK |= (1<<OCIE1A); // Interrupt freischalten

sei(); // Interrupts gloabl einschalten

/*********************************************************************/
// nur zum Testen, im Anwendungsfall löschen

volatile uint8_t tmp;
const uint8_t t1[8]={27, 40, 3, 17, 150, 99, 5, 9};
const uint8_t t2[8]={27, 40, 3, 0, 150, 99, 5, 9};
const uint8_t t3[8]={27, 40, 3, 17, 3, 99, 3, 0};
const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t t5[8]={0, 0, 0, 0, 0, 0, 0, 9};
const uint8_t t6[8]={33, 33, 33, 33, 33, 33, 33, 33};

// Messung der Interruptdauer
tmp =0;
tmp =0;
tmp =0;

// Debug

memcpy(pwm_setting, t1, 8);

memcpy(pwm_setting, t2, 8);

memcpy(pwm_setting, t3, 8);

memcpy(pwm_setting, t4, 8);

memcpy(pwm_setting, t5, 8);

memcpy(pwm_setting, t6, 8);

/*********************************************************************/

return 0;
}
</c>

Mit dieser Interruptroutine werden nur noch 93 Takte benötigt, die CPU-Belastung verringert sich auf ~30%. Nicht schlecht. Der Programmcode steigt auf 324 Byte, aber das ist im Angesicht der Leistungsverbesserung zu verschmerzen. Weiter verringern kann man die CPU-Belastung durch eine niedrigere PWM-Frequenz oder eine geringere Anzahl Stufen der PWM. Wenn man beispielsweise mit 64 (6 Bit) statt 256 (8 Bit) Stufen auskommt verringert sich die Belastung um den Faktor 4.

== Intelligenter Lösungsansatz ==

Wenn auch eine CPU-Last von 30% recht akzeptabel erscheint, so hat man doch noch irgendwie das Gefühl, daß es noch besser geht. Aber wie? Mein Mathematikprofessor pflegte in so einem Fall die Anwendung der „Methode des scharfen Blicks“ ™. Was passiert eigentlich während eines gesamten PWM-Zykluses?

*Zu Beginn werden alle IO-Pins gesetzt, deren PWM-Einstellung nicht Null ist.
*Die jeweiligen IO-Pins werden gelöscht, wenn der PWM-Zähler mit der PWM-Einstellung übereinstimmt

Ja klar, aber da wir nur acht Kanäle haben, gibt es maximal 8 Zeitpunkte, an denen ein Pin gelöscht werden muss. Wenn mehrere Kanäle die gleiche PWM-Einstellung haben sind es sogar noch weniger. Alle anderen Interrupts verursachen keinerlei Änderung der IO-Pins und verbrauchen eigentlich nur sinnlos Rechenzeit. Ein Skandal!

Was ist also zu tun? Wir wissen nun, daß es maximal 9 Ereignisse pro PWM-Zyklus gibt. Was ist damit zu machen?

*Die PWM-Kanäle müssen in aufsteigender Folge sortiert werden.
*Wenn mehrere PWM-Kanäle den gleichen PWM-Wert haben müssen sie zusammengefaßt werden
*Die Zeitdifferenzen zwischen den einzelnen Ereignissen müssen berechnet werden

Das ist eigentlich schon alles. Praktisch ist das mit einigen Kniffligkeiten verbunden, aber die sind lösbar. Am Ende steht eine Interruptroutine, welche maximal 9 mal pro PWM-Zyklus aufgerufen wird und die jeweiligen IO-Pins setzt bzw. löscht. Eine normale Funktion wird benutzt, um die PWM-Einstellungen der acht Kanäle in die notwendigen Informationen für die Interruptroutine umzuwandeln. Das hat unter anderem den Vorteil, daß nur dann zusätzlich Rechenzeit benötigt wird, wenn sich die PWM-Einstellungen ändern.

<c>
/*
Eine 8-kanalige PWM mit intelligentem Lösungsansatz

ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L // Systemtakt in Hz
#define F_PWM 100L // PWM-Frequenz in Hz
#define PWM_PRESCALER 8 // Vorteiler für den Timer
#define PWM_STEPS 256 // PWM-Schritte pro Zyklus(1..256)
#define PWM_PORT PORTB // Port für PWM
#define PWM_DDR DDRB // Datenrichtungsregister für PWM
#define PWM_CHANNELS 8 // Anzahl der PWM-Kanäle

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(PWM_PRESCALER*F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt
//#define T_PWM 1 //TEST

#if ((T_PWM*PWM_PRESCALER)<(111+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

#if ((T_PWM*PWM_STEPS)>65535)
#error Periodendauer der PWM zu gross! F_PWM oder PWM_PRESCALER erhöhen.
#endif
// includes

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

// globale Variablen

uint16_t pwm_timing[PWM_CHANNELS+1]; // Zeitdifferenzen der PWM Werte
uint16_t pwm_timing_tmp[PWM_CHANNELS+1];
uint8_t pwm_mask[PWM_CHANNELS+1]; // Bitmaske für PWM Bits, welche gelöscht werden sollen
uint8_t pwm_mask_tmp[PWM_CHANNELS+1];
uint8_t pwm_setting[PWM_CHANNELS]; // Einstellungen für die einzelnen PWM-Kanäle
uint8_t pwm_setting_tmp[PWM_CHANNELS+1]; // Einstellungen der PWM Werte, sortiert

volatile uint8_t pwm_cnt_max=1; // Zählergrenze, Initialisierung mit 1 ist wichtig!
volatile uint8_t pwm_sync; // Update jetzt möglich

// Pointer für wechselseitigen Datenzugriff

uint16_t * isr_ptr_time = pwm_timing;
uint16_t * main_ptr_time = pwm_timing_tmp;
uint8_t * isr_ptr_mask = pwm_mask;
uint8_t * main_ptr_mask = pwm_mask_tmp;

// Zeiger austauschen
// das muss in einem Unterprogramm erfolgen,
// um eine Zwischenspeicherung durch den Compiler zu verhindern

void tausche_zeiger(void) {
uint16_t * tmp_ptr16;
uint8_t * tmp_ptr8;

tmp_ptr16 = isr_ptr_time;
isr_ptr_time = main_ptr_time;
main_ptr_time = tmp_ptr16;
tmp_ptr8 = isr_ptr_mask;
isr_ptr_mask = main_ptr_mask;
main_ptr_mask = tmp_ptr8;
}

// PWM Update, berechnet aus den PWM Einstellungen
// die neuen Werte für die Interruptroutine

void pwm_update(void) {
uint8_t i, j, k, min;
uint8_t tmp;

// PWM Maske für Start berechnen
// gleichzeitig die Bitmasken generieren und PWM Werte kopieren

tmp=0;
j = 1;
for(i=1; i<=(PWM_CHANNELS); i++) {
main_ptr_mask[i]=~j; // Maske zum Löschen der PWM Ausgänge
pwm_setting_tmp[i] = pwm_setting[i-1];
if (pwm_setting_tmp[i]!=0) tmp |= j; // Maske zum setzen der IOs am PWM Start
j <<= 1;
}
main_ptr_mask[0]=tmp; // PWM Start Daten

// PWM settings sortieren; Einfügesortieren

for(i=1; i<=PWM_CHANNELS; i++) {
min=255;
k=i;
for(j=i; j<=PWM_CHANNELS; j++) {
if (pwm_setting_tmp[j]<min) {
k=j; // Index und PWM-setting merken
min = pwm_setting_tmp[j];
}
}
if (k!=i) {
// ermitteltes Minimum mit aktueller Sortiertstelle tauschen
tmp = pwm_setting_tmp[k];
pwm_setting_tmp[k] = pwm_setting_tmp[i];
pwm_setting_tmp[i] = tmp;
tmp = main_ptr_mask[k];
main_ptr_mask[k] = main_ptr_mask[i];
main_ptr_mask[i] = tmp;
}
}

// Gleiche PWM-Werte vereinigen, ebenso den PWM-Wert 0 löschen falls vorhanden

k=PWM_CHANNELS; // PWM_CHANNELS Datensätze
i=1; // Startindex

while(k>i) {
while ( ((pwm_setting_tmp[i]==pwm_setting_tmp[i+1]) || (pwm_setting_tmp[i]==0)) && (k>i) ) {

// aufeinanderfolgende Werte sind gleich und können vereinigt werden
// oder PWM Wert ist Null
if (pwm_setting_tmp[i]!=0)
main_ptr_mask[i+1] &= main_ptr_mask[i]; // Masken vereinigen

// Datensatz entfernen,
// Nachfolger alle eine Stufe hochschieben
for(j=i; j<k; j++) {
pwm_setting_tmp[j] = pwm_setting_tmp[j+1];
main_ptr_mask[j] = main_ptr_mask[j+1];
}
k--;
}
i++;
}

// letzten Datensatz extra behandeln
// Vergleich mit dem Nachfolger nicht möglich, nur löschen
// gilt nur im Sonderfall, wenn alle Kanäle 0 sind
if (pwm_setting_tmp[i]==0) k--;

// Zeitdifferenzen berechnen

if (k==0) { // Sonderfall, wenn alle Kanäle 0 sind
main_ptr_time[0]=(uint16_t)T_PWM*PWM_STEPS/2;
main_ptr_time[1]=(uint16_t)T_PWM*PWM_STEPS/2;
k=1;
}
else {
i=k;
main_ptr_time[i]=(uint16_t)T_PWM*(PWM_STEPS-pwm_setting_tmp[i]);
j=pwm_setting_tmp[i];
i--;
for (; i>0; i--) {
main_ptr_time[i]=(uint16_t)T_PWM*(j-pwm_setting_tmp[i]);
j=pwm_setting_tmp[i];
}
main_ptr_time[0]=(uint16_t)T_PWM*j;
}

// auf Sync warten

pwm_sync=0; // Sync wird im Interrupt gesetzt
while(pwm_sync==0);

// Zeiger tauschen
cli();
tausche_zeiger();
pwm_cnt_max = k;
sei();
}

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
static uint8_t pwm_cnt;
uint8_t tmp;

OCR1A += isr_ptr_time[pwm_cnt];
tmp = isr_ptr_mask[pwm_cnt];

if (pwm_cnt == 0) {
PWM_PORT = tmp; // Ports setzen zu Begin der PWM
pwm_cnt++;
}
else {
PWM_PORT &= tmp; // Ports löschen
if (pwm_cnt == pwm_cnt_max) {
pwm_sync = 1; // Update jetzt möglich
pwm_cnt = 0;
}
else pwm_cnt++;
}
}

int main(void) {

// PWM Port einstellen

PWM_DDR = 0xFF; // Port als Ausgang

// Timer 1 OCRA1, als variablen Timer nutzen

TCCR1B = 2; // Timer läuft mit Prescaler 8
TIMSK |= (1<<OCIE1A); // Interrupt freischalten

sei(); // Interrupts gloabl einschalten

/******************************************************************/
// nur zum testen, in der Anwendung entfernen
/*
// Test values
volatile uint8_t tmp;
const uint8_t t1[8]={255, 40, 3, 17, 150, 99, 5, 9};
const uint8_t t2[8]={27, 40, 3, 0, 150, 99, 5, 9};
const uint8_t t3[8]={27, 40, 3, 17, 3, 99, 3, 0};
const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t t5[8]={9, 1, 1, 1, 1, 1, 1, 1};
const uint8_t t6[8]={33, 33, 33, 33, 33, 33, 33, 33};
const uint8_t t7[8]={0, 0, 0, 0, 0, 0, 0, 88};

// Messung der Interruptdauer
tmp =1;
tmp =2;
tmp =3;

// Debug

memcpy(pwm_setting, t1, 8);
pwm_update();

memcpy(pwm_setting, t2, 8);
pwm_update();

memcpy(pwm_setting, t3, 8);
pwm_update();

memcpy(pwm_setting, t4, 8);
pwm_update();

memcpy(pwm_setting, t5, 8);
pwm_update();

memcpy(pwm_setting, t6, 8);
pwm_update();

memcpy(pwm_setting, t7, 8);
pwm_update();
*/
/******************************************************************/

while(1);
return 0;
}
</c>

Das Programm ist schon um einiges länger (968 Byte). Die Interruptroutine benötigt maximal 111 Takte und wird zwischen 2 bis 9 mal pro PWM-Zyklus aufgerufen. Zweimal, wenn alle PWM-Einstellungen gleich sind, 9 mal, wenn alle PWM-Einstellungen verschieden sind. Damit werden zwischen 222 bis 999 Takte benötigt, pro '''PWM-Zyklus''', nicht pro PWM-Takt! Das entspricht einer '''CPU-Belastung von 0,3..1,2%'''! [http://de.wikipedia.org/wiki/Beifall Standing Ovations]! Die Funktion pwm_update() benötigt ca. 1500 bis 1800 Takte, das ist geringfügig abhängig von den PWM-Einstellungen, je nach dem ob die Daten schon sortiert sind und ob PWM-Werte mehrfach vorkommen. Bei einer Updaterate von 100 Hz (mehr ist physikalisch sinnlos) entspricht das einer CPU-Belastung von 2,3%, praktisch wird es wahrscheinlich weniger sein. Taktet man den AVR mit vollen 16 MHz halbiert sich die CPU-Belastung noch einmal. Beachtet werden sollte hier die Datenübergabe von der Funktion pwm_update() zur Interruptroutine. Hier werden jeweils zwei Zeiger verwendet, um auf Arrays zu zeigen. In zwei Arrays werden durch die Funktion die Berechnungen der neuen Daten vorgenommen. In den beiden anderen Arrays stehen die aktuellen Daten, mit welchen die ISR arbeitet. Um am Ende der Berechung ein relativ aufwändiges Kopieren der Daten zu vermeiden werden einfach die Zeiger vertauscht. Das ist wesentlich schneller als das Kopieren der Arrays! Im englischen spricht man hier von double buffering, also doppelter Pufferung. Dieses Prinzip wird oft angewendet. Würde man allerdings einfach am Ende die Zeiger tauschen käme es zu einem Crash! Der Interrupt kann jederzeit aktiv werden. Wenn dann die Zeiger nur halb kopiert sind greift die Interruptroutine auf zerstückelte Daten zu und macht Müll. Ebenso würde es zu Fehlfunktionen kommen, wenn während es PWM-Zyklus neue Daten in die Arrays kopiert werden. Das muß verhindert werden. Und zwar dadurch, daß über eine Variable eine Synchronisation durchgeführt wird. Diese wird am Ende des PWM-Zyklus gesetzt und signalisiert, daß neue Daten für den nächsten Zyklus kopiert werden können. Deshalb muss die Funktion pwm_update ggf. bis zu 1 vollen PWM-Zyklus warten, bis die Zeiger getauscht werden können. Wichtig ist dabei, daß die Variable pwm_sync, welche sowohl in der Funktion als auch im Interrupt geschrieben wird, als '''volatile''' deklariert wird. Denn sonst würde die Sequenz

<c>
pwm_sync=0; // Sync wird im Interrupt gesetzt
while(pwm_sync==0);
</c>

zum Stehenbleiben der CPU führen, weil der Compiler erkennt, daß die Variable nie ungleich Null sein kann und damit die Schleife endlos ausgeführt wird. Der Compiler kann prinzipbedingt nicht automatisch erkennen, daß die Variable im Interrupt auf 1 gesetzt wird.

Bei dem schon recht hohen Prozessortakt von 8MHz und der relativ niedrigen PWM Frequenz von 100 Hz haben wir allerdings ein kleines Problem. Wenn beispielsweise nur ein Kanal den PWM-Wert 10 hat, alle anderen aber den Wert Null, dann passiert folgendes. Zum Begin eines PWM-Zyklus wird der eine Kanal aktiviert. Jetzt wird per Timer für 10xT_PWM = 3120 Takte gewartet. Jetzt wird dieser Kanal wieder gelöscht. Bis zum Begin des nächsten PWM-Zyklus muss jedoch noch (256-10)*T_PWM = 76752 Takte gewartet werden. Doch diese Zahl passt nicht mehr in eine 16 Bit Variable! Und damit kann sie auch nicht mit dem Timer verwendet werden. Der Ausweg heisst Vorteiler (engl. Prescaler). Damit kann der Timer langsamer getaktet werden und somit wird die gleiche Wartezeit mit weniger Timertakten erzielt. Zu beachten ist, dass die Einstellung im #define PWM_PRESCALER mit der realen Einstellung in TCCR1B übereinstimmen muss.

Eine Einschränkung gilt allerdings für alle Soft-PWMs. Die PWM-Frequenz muss niedrig genug sein, damit sich die Interrupts nicht überschneiden. D.h. der Wert T_PWM muß immer größer sein als die Anzahl Takte der Interruptroutine. Das wird im Quelltext mit Hilfe von #if . . #endif geprüft. Die +5 Takte sind eine Reserve. Dazu muß aber die Optimierung -Os eingeschaltet sein, sonst stimmen die Zahlen nicht!

== Zusammenfassung ==

Durch kritische Analyse ist es möglich, eine Software-PWM drastisch zu verbessern und die CPU-Belastung auf ein verschwindend geringes Maß zu reduzieren. Zudem zeigt dieses Beispiel ein oft vorkommendes Muster auf, welches gemeinhin als 'Time for Space' (Zeit für Platz) bezeichnet wird. Man meint damit, dass es oft möglich ist, dramatische Einsparungen in der Laufzeit zu erreichen, wenn man gewillt ist dafür Speicherplatz zu opfern.

{| border="1"
|-
| Version || Programmspeicher [Byte] || CPU-Belastung [%]
|- align="center"
| 1 || 284 || 49
|- align="center"
| 2 || 324 || 30
|- align="center"
| 3 || 968 || 0,3..1,2
|}

== Siehe auch ==

* [[AVR-Tutorial: PWM]]
* [[AVR-GCC-Tutorial#PWM (Pulsweitenmodulation)|AVR-GCC-Tutorial: PWM]]
* [[LED-Fading]] - LED dimmen mit PWM

[[Category:AVR]]

Soft-PWM

2010-05-16T20:28:54Z

91.19.247.16: /* Zusammenfassung */

Soft-PWM

2010-05-16T20:26:18Z

91.19.247.16: /* Siehe auch */

== Einleitung ==
[[PWM]] ist eine oft verwendete Funktion auf dem Gebiet der Mikrocontroller. Damit lassen sich vielfältige Aufgaben lösen, wie beispielsweise die Leistungssteuerung von Motoren, Helligkeitssteuerung von [[LED-Fading | LEDs]], [[DA-Wandler | Digital-Analog Wandlung]] und vieles mehr. Die meisten Mikrocontroller haben ein oder mehrere PWM-Module eingebaut, womit ohne CPU-Belastung eine PWM generiert werden kann. Jedoch kommt es bisweilen vor, daß die Anzahl der verfügbaren PWM-Kanäle nicht ausreicht. Dann muß eine Softwarelösung gefunden werden, bei der die CPU die PWM-Generierung vornimmt, allgemein Soft-PWM genannt.

'''Achtung:''' Wenn man für eine PWM aussschliesslich 8 Bit breite Datentypen verwendet, dann steht für den Parameter für die Pulsbreite nur der Bereich 0..255 zur Verfügung. Da bei einer vollständigen PWM mit N Schritten aber N+1 mögliche Fälle auftreten können (0/N bis N/0), ist mit dem hier gezeigten Code eine solche PWM nur für N <= 255 realisierbar.

== Einfacher Lösungsansatz ==

Ein sehr einfacher Lösungsansatz findet sich im [[AVR-Tutorial: PWM]]. Hier wird schon ein [[AVR-Tutorial: Timer | Timer]] benutzt, um in regelmäßigen Abständen die PWM-Generierung durchzuführen. Damit verbleibt noch Rechenzeit für andere Aufgaben, außerdem wird die Programmierung wesentlich vereinfacht. Allerdings ist das Beispiel in ASM, hier soll das ganze in [[C]] gemacht werden.

Es soll nun eine 8 Bit PWM mit 100 Hz (PWM-Zyklus 10ms) und acht Kanälen generiert werden. Der verwendete Controller ist ein [[AVR]] vom Typ ATmega32, welcher mit dem internen RC-Oszillator auf 8 MHz getaktet wird. Das Programm kann jedoch problemlos an so ziemlich jeden anderen AVR angepaßt werden. Die Programme wurden mit dem Optimierungsgrad -Os compiliert.

=== Erster Versuch ===

Das Programm ist recht kurz und übersichtlich. Im Hauptprogramm wird der Timer 1 initialisiert und der Output Compare 1A als variabler Timer verwendet, wobei die Output Compare Funktion nicht mit dem IO-Pin verbunden ist. Im Interrupt, welcher regelmäßig aufgerufen wird, werden nun in einer Schleife alle acht Kanäle geprüft. Alle Kanäle werden auf HIGH gesetzt, welche eine PWM-Einstellung größer als der aktuelle Zykluszähler haben. Sinnvollerweise werden erst alle Kanäle geprüft und das Ergebnis zwischengespeichert, am Ende erfolgt nur ein Zugriff auf den Port.

<c>
/*
Eine 8-kanalige PWM mit einfachem Lösungsansatz

ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L // Systemtakt in Hz
#define F_PWM 100 // PWM-Frequenz in Hz
#define PWM_STEPS 255 // PWM-Schritte pro Zyklus(1..255)
#define PWM_PORT PORTD // Port für PWM
#define PWM_DDR DDRD // Datenrichtungsregister für PWM

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt

#if (T_PWM<(152+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

#if PWM_STEPS > 255
#error PWM_STEPS zu gross
#endif

// includes

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

// globale Variablen

volatile uint8_t pwm_setting[8]; // Einstellungen für die einzelnen PWM-Kanäle

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
static uint8_t pwm_cnt=0;
uint8_t tmp=0, i=0, j=1;

OCR1A += (uint16_t)T_PWM;

for (; i<8; i++) {
if (pwm_setting[i] > pwm_cnt) tmp |= j;
j<<=1;
}
PWM_PORT = tmp; // PWMs aktualisieren
if (pwm_cnt==(uint8_t)(PWM_STEPS-1))
pwm_cnt=0;
else
pwm_cnt++;
}

int main(void) {

// PWM einstellen

PWM_DDR = 0xFF; // Port als Ausgang

// Timer 1 OCRA1, als variablem Timer nutzen

TCCR1B = 1; // Timer läuft mit vollem Systemtakt
TIMSK |= (1<<OCIE1A); // Interrupt freischalten

sei(); // Interrupts gloabl einschalten

/*********************************************************************/
// nur zum Testen, im Anwendungsfall löschen

volatile uint8_t tmp;
const uint8_t t1[8]={27, 40, 3, 17, 150, 99, 5, 9};
const uint8_t t2[8]={27, 40, 3, 0, 150, 99, 5, 9};
const uint8_t t3[8]={27, 40, 3, 17, 3, 99, 3, 0};
const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t t5[8]={0, 0, 0, 0, 0, 0, 0, 9};
const uint8_t t6[8]={33, 33, 33, 33, 33, 33, 33, 33};

// Messung der Interruptdauer
tmp =0;
tmp =0;
tmp =0;

// Debug

memcpy(pwm_setting, t1, 8);

memcpy(pwm_setting, t2, 8);

memcpy(pwm_setting, t3, 8);

memcpy(pwm_setting, t4, 8);

memcpy(pwm_setting, t5, 8);

memcpy(pwm_setting, t6, 8);

/*********************************************************************/

return 0;
}
</c>

Im [[AVR-Studio]] kann man den Code simulieren. Wichtig ist hier vor allem die Ausführungszeit des Interrupts. Bei 100 Hz PWM-Frequenz und 256 Schritten pro PWM-Zyklus wird diese Funktion immerhin 25600 mal pro Sekunde aufgerufen (PWM-Takt 25,6 kHz), bei 8MHz Taktfrequenz stehen damit maximal 312 Takte zur Verfügung. Glücklicherweise ist die Funktion relativ kurz und der GCC leistet gute Arbeit. Der Interrupt benötigt hier 152 Takte, es verbleiben also jeweils 160 Takte zur Bearbeitung anderer Aufgaben. Das entspricht einer CPU-Belastung von ~49%. Das Programm benötigt 284 Byte Programmspeicher. Nicht schlecht für den Anfang.

=== Zweiter Versuch ===

Wo gibt es in diesem Programm noch Optimierungsmöglichkeiten? Nur im Interrupt, denn das ganze Programm besteht ja praktisch nur aus der Interruptroutine. Betrachten wir die Schleifen genauer müssen wir feststellen, daß die Indizierung von pwm_setting[] etwas Rechenzeit benötigt. Ebenso die Schiebeoperation von tmp, auch wenn das nur acht mal ein Takt ist. Wir können jetzt per Hand das machen, was der Compiler auch manchmal macht. Die Rede ist vom Loop-Unrolling. Dabei wird die Schleife durch mehrere diskrete Befehle ersetzt (entrollt). Der Vorteil dabei ist, daß die Befehle zur Berechnung und Prüfung der Zählvariable entfallen, außerdem können ggf. Werte im Voraus berechnet werden. Als Ergebnis hat man zwar ein etwas größeres Programm, doch das wird schneller ausgeführt! Ausserdem orientiert sich diese Version mehr am Original der Assemblerversion. Dadurch wird sie zusätzlich ein wenig kürzer und schneller.

<c>
/*
Eine 8-kanalige PWM mit verbessertem Lösungsansatz

ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L // Systemtakt in Hz
#define F_PWM 100 // PWM-Frequenz in Hz
#define PWM_STEPS 256 // PWM-Schritte pro Zyklus(1..256)
#define PWM_PORT PORTD // Port für PWM
#define PWM_DDR DDRD // Datenrichtungsregister für PWM

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt

#if (T_PWM<(93+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

// includes

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

// globale Variablen

volatile uint8_t pwm_setting[8]; // Einstellungen für die einzelnen PWM-Kanäle

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
static uint8_t pwm_cnt=0;
uint8_t tmp=0;

OCR1A += (uint16_t)T_PWM;

if (pwm_setting[0] > pwm_cnt) tmp |= (1<<0);
if (pwm_setting[1] > pwm_cnt) tmp |= (1<<1);
if (pwm_setting[2] > pwm_cnt) tmp |= (1<<2);
if (pwm_setting[3] > pwm_cnt) tmp |= (1<<3);
if (pwm_setting[4] > pwm_cnt) tmp |= (1<<4);
if (pwm_setting[5] > pwm_cnt) tmp |= (1<<5);
if (pwm_setting[6] > pwm_cnt) tmp |= (1<<6);
if (pwm_setting[7] > pwm_cnt) tmp |= (1<<7);
PWM_PORT = tmp; // PWMs aktualisieren
if (pwm_cnt==(uint8_t)(PWM_STEPS-1))
pwm_cnt=0;
else
pwm_cnt++;
}

int main(void) {

// PWM einstellen

PWM_DDR = 0xFF; // Port als Ausgang

// Timer 1 OCRA1, als variablem Timer nutzen

TCCR1B = 1; // Timer läuft mit vollem Systemtakt
TIMSK |= (1<<OCIE1A); // Interrupt freischalten

sei(); // Interrupts gloabl einschalten

/*********************************************************************/
// nur zum Testen, im Anwendungsfall löschen

volatile uint8_t tmp;
const uint8_t t1[8]={27, 40, 3, 17, 150, 99, 5, 9};
const uint8_t t2[8]={27, 40, 3, 0, 150, 99, 5, 9};
const uint8_t t3[8]={27, 40, 3, 17, 3, 99, 3, 0};
const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t t5[8]={0, 0, 0, 0, 0, 0, 0, 9};
const uint8_t t6[8]={33, 33, 33, 33, 33, 33, 33, 33};

// Messung der Interruptdauer
tmp =0;
tmp =0;
tmp =0;

// Debug

memcpy(pwm_setting, t1, 8);

memcpy(pwm_setting, t2, 8);

memcpy(pwm_setting, t3, 8);

memcpy(pwm_setting, t4, 8);

memcpy(pwm_setting, t5, 8);

memcpy(pwm_setting, t6, 8);

/*********************************************************************/

return 0;
}
</c>

Mit dieser Interruptroutine werden nur noch 93 Takte benötigt, die CPU-Belastung verringert sich auf ~30%. Nicht schlecht. Der Programmcode steigt auf 324 Byte, aber das ist im Angesicht der Leistungsverbesserung zu verschmerzen. Weiter verringern kann man die CPU-Belastung durch eine niedrigere PWM-Frequenz oder eine geringere Anzahl Stufen der PWM. Wenn man beispielsweise mit 64 (6 Bit) statt 256 (8 Bit) Stufen auskommt verringert sich die Belastung um den Faktor 4.

== Intelligenter Lösungsansatz ==

Wenn auch eine CPU-Last von 30% recht akzeptabel erscheint, so hat man doch noch irgendwie das Gefühl, daß es noch besser geht. Aber wie? Mein Mathematikprofessor pflegte in so einem Fall die Anwendung der „Methode des scharfen Blicks“ ™. Was passiert eigentlich während eines gesamten PWM-Zykluses?

*Zu Beginn werden alle IO-Pins gesetzt, deren PWM-Einstellung nicht Null ist.
*Die jeweiligen IO-Pins werden gelöscht, wenn der PWM-Zähler mit der PWM-Einstellung übereinstimmt

Ja klar, aber da wir nur acht Kanäle haben, gibt es maximal 8 Zeitpunkte, an denen ein Pin gelöscht werden muss. Wenn mehrere Kanäle die gleiche PWM-Einstellung haben sind es sogar noch weniger. Alle anderen Interrupts verursachen keinerlei Änderung der IO-Pins und verbrauchen eigentlich nur sinnlos Rechenzeit. Ein Skandal!

Was ist also zu tun? Wir wissen nun, daß es maximal 9 Ereignisse pro PWM-Zyklus gibt. Was ist damit zu machen?

*Die PWM-Kanäle müssen in aufsteigender Folge sortiert werden.
*Wenn mehrere PWM-Kanäle den gleichen PWM-Wert haben müssen sie zusammengefaßt werden
*Die Zeitdifferenzen zwischen den einzelnen Ereignissen müssen berechnet werden

Das ist eigentlich schon alles. Praktisch ist das mit einigen Kniffligkeiten verbunden, aber die sind lösbar. Am Ende steht eine Interruptroutine, welche maximal 9 mal pro PWM-Zyklus aufgerufen wird und die jeweiligen IO-Pins setzt bzw. löscht. Eine normale Funktion wird benutzt, um die PWM-Einstellungen der acht Kanäle in die notwendigen Informationen für die Interruptroutine umzuwandeln. Das hat unter anderem den Vorteil, daß nur dann zusätzlich Rechenzeit benötigt wird, wenn sich die PWM-Einstellungen ändern.

<c>
/*
Eine 8-kanalige PWM mit intelligentem Lösungsansatz

ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L // Systemtakt in Hz
#define F_PWM 100L // PWM-Frequenz in Hz
#define PWM_PRESCALER 8 // Vorteiler für den Timer
#define PWM_STEPS 256 // PWM-Schritte pro Zyklus(1..256)
#define PWM_PORT PORTB // Port für PWM
#define PWM_DDR DDRB // Datenrichtungsregister für PWM
#define PWM_CHANNELS 8 // Anzahl der PWM-Kanäle

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(PWM_PRESCALER*F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt
//#define T_PWM 1 //TEST

#if ((T_PWM*PWM_PRESCALER)<(111+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

#if ((T_PWM*PWM_STEPS)>65535)
#error Periodendauer der PWM zu gross! F_PWM oder PWM_PRESCALER erhöhen.
#endif
// includes

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

// globale Variablen

uint16_t pwm_timing[PWM_CHANNELS+1]; // Zeitdifferenzen der PWM Werte
uint16_t pwm_timing_tmp[PWM_CHANNELS+1];
uint8_t pwm_mask[PWM_CHANNELS+1]; // Bitmaske für PWM Bits, welche gelöscht werden sollen
uint8_t pwm_mask_tmp[PWM_CHANNELS+1];
uint8_t pwm_setting[PWM_CHANNELS]; // Einstellungen für die einzelnen PWM-Kanäle
uint8_t pwm_setting_tmp[PWM_CHANNELS+1]; // Einstellungen der PWM Werte, sortiert

volatile uint8_t pwm_cnt_max=1; // Zählergrenze, Initialisierung mit 1 ist wichtig!
volatile uint8_t pwm_sync; // Update jetzt möglich

// Pointer für wechselseitigen Datenzugriff

uint16_t * isr_ptr_time = pwm_timing;
uint16_t * main_ptr_time = pwm_timing_tmp;
uint8_t * isr_ptr_mask = pwm_mask;
uint8_t * main_ptr_mask = pwm_mask_tmp;

// Zeiger austauschen
// das muss in einem Unterprogramm erfolgen,
// um eine Zwischenspeicherung durch den Compiler zu verhindern

void tausche_zeiger(void) {
uint16_t * tmp_ptr16;
uint8_t * tmp_ptr8;

tmp_ptr16 = isr_ptr_time;
isr_ptr_time = main_ptr_time;
main_ptr_time = tmp_ptr16;
tmp_ptr8 = isr_ptr_mask;
isr_ptr_mask = main_ptr_mask;
main_ptr_mask = tmp_ptr8;
}

// PWM Update, berechnet aus den PWM Einstellungen
// die neuen Werte für die Interruptroutine

void pwm_update(void) {
uint8_t i, j, k, min;
uint8_t tmp;

// PWM Maske für Start berechnen
// gleichzeitig die Bitmasken generieren und PWM Werte kopieren

tmp=0;
j = 1;
for(i=1; i<=(PWM_CHANNELS); i++) {
main_ptr_mask[i]=~j; // Maske zum Löschen der PWM Ausgänge
pwm_setting_tmp[i] = pwm_setting[i-1];
if (pwm_setting_tmp[i]!=0) tmp |= j; // Maske zum setzen der IOs am PWM Start
j <<= 1;
}
main_ptr_mask[0]=tmp; // PWM Start Daten

// PWM settings sortieren; Einfügesortieren

for(i=1; i<=PWM_CHANNELS; i++) {
min=255;
k=i;
for(j=i; j<=PWM_CHANNELS; j++) {
if (pwm_setting_tmp[j]<min) {
k=j; // Index und PWM-setting merken
min = pwm_setting_tmp[j];
}
}
if (k!=i) {
// ermitteltes Minimum mit aktueller Sortiertstelle tauschen
tmp = pwm_setting_tmp[k];
pwm_setting_tmp[k] = pwm_setting_tmp[i];
pwm_setting_tmp[i] = tmp;
tmp = main_ptr_mask[k];
main_ptr_mask[k] = main_ptr_mask[i];
main_ptr_mask[i] = tmp;
}
}

// Gleiche PWM-Werte vereinigen, ebenso den PWM-Wert 0 löschen falls vorhanden

k=PWM_CHANNELS; // PWM_CHANNELS Datensätze
i=1; // Startindex

while(k>i) {
while ( ((pwm_setting_tmp[i]==pwm_setting_tmp[i+1]) || (pwm_setting_tmp[i]==0)) && (k>i) ) {

// aufeinanderfolgende Werte sind gleich und können vereinigt werden
// oder PWM Wert ist Null
if (pwm_setting_tmp[i]!=0)
main_ptr_mask[i+1] &= main_ptr_mask[i]; // Masken vereinigen

// Datensatz entfernen,
// Nachfolger alle eine Stufe hochschieben
for(j=i; j<k; j++) {
pwm_setting_tmp[j] = pwm_setting_tmp[j+1];
main_ptr_mask[j] = main_ptr_mask[j+1];
}
k--;
}
i++;
}

// letzten Datensatz extra behandeln
// Vergleich mit dem Nachfolger nicht möglich, nur löschen
// gilt nur im Sonderfall, wenn alle Kanäle 0 sind
if (pwm_setting_tmp[i]==0) k--;

// Zeitdifferenzen berechnen

if (k==0) { // Sonderfall, wenn alle Kanäle 0 sind
main_ptr_time[0]=(uint16_t)T_PWM*PWM_STEPS/2;
main_ptr_time[1]=(uint16_t)T_PWM*PWM_STEPS/2;
k=1;
}
else {
i=k;
main_ptr_time[i]=(uint16_t)T_PWM*(PWM_STEPS-pwm_setting_tmp[i]);
j=pwm_setting_tmp[i];
i--;
for (; i>0; i--) {
main_ptr_time[i]=(uint16_t)T_PWM*(j-pwm_setting_tmp[i]);
j=pwm_setting_tmp[i];
}
main_ptr_time[0]=(uint16_t)T_PWM*j;
}

// auf Sync warten

pwm_sync=0; // Sync wird im Interrupt gesetzt
while(pwm_sync==0);

// Zeiger tauschen
cli();
tausche_zeiger();
pwm_cnt_max = k;
sei();
}

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
static uint8_t pwm_cnt;
uint8_t tmp;

OCR1A += isr_ptr_time[pwm_cnt];
tmp = isr_ptr_mask[pwm_cnt];

if (pwm_cnt == 0) {
PWM_PORT = tmp; // Ports setzen zu Begin der PWM
pwm_cnt++;
}
else {
PWM_PORT &= tmp; // Ports löschen
if (pwm_cnt == pwm_cnt_max) {
pwm_sync = 1; // Update jetzt möglich
pwm_cnt = 0;
}
else pwm_cnt++;
}
}

int main(void) {

// PWM Port einstellen

PWM_DDR = 0xFF; // Port als Ausgang

// Timer 1 OCRA1, als variablen Timer nutzen

TCCR1B = 2; // Timer läuft mit Prescaler 8
TIMSK |= (1<<OCIE1A); // Interrupt freischalten

sei(); // Interrupts gloabl einschalten

/******************************************************************/
// nur zum testen, in der Anwendung entfernen
/*
// Test values
volatile uint8_t tmp;
const uint8_t t1[8]={255, 40, 3, 17, 150, 99, 5, 9};
const uint8_t t2[8]={27, 40, 3, 0, 150, 99, 5, 9};
const uint8_t t3[8]={27, 40, 3, 17, 3, 99, 3, 0};
const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t t5[8]={9, 1, 1, 1, 1, 1, 1, 1};
const uint8_t t6[8]={33, 33, 33, 33, 33, 33, 33, 33};
const uint8_t t7[8]={0, 0, 0, 0, 0, 0, 0, 88};

// Messung der Interruptdauer
tmp =1;
tmp =2;
tmp =3;

// Debug

memcpy(pwm_setting, t1, 8);
pwm_update();

memcpy(pwm_setting, t2, 8);
pwm_update();

memcpy(pwm_setting, t3, 8);
pwm_update();

memcpy(pwm_setting, t4, 8);
pwm_update();

memcpy(pwm_setting, t5, 8);
pwm_update();

memcpy(pwm_setting, t6, 8);
pwm_update();

memcpy(pwm_setting, t7, 8);
pwm_update();
*/
/******************************************************************/

while(1);
return 0;
}
</c>

Das Programm ist schon um einiges länger (968 Byte). Die Interruptroutine benötigt maximal 111 Takte und wird zwischen 2 bis 9 mal pro PWM-Zyklus aufgerufen. Zweimal, wenn alle PWM-Einstellungen gleich sind, 9 mal, wenn alle PWM-Einstellungen verschieden sind. Damit werden zwischen 222 bis 999 Takte benötigt, pro '''PWM-Zyklus''', nicht pro PWM-Takt! Das entspricht einer '''CPU-Belastung von 0,3..1,2%'''! [http://de.wikipedia.org/wiki/Beifall Standing Ovations]! Die Funktion pwm_update() benötigt ca. 1500 bis 1800 Takte, das ist geringfügig abhängig von den PWM-Einstellungen, je nach dem ob die Daten schon sortiert sind und ob PWM-Werte mehrfach vorkommen. Bei einer Updaterate von 100 Hz (mehr ist physikalisch sinnlos) entspricht das einer CPU-Belastung von 2,3%, praktisch wird es wahrscheinlich weniger sein. Taktet man den AVR mit vollen 16 MHz halbiert sich die CPU-Belastung noch einmal. Beachtet werden sollte hier die Datenübergabe von der Funktion pwm_update() zur Interruptroutine. Hier werden jeweils zwei Zeiger verwendet, um auf Arrays zu zeigen. In zwei Arrays werden durch die Funktion die Berechnungen der neuen Daten vorgenommen. In den beiden anderen Arrays stehen die aktuellen Daten, mit welchen die ISR arbeitet. Um am Ende der Berechung ein relativ aufwändiges Kopieren der Daten zu vermeiden werden einfach die Zeiger vertauscht. Das ist wesentlich schneller als das Kopieren der Arrays! Im englischen spricht man hier von double buffering, also doppelter Pufferung. Dieses Prinzip wird oft angewendet. Würde man allerdings einfach am Ende die Zeiger tauschen käme es zu einem Crash! Der Interrupt kann jederzeit aktiv werden. Wenn dann die Zeiger nur halb kopiert sind greift die Interruptroutine auf zerstückelte Daten zu und macht Müll. Ebenso würde es zu Fehlfunktionen kommen, wenn während es PWM-Zyklus neue Daten in die Arrays kopiert werden. Das muß verhindert werden. Und zwar dadurch, daß über eine Variable eine Synchronisation durchgeführt wird. Diese wird am Ende des PWM-Zyklus gesetzt und signalisiert, daß neue Daten für den nächsten Zyklus kopiert werden können. Deshalb muss die Funktion pwm_update ggf. bis zu 1 vollen PWM-Zyklus warten, bis die Zeiger getauscht werden können. Wichtig ist dabei, daß die Variable pwm_sync, welche sowohl in der Funktion als auch im Interrupt geschrieben wird, als '''volatile''' deklariert wird. Denn sonst würde die Sequenz

<c>
pwm_sync=0; // Sync wird im Interrupt gesetzt
while(pwm_sync==0);
</c>

zum Stehenbleiben der CPU führen, weil der Compiler erkennt, daß die Variable nie ungleich Null sein kann und damit die Schleife endlos ausgeführt wird. Der Compiler kann prinzipbedingt nicht automatisch erkennen, daß die Variable im Interrupt auf 1 gesetzt wird.

Bei dem schon recht hohen Prozessortakt von 8MHz und der relativ niedrigen PWM Frequenz von 100 Hz haben wir allerdings ein kleines Problem. Wenn beispielsweise nur ein Kanal den PWM-Wert 10 hat, alle anderen aber den Wert Null, dann passiert folgendes. Zum Begin eines PWM-Zyklus wird der eine Kanal aktiviert. Jetzt wird per Timer für 10xT_PWM = 3120 Takte gewartet. Jetzt wird dieser Kanal wieder gelöscht. Bis zum Begin des nächsten PWM-Zyklus muss jedoch noch (256-10)*T_PWM = 76752 Takte gewartet werden. Doch diese Zahl passt nicht mehr in eine 16 Bit Variable! Und damit kann sie auch nicht mit dem Timer verwendet werden. Der Ausweg heisst Vorteiler (engl. Prescaler). Damit kann der Timer langsamer getaktet werden und somit wird die gleiche Wartezeit mit weniger Timertakten erzielt. Zu beachten ist, dass die Einstellung im #define PWM_PRESCALER mit der realen Einstellung in TCCR1B übereinstimmen muss.

Eine Einschränkung gilt allerdings für alle Soft-PWMs. Die PWM-Frequenz muss niedrig genug sein, damit sich die Interrupts nicht überschneiden. D.h. der Wert T_PWM muß immer größer sein als die Anzahl Takte der Interruptroutine. Das wird im Quelltext mit Hilfe von #if . . #endif geprüft. Die +5 Takte sind eine Reserve. Dazu muß aber die Optimierung -Os eingeschaltet sein, sonst stimmen die Zahlen nicht!

== Zusammenfassung ==

Durch kritische Analyse ist es möglich, eine Software-PWM drastisch zu verbessern und die CPU-Belastung auf ein verschwindend geringes Maß zu reduzieren. Zudem zeigt dieses Beispiel ein oft vorkommendes Muster auf, welches gemeinhin als 'Time for Space' (Zeit für Platz) bezeichnet wird. Man meint damit, dass es oft möglich ist, dramatische Einsparungen in der Laufzeit zu erreichen, wenn man gewillt ist dafür Speicherplatz zu opfern.

{| border="1"
|-
| Version || Programmspeicher [Byte] || CPU-Belastung [%]
|- align="center"
| 1 || 284 || 49
|- align="center"
| 2 || 324 || 30
|- align="center"
| 3 || 968 || 0,3..1,2
|}

[[Category:AVR]]

== Siehe auch ==

* [[AVR-Tutorial: PWM]]
* [[AVR-GCC-Tutorial#PWM (Pulsweitenmodulation)|AVR-GCC-Tutorial: PWM]]
* [[LED-Fading]] - LED dimmen mit PWM

Soft-PWM

2010-05-16T20:25:53Z

91.19.247.16: /* Zusammenfassung */

== Einleitung ==
[[PWM]] ist eine oft verwendete Funktion auf dem Gebiet der Mikrocontroller. Damit lassen sich vielfältige Aufgaben lösen, wie beispielsweise die Leistungssteuerung von Motoren, Helligkeitssteuerung von [[LED-Fading | LEDs]], [[DA-Wandler | Digital-Analog Wandlung]] und vieles mehr. Die meisten Mikrocontroller haben ein oder mehrere PWM-Module eingebaut, womit ohne CPU-Belastung eine PWM generiert werden kann. Jedoch kommt es bisweilen vor, daß die Anzahl der verfügbaren PWM-Kanäle nicht ausreicht. Dann muß eine Softwarelösung gefunden werden, bei der die CPU die PWM-Generierung vornimmt, allgemein Soft-PWM genannt.

'''Achtung:''' Wenn man für eine PWM aussschliesslich 8 Bit breite Datentypen verwendet, dann steht für den Parameter für die Pulsbreite nur der Bereich 0..255 zur Verfügung. Da bei einer vollständigen PWM mit N Schritten aber N+1 mögliche Fälle auftreten können (0/N bis N/0), ist mit dem hier gezeigten Code eine solche PWM nur für N <= 255 realisierbar.

== Einfacher Lösungsansatz ==

Ein sehr einfacher Lösungsansatz findet sich im [[AVR-Tutorial: PWM]]. Hier wird schon ein [[AVR-Tutorial: Timer | Timer]] benutzt, um in regelmäßigen Abständen die PWM-Generierung durchzuführen. Damit verbleibt noch Rechenzeit für andere Aufgaben, außerdem wird die Programmierung wesentlich vereinfacht. Allerdings ist das Beispiel in ASM, hier soll das ganze in [[C]] gemacht werden.

Es soll nun eine 8 Bit PWM mit 100 Hz (PWM-Zyklus 10ms) und acht Kanälen generiert werden. Der verwendete Controller ist ein [[AVR]] vom Typ ATmega32, welcher mit dem internen RC-Oszillator auf 8 MHz getaktet wird. Das Programm kann jedoch problemlos an so ziemlich jeden anderen AVR angepaßt werden. Die Programme wurden mit dem Optimierungsgrad -Os compiliert.

=== Erster Versuch ===

Das Programm ist recht kurz und übersichtlich. Im Hauptprogramm wird der Timer 1 initialisiert und der Output Compare 1A als variabler Timer verwendet, wobei die Output Compare Funktion nicht mit dem IO-Pin verbunden ist. Im Interrupt, welcher regelmäßig aufgerufen wird, werden nun in einer Schleife alle acht Kanäle geprüft. Alle Kanäle werden auf HIGH gesetzt, welche eine PWM-Einstellung größer als der aktuelle Zykluszähler haben. Sinnvollerweise werden erst alle Kanäle geprüft und das Ergebnis zwischengespeichert, am Ende erfolgt nur ein Zugriff auf den Port.

<c>
/*
Eine 8-kanalige PWM mit einfachem Lösungsansatz

ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L // Systemtakt in Hz
#define F_PWM 100 // PWM-Frequenz in Hz
#define PWM_STEPS 255 // PWM-Schritte pro Zyklus(1..255)
#define PWM_PORT PORTD // Port für PWM
#define PWM_DDR DDRD // Datenrichtungsregister für PWM

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt

#if (T_PWM<(152+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

#if PWM_STEPS > 255
#error PWM_STEPS zu gross
#endif

// includes

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

// globale Variablen

volatile uint8_t pwm_setting[8]; // Einstellungen für die einzelnen PWM-Kanäle

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
static uint8_t pwm_cnt=0;
uint8_t tmp=0, i=0, j=1;

OCR1A += (uint16_t)T_PWM;

for (; i<8; i++) {
if (pwm_setting[i] > pwm_cnt) tmp |= j;
j<<=1;
}
PWM_PORT = tmp; // PWMs aktualisieren
if (pwm_cnt==(uint8_t)(PWM_STEPS-1))
pwm_cnt=0;
else
pwm_cnt++;
}

int main(void) {

// PWM einstellen

PWM_DDR = 0xFF; // Port als Ausgang

// Timer 1 OCRA1, als variablem Timer nutzen

TCCR1B = 1; // Timer läuft mit vollem Systemtakt
TIMSK |= (1<<OCIE1A); // Interrupt freischalten

sei(); // Interrupts gloabl einschalten

/*********************************************************************/
// nur zum Testen, im Anwendungsfall löschen

volatile uint8_t tmp;
const uint8_t t1[8]={27, 40, 3, 17, 150, 99, 5, 9};
const uint8_t t2[8]={27, 40, 3, 0, 150, 99, 5, 9};
const uint8_t t3[8]={27, 40, 3, 17, 3, 99, 3, 0};
const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t t5[8]={0, 0, 0, 0, 0, 0, 0, 9};
const uint8_t t6[8]={33, 33, 33, 33, 33, 33, 33, 33};

// Messung der Interruptdauer
tmp =0;
tmp =0;
tmp =0;

// Debug

memcpy(pwm_setting, t1, 8);

memcpy(pwm_setting, t2, 8);

memcpy(pwm_setting, t3, 8);

memcpy(pwm_setting, t4, 8);

memcpy(pwm_setting, t5, 8);

memcpy(pwm_setting, t6, 8);

/*********************************************************************/

return 0;
}
</c>

Im [[AVR-Studio]] kann man den Code simulieren. Wichtig ist hier vor allem die Ausführungszeit des Interrupts. Bei 100 Hz PWM-Frequenz und 256 Schritten pro PWM-Zyklus wird diese Funktion immerhin 25600 mal pro Sekunde aufgerufen (PWM-Takt 25,6 kHz), bei 8MHz Taktfrequenz stehen damit maximal 312 Takte zur Verfügung. Glücklicherweise ist die Funktion relativ kurz und der GCC leistet gute Arbeit. Der Interrupt benötigt hier 152 Takte, es verbleiben also jeweils 160 Takte zur Bearbeitung anderer Aufgaben. Das entspricht einer CPU-Belastung von ~49%. Das Programm benötigt 284 Byte Programmspeicher. Nicht schlecht für den Anfang.

=== Zweiter Versuch ===

Wo gibt es in diesem Programm noch Optimierungsmöglichkeiten? Nur im Interrupt, denn das ganze Programm besteht ja praktisch nur aus der Interruptroutine. Betrachten wir die Schleifen genauer müssen wir feststellen, daß die Indizierung von pwm_setting[] etwas Rechenzeit benötigt. Ebenso die Schiebeoperation von tmp, auch wenn das nur acht mal ein Takt ist. Wir können jetzt per Hand das machen, was der Compiler auch manchmal macht. Die Rede ist vom Loop-Unrolling. Dabei wird die Schleife durch mehrere diskrete Befehle ersetzt (entrollt). Der Vorteil dabei ist, daß die Befehle zur Berechnung und Prüfung der Zählvariable entfallen, außerdem können ggf. Werte im Voraus berechnet werden. Als Ergebnis hat man zwar ein etwas größeres Programm, doch das wird schneller ausgeführt! Ausserdem orientiert sich diese Version mehr am Original der Assemblerversion. Dadurch wird sie zusätzlich ein wenig kürzer und schneller.

<c>
/*
Eine 8-kanalige PWM mit verbessertem Lösungsansatz

ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L // Systemtakt in Hz
#define F_PWM 100 // PWM-Frequenz in Hz
#define PWM_STEPS 256 // PWM-Schritte pro Zyklus(1..256)
#define PWM_PORT PORTD // Port für PWM
#define PWM_DDR DDRD // Datenrichtungsregister für PWM

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt

#if (T_PWM<(93+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

// includes

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

// globale Variablen

volatile uint8_t pwm_setting[8]; // Einstellungen für die einzelnen PWM-Kanäle

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
static uint8_t pwm_cnt=0;
uint8_t tmp=0;

OCR1A += (uint16_t)T_PWM;

if (pwm_setting[0] > pwm_cnt) tmp |= (1<<0);
if (pwm_setting[1] > pwm_cnt) tmp |= (1<<1);
if (pwm_setting[2] > pwm_cnt) tmp |= (1<<2);
if (pwm_setting[3] > pwm_cnt) tmp |= (1<<3);
if (pwm_setting[4] > pwm_cnt) tmp |= (1<<4);
if (pwm_setting[5] > pwm_cnt) tmp |= (1<<5);
if (pwm_setting[6] > pwm_cnt) tmp |= (1<<6);
if (pwm_setting[7] > pwm_cnt) tmp |= (1<<7);
PWM_PORT = tmp; // PWMs aktualisieren
if (pwm_cnt==(uint8_t)(PWM_STEPS-1))
pwm_cnt=0;
else
pwm_cnt++;
}

int main(void) {

// PWM einstellen

PWM_DDR = 0xFF; // Port als Ausgang

// Timer 1 OCRA1, als variablem Timer nutzen

TCCR1B = 1; // Timer läuft mit vollem Systemtakt
TIMSK |= (1<<OCIE1A); // Interrupt freischalten

sei(); // Interrupts gloabl einschalten

/*********************************************************************/
// nur zum Testen, im Anwendungsfall löschen

volatile uint8_t tmp;
const uint8_t t1[8]={27, 40, 3, 17, 150, 99, 5, 9};
const uint8_t t2[8]={27, 40, 3, 0, 150, 99, 5, 9};
const uint8_t t3[8]={27, 40, 3, 17, 3, 99, 3, 0};
const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t t5[8]={0, 0, 0, 0, 0, 0, 0, 9};
const uint8_t t6[8]={33, 33, 33, 33, 33, 33, 33, 33};

// Messung der Interruptdauer
tmp =0;
tmp =0;
tmp =0;

// Debug

memcpy(pwm_setting, t1, 8);

memcpy(pwm_setting, t2, 8);

memcpy(pwm_setting, t3, 8);

memcpy(pwm_setting, t4, 8);

memcpy(pwm_setting, t5, 8);

memcpy(pwm_setting, t6, 8);

/*********************************************************************/

return 0;
}
</c>

Mit dieser Interruptroutine werden nur noch 93 Takte benötigt, die CPU-Belastung verringert sich auf ~30%. Nicht schlecht. Der Programmcode steigt auf 324 Byte, aber das ist im Angesicht der Leistungsverbesserung zu verschmerzen. Weiter verringern kann man die CPU-Belastung durch eine niedrigere PWM-Frequenz oder eine geringere Anzahl Stufen der PWM. Wenn man beispielsweise mit 64 (6 Bit) statt 256 (8 Bit) Stufen auskommt verringert sich die Belastung um den Faktor 4.

== Intelligenter Lösungsansatz ==

Wenn auch eine CPU-Last von 30% recht akzeptabel erscheint, so hat man doch noch irgendwie das Gefühl, daß es noch besser geht. Aber wie? Mein Mathematikprofessor pflegte in so einem Fall die Anwendung der „Methode des scharfen Blicks“ ™. Was passiert eigentlich während eines gesamten PWM-Zykluses?

*Zu Beginn werden alle IO-Pins gesetzt, deren PWM-Einstellung nicht Null ist.
*Die jeweiligen IO-Pins werden gelöscht, wenn der PWM-Zähler mit der PWM-Einstellung übereinstimmt

Ja klar, aber da wir nur acht Kanäle haben, gibt es maximal 8 Zeitpunkte, an denen ein Pin gelöscht werden muss. Wenn mehrere Kanäle die gleiche PWM-Einstellung haben sind es sogar noch weniger. Alle anderen Interrupts verursachen keinerlei Änderung der IO-Pins und verbrauchen eigentlich nur sinnlos Rechenzeit. Ein Skandal!

Was ist also zu tun? Wir wissen nun, daß es maximal 9 Ereignisse pro PWM-Zyklus gibt. Was ist damit zu machen?

*Die PWM-Kanäle müssen in aufsteigender Folge sortiert werden.
*Wenn mehrere PWM-Kanäle den gleichen PWM-Wert haben müssen sie zusammengefaßt werden
*Die Zeitdifferenzen zwischen den einzelnen Ereignissen müssen berechnet werden

Das ist eigentlich schon alles. Praktisch ist das mit einigen Kniffligkeiten verbunden, aber die sind lösbar. Am Ende steht eine Interruptroutine, welche maximal 9 mal pro PWM-Zyklus aufgerufen wird und die jeweiligen IO-Pins setzt bzw. löscht. Eine normale Funktion wird benutzt, um die PWM-Einstellungen der acht Kanäle in die notwendigen Informationen für die Interruptroutine umzuwandeln. Das hat unter anderem den Vorteil, daß nur dann zusätzlich Rechenzeit benötigt wird, wenn sich die PWM-Einstellungen ändern.

<c>
/*
Eine 8-kanalige PWM mit intelligentem Lösungsansatz

ATmega32 @ 8 MHz

*/

// Defines an den Controller und die Anwendung anpassen

#define F_CPU 8000000L // Systemtakt in Hz
#define F_PWM 100L // PWM-Frequenz in Hz
#define PWM_PRESCALER 8 // Vorteiler für den Timer
#define PWM_STEPS 256 // PWM-Schritte pro Zyklus(1..256)
#define PWM_PORT PORTB // Port für PWM
#define PWM_DDR DDRB // Datenrichtungsregister für PWM
#define PWM_CHANNELS 8 // Anzahl der PWM-Kanäle

// ab hier nichts ändern, wird alles berechnet

#define T_PWM (F_CPU/(PWM_PRESCALER*F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt
//#define T_PWM 1 //TEST

#if ((T_PWM*PWM_PRESCALER)<(111+5))
#error T_PWM zu klein, F_CPU muss vergrösst werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif

#if ((T_PWM*PWM_STEPS)>65535)
#error Periodendauer der PWM zu gross! F_PWM oder PWM_PRESCALER erhöhen.
#endif
// includes

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

// globale Variablen

uint16_t pwm_timing[PWM_CHANNELS+1]; // Zeitdifferenzen der PWM Werte
uint16_t pwm_timing_tmp[PWM_CHANNELS+1];
uint8_t pwm_mask[PWM_CHANNELS+1]; // Bitmaske für PWM Bits, welche gelöscht werden sollen
uint8_t pwm_mask_tmp[PWM_CHANNELS+1];
uint8_t pwm_setting[PWM_CHANNELS]; // Einstellungen für die einzelnen PWM-Kanäle
uint8_t pwm_setting_tmp[PWM_CHANNELS+1]; // Einstellungen der PWM Werte, sortiert

volatile uint8_t pwm_cnt_max=1; // Zählergrenze, Initialisierung mit 1 ist wichtig!
volatile uint8_t pwm_sync; // Update jetzt möglich

// Pointer für wechselseitigen Datenzugriff

uint16_t * isr_ptr_time = pwm_timing;
uint16_t * main_ptr_time = pwm_timing_tmp;
uint8_t * isr_ptr_mask = pwm_mask;
uint8_t * main_ptr_mask = pwm_mask_tmp;

// Zeiger austauschen
// das muss in einem Unterprogramm erfolgen,
// um eine Zwischenspeicherung durch den Compiler zu verhindern

void tausche_zeiger(void) {
uint16_t * tmp_ptr16;
uint8_t * tmp_ptr8;

tmp_ptr16 = isr_ptr_time;
isr_ptr_time = main_ptr_time;
main_ptr_time = tmp_ptr16;
tmp_ptr8 = isr_ptr_mask;
isr_ptr_mask = main_ptr_mask;
main_ptr_mask = tmp_ptr8;
}

// PWM Update, berechnet aus den PWM Einstellungen
// die neuen Werte für die Interruptroutine

void pwm_update(void) {
uint8_t i, j, k, min;
uint8_t tmp;

// PWM Maske für Start berechnen
// gleichzeitig die Bitmasken generieren und PWM Werte kopieren

tmp=0;
j = 1;
for(i=1; i<=(PWM_CHANNELS); i++) {
main_ptr_mask[i]=~j; // Maske zum Löschen der PWM Ausgänge
pwm_setting_tmp[i] = pwm_setting[i-1];
if (pwm_setting_tmp[i]!=0) tmp |= j; // Maske zum setzen der IOs am PWM Start
j <<= 1;
}
main_ptr_mask[0]=tmp; // PWM Start Daten

// PWM settings sortieren; Einfügesortieren

for(i=1; i<=PWM_CHANNELS; i++) {
min=255;
k=i;
for(j=i; j<=PWM_CHANNELS; j++) {
if (pwm_setting_tmp[j]<min) {
k=j; // Index und PWM-setting merken
min = pwm_setting_tmp[j];
}
}
if (k!=i) {
// ermitteltes Minimum mit aktueller Sortiertstelle tauschen
tmp = pwm_setting_tmp[k];
pwm_setting_tmp[k] = pwm_setting_tmp[i];
pwm_setting_tmp[i] = tmp;
tmp = main_ptr_mask[k];
main_ptr_mask[k] = main_ptr_mask[i];
main_ptr_mask[i] = tmp;
}
}

// Gleiche PWM-Werte vereinigen, ebenso den PWM-Wert 0 löschen falls vorhanden

k=PWM_CHANNELS; // PWM_CHANNELS Datensätze
i=1; // Startindex

while(k>i) {
while ( ((pwm_setting_tmp[i]==pwm_setting_tmp[i+1]) || (pwm_setting_tmp[i]==0)) && (k>i) ) {

// aufeinanderfolgende Werte sind gleich und können vereinigt werden
// oder PWM Wert ist Null
if (pwm_setting_tmp[i]!=0)
main_ptr_mask[i+1] &= main_ptr_mask[i]; // Masken vereinigen

// Datensatz entfernen,
// Nachfolger alle eine Stufe hochschieben
for(j=i; j<k; j++) {
pwm_setting_tmp[j] = pwm_setting_tmp[j+1];
main_ptr_mask[j] = main_ptr_mask[j+1];
}
k--;
}
i++;
}

// letzten Datensatz extra behandeln
// Vergleich mit dem Nachfolger nicht möglich, nur löschen
// gilt nur im Sonderfall, wenn alle Kanäle 0 sind
if (pwm_setting_tmp[i]==0) k--;

// Zeitdifferenzen berechnen

if (k==0) { // Sonderfall, wenn alle Kanäle 0 sind
main_ptr_time[0]=(uint16_t)T_PWM*PWM_STEPS/2;
main_ptr_time[1]=(uint16_t)T_PWM*PWM_STEPS/2;
k=1;
}
else {
i=k;
main_ptr_time[i]=(uint16_t)T_PWM*(PWM_STEPS-pwm_setting_tmp[i]);
j=pwm_setting_tmp[i];
i--;
for (; i>0; i--) {
main_ptr_time[i]=(uint16_t)T_PWM*(j-pwm_setting_tmp[i]);
j=pwm_setting_tmp[i];
}
main_ptr_time[0]=(uint16_t)T_PWM*j;
}

// auf Sync warten

pwm_sync=0; // Sync wird im Interrupt gesetzt
while(pwm_sync==0);

// Zeiger tauschen
cli();
tausche_zeiger();
pwm_cnt_max = k;
sei();
}

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
static uint8_t pwm_cnt;
uint8_t tmp;

OCR1A += isr_ptr_time[pwm_cnt];
tmp = isr_ptr_mask[pwm_cnt];

if (pwm_cnt == 0) {
PWM_PORT = tmp; // Ports setzen zu Begin der PWM
pwm_cnt++;
}
else {
PWM_PORT &= tmp; // Ports löschen
if (pwm_cnt == pwm_cnt_max) {
pwm_sync = 1; // Update jetzt möglich
pwm_cnt = 0;
}
else pwm_cnt++;
}
}

int main(void) {

// PWM Port einstellen

PWM_DDR = 0xFF; // Port als Ausgang

// Timer 1 OCRA1, als variablen Timer nutzen

TCCR1B = 2; // Timer läuft mit Prescaler 8
TIMSK |= (1<<OCIE1A); // Interrupt freischalten

sei(); // Interrupts gloabl einschalten

/******************************************************************/
// nur zum testen, in der Anwendung entfernen
/*
// Test values
volatile uint8_t tmp;
const uint8_t t1[8]={255, 40, 3, 17, 150, 99, 5, 9};
const uint8_t t2[8]={27, 40, 3, 0, 150, 99, 5, 9};
const uint8_t t3[8]={27, 40, 3, 17, 3, 99, 3, 0};
const uint8_t t4[8]={0, 0, 0, 0, 0, 0, 0, 0};
const uint8_t t5[8]={9, 1, 1, 1, 1, 1, 1, 1};
const uint8_t t6[8]={33, 33, 33, 33, 33, 33, 33, 33};
const uint8_t t7[8]={0, 0, 0, 0, 0, 0, 0, 88};

// Messung der Interruptdauer
tmp =1;
tmp =2;
tmp =3;

// Debug

memcpy(pwm_setting, t1, 8);
pwm_update();

memcpy(pwm_setting, t2, 8);
pwm_update();

memcpy(pwm_setting, t3, 8);
pwm_update();

memcpy(pwm_setting, t4, 8);
pwm_update();

memcpy(pwm_setting, t5, 8);
pwm_update();

memcpy(pwm_setting, t6, 8);
pwm_update();

memcpy(pwm_setting, t7, 8);
pwm_update();
*/
/******************************************************************/

while(1);
return 0;
}
</c>

Das Programm ist schon um einiges länger (968 Byte). Die Interruptroutine benötigt maximal 111 Takte und wird zwischen 2 bis 9 mal pro PWM-Zyklus aufgerufen. Zweimal, wenn alle PWM-Einstellungen gleich sind, 9 mal, wenn alle PWM-Einstellungen verschieden sind. Damit werden zwischen 222 bis 999 Takte benötigt, pro '''PWM-Zyklus''', nicht pro PWM-Takt! Das entspricht einer '''CPU-Belastung von 0,3..1,2%'''! [http://de.wikipedia.org/wiki/Beifall Standing Ovations]! Die Funktion pwm_update() benötigt ca. 1500 bis 1800 Takte, das ist geringfügig abhängig von den PWM-Einstellungen, je nach dem ob die Daten schon sortiert sind und ob PWM-Werte mehrfach vorkommen. Bei einer Updaterate von 100 Hz (mehr ist physikalisch sinnlos) entspricht das einer CPU-Belastung von 2,3%, praktisch wird es wahrscheinlich weniger sein. Taktet man den AVR mit vollen 16 MHz halbiert sich die CPU-Belastung noch einmal. Beachtet werden sollte hier die Datenübergabe von der Funktion pwm_update() zur Interruptroutine. Hier werden jeweils zwei Zeiger verwendet, um auf Arrays zu zeigen. In zwei Arrays werden durch die Funktion die Berechnungen der neuen Daten vorgenommen. In den beiden anderen Arrays stehen die aktuellen Daten, mit welchen die ISR arbeitet. Um am Ende der Berechung ein relativ aufwändiges Kopieren der Daten zu vermeiden werden einfach die Zeiger vertauscht. Das ist wesentlich schneller als das Kopieren der Arrays! Im englischen spricht man hier von double buffering, also doppelter Pufferung. Dieses Prinzip wird oft angewendet. Würde man allerdings einfach am Ende die Zeiger tauschen käme es zu einem Crash! Der Interrupt kann jederzeit aktiv werden. Wenn dann die Zeiger nur halb kopiert sind greift die Interruptroutine auf zerstückelte Daten zu und macht Müll. Ebenso würde es zu Fehlfunktionen kommen, wenn während es PWM-Zyklus neue Daten in die Arrays kopiert werden. Das muß verhindert werden. Und zwar dadurch, daß über eine Variable eine Synchronisation durchgeführt wird. Diese wird am Ende des PWM-Zyklus gesetzt und signalisiert, daß neue Daten für den nächsten Zyklus kopiert werden können. Deshalb muss die Funktion pwm_update ggf. bis zu 1 vollen PWM-Zyklus warten, bis die Zeiger getauscht werden können. Wichtig ist dabei, daß die Variable pwm_sync, welche sowohl in der Funktion als auch im Interrupt geschrieben wird, als '''volatile''' deklariert wird. Denn sonst würde die Sequenz

<c>
pwm_sync=0; // Sync wird im Interrupt gesetzt
while(pwm_sync==0);
</c>

zum Stehenbleiben der CPU führen, weil der Compiler erkennt, daß die Variable nie ungleich Null sein kann und damit die Schleife endlos ausgeführt wird. Der Compiler kann prinzipbedingt nicht automatisch erkennen, daß die Variable im Interrupt auf 1 gesetzt wird.

Bei dem schon recht hohen Prozessortakt von 8MHz und der relativ niedrigen PWM Frequenz von 100 Hz haben wir allerdings ein kleines Problem. Wenn beispielsweise nur ein Kanal den PWM-Wert 10 hat, alle anderen aber den Wert Null, dann passiert folgendes. Zum Begin eines PWM-Zyklus wird der eine Kanal aktiviert. Jetzt wird per Timer für 10xT_PWM = 3120 Takte gewartet. Jetzt wird dieser Kanal wieder gelöscht. Bis zum Begin des nächsten PWM-Zyklus muss jedoch noch (256-10)*T_PWM = 76752 Takte gewartet werden. Doch diese Zahl passt nicht mehr in eine 16 Bit Variable! Und damit kann sie auch nicht mit dem Timer verwendet werden. Der Ausweg heisst Vorteiler (engl. Prescaler). Damit kann der Timer langsamer getaktet werden und somit wird die gleiche Wartezeit mit weniger Timertakten erzielt. Zu beachten ist, dass die Einstellung im #define PWM_PRESCALER mit der realen Einstellung in TCCR1B übereinstimmen muss.

Eine Einschränkung gilt allerdings für alle Soft-PWMs. Die PWM-Frequenz muss niedrig genug sein, damit sich die Interrupts nicht überschneiden. D.h. der Wert T_PWM muß immer größer sein als die Anzahl Takte der Interruptroutine. Das wird im Quelltext mit Hilfe von #if . . #endif geprüft. Die +5 Takte sind eine Reserve. Dazu muß aber die Optimierung -Os eingeschaltet sein, sonst stimmen die Zahlen nicht!

== Zusammenfassung ==

Durch kritische Analyse ist es möglich, eine Software-PWM drastisch zu verbessern und die CPU-Belastung auf ein verschwindend geringes Maß zu reduzieren. Zudem zeigt dieses Beispiel ein oft vorkommendes Muster auf, welches gemeinhin als 'Time for Space' (Zeit für Platz) bezeichnet wird. Man meint damit, dass es oft möglich ist, dramatische Einsparungen in der Laufzeit zu erreichen, wenn man gewillt ist dafür Speicherplatz zu opfern.

{| border="1"
|-
| Version || Programmspeicher [Byte] || CPU-Belastung [%]
|- align="center"
| 1 || 284 || 49
|- align="center"
| 2 || 324 || 30
|- align="center"
| 3 || 968 || 0,3..1,2
|}

[[Category:AVR]]

== Siehe auch ==

* [[AVR-Tutorial: PWM]]
* [[AVR-GCC-Tutorial#PWM (Pulsweitenmodulation)|AVR-GCC-Tutorial: PWM]]
* [[Soft-PWM]] - PWM in Software
* [[LED-Fading]] - LED dimmen mit PWM