PWM mit Timer0 & 2 mit ATmega168PA läuft nicht

[Hans Schmidt (Gast)]

Hallo,

stehe gerade mit der PWM Funktion (phase correct PWM, Mode 5) der Timer 
0 und 2 bei meinem ATmega168PA auf Kriegsfuss. An den Ausgangspins 
passiert einfach nichts, d.h. die wechseln nie von 0 auf 1. Die Timer 
zählen/laufen brav, der Wert für TOP ist gesetzt und die vier OCxx Bits 
sind auch gesetzt.
Was habe ich an der Stelle vergessen, bzw. mache ich falsch?

Gruß, Hans

/*****************************************************************
**
** Includes/externe Bibliotheken die im Programm genutzt werden
**
******************************************************************/
// zentrale Konfigurationsdaten einbinden
#include "config.h"
// zur Nutzung von I/O-Pins
#include <avr/io.h>
// Warteschleifen
#include <util/delay.h>
// Interrupts nutzen
#include <avr/interrupt.h>
// Funktionen zum Zugriff auf den UART (RS232)
#include "./USART/uart.h"
// zur Konvertierung eines Integer in einen String mittles itoa
#include <stdlib.h>

/*****************************************************************
**
** Initialisiert die Ports des uControllers
** Parameter: keine
** Rückgabewert: keiner
**
******************************************************************/
void init_ports (void)
{
  // Port B
  //  Pin 0: ungenutzt
  //  Pin 1: ungenutzt
  //  Pin 2: ungenutzt
  //  Pin 3: Ausgang, PWM Timer 2
  //  Pin 4: ungenutzt
  //  Pin 5: ungenutzt
  //  Pin 6: ungenutzt
  //  Pin 7: ungenutzt
  PORTB |= (1 << PB0) | (1 << PB1) | (1 << PB2) | (1 << PB4) | (1 << PB5) | (1 << PB6) | (1 << PB7);
  DDRB |= (1 << DDB3); // Pin 3 im Richtungsregister als Ausgang definieren (ohne Pull-Up)
  // Port D
  //  Pin 0: Eingang, serielle Schnittstelle (RxD)
  //  Pin 1: Ausgang, serielle Schnittstelle (TxD)
  //  Pin 2: Ausgang, An-Ausschalter Pumpe 1
  //  Pin 3: Ausgang, PWM Timer 2
  //  Pin 4: ungenutzt
  //  Pin 5: Ausgang, PWM Timer 0
  //  Pin 6: Ausgang, PWM Timer 0
  //  Pin 7: Ausgang, An-Ausschalter Pumpe 2
  PORTD |= (1 << PD0) | (1 << PD2) | (1 << PD4) | (1 << PD7);
  DDRD |= (1 << DDD1) | (1 << DDD2) | (1 << DDD3) | (1 << DDD5) | (1 << DDD6) | (1 << DDD7); // Pin 1; 2; 3; 5; 6 & 7 im Richtungsregister als Ausgang definieren (2 & 7 mit Pull-Up)
}

/*****************************************************************
**
** Initialisiert den Timer 0 im PWM Modus
** Parameter: keine
** Rückgabewert: keiner
**
******************************************************************/
void init_pwm0 (void)
{
  // entsprechende Pins (Output Compare 0, Kanal A & B) als Ausgang schalten
  DDRD |= (1 << DDD5) | (1 << DDD6);
  // Phase Correct PWM Modus, setze OC0A & OC0B bei Null/unten, loesche OC0A & OC0B wenn der Timerwert OCR0A bzw. OCR0B erreicht hat
  TCCR0A |= (1 << COM0A1) | (1 << COM0B1) | (1 << WGM00);
  //  Takt = F_CPU (kein Vorteiler)
  TCCR0B |= (1 << WGM02) | (1 << CS00);
  // Vergleichswert für den Timer = oberes Ende setzen
  OCR0A = 0xE0;
  OCR0B = 0xE0;
}

/*****************************************************************
**
** Initialisiert den Timer 2 im PWM Modus
** Parameter: keine
** Rückgabewert: keiner
**
******************************************************************/
void init_pwm2 (void)
{
  // entsprechende Pins (Output Compare 2, Kanal A & B) als Ausgang schalten
  DDRB |= (1 << DDB3);
  DDRD |= (1 << DDD3);
  // Phase Correct PWM Modus, setze OC2A & OC2B bei Null/unten, loesche OC2A & OC2B wenn der Timerwert OCR2A bzw. OCR2B erreicht hat
  TCCR2A |= (1 << COM2A1) | (1 << COM2B1) | (1 << WGM20);
  //  Takt = F_CPU (kein Vorteiler)
  TCCR2B |= (1 << WGM22) | (1 << CS20);
  // Vergleichswert für den Timer = oberes Ende setzen
  OCR2A = 0xE0;
  OCR2B = 0xE0;
}

/*****************************************************************
**
** Hauptprogramm
** Parameter: keine
** Rückgabewert: Exit code (irrelevant, wird nie erreicht)
**
******************************************************************/
int main(void) // Beginn des Hauptprogrammes
{
  // (zur Sicherheit) Interrupts sperren (sollte unnötig sein)
  cli ();
  // Ports initialisieren
  init_ports ();
  // PWM an Timer 0 initialisieren
  init_pwm0 ();
  // PWM an Timer 2 initialisieren
  init_pwm2 ();
  // serielle Schnittstelle zum debuggen aktivieren
  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
  sei();
  while (1)
  {
    itoa (OCR2A, str, 10);
    uart_puts("OCR2A Wert: ");
    uart_puts(str);
    uart_puts("\r\n");
    itoa (TCNT2, str, 10);
    uart_puts("TCNT2 Wert: ");
    uart_puts(str);
    uart_puts("\r\n");
    _delay_ms(1000);
  }
}

serielle Ausgabe

OCR2A Wert: 224
TCNT2 Wert: 168
OCR2A Wert: 224
TCNT2 Wert: 54
OCR2A Wert: 224
TCNT2 Wert: 205
OCR2A Wert: 224
TCNT2 Wert: 90
OCR2A Wert: 224
TCNT2 Wert: 207
OCR2A Wert: 224
TCNT2 Wert: 126
[...]

[Stefan F. (Gast)]

> TCCR0A |= (1 << COM0A1) | (1 << COM0B1) | (1 << WGM00);
> TCCR0B |= (1 << WGM02) | (1 << CS00);

> TCCR2A |= (1 << COM2A1) | (1 << COM2B1) | (1 << WGM20);
> TCCR2B |= (1 << WGM22) | (1 << CS20);

Das klappt nur, wenn die Register vorher 0 waren. Vielleicht hast du 
einen Bootloader der die Register ändert, deswegen würde ich lieber = 
anstatt |= verwenden.

[Hans Schmidt (Gast)]

Hallo Stefan,

Bootloader nutze ich nicht, beim (neu-)programmieren des AVRs wird der 
AVR gelöscht und dann neu beschrieben.
Habe es aber auch einmal mit "=" probiert: keine Änderung. Die Pins 
wackeln nicht.
Nehme ich die Initialisierung des Timers 0 raus und packe ein

  PORTD |= (1<<PD5) | (1<<PD6);
  _delay_ms(10);
  PORTD &= ~(1<<PD5) & ~(1<<PD6);
  _delay_ms(10);

in die while Schleife, so lässt das die beiden Pins vom Timer 0 schön 
wackeln.
Bin so langsam echt ratlos...

[S. Landolt (Gast)]

> PWM Funktion (phase correct PWM, Mode 5) der Timer ...

Im Modus 5 ist OCRA der TOP-Wert - ist das berücksichtigt?

[mmmhh (Gast)]

Schon mal OCR0B bzw OCR2B etwas kleiner als OCR0A bzw OCR2A angegeben?

[Hans Schmidt (Gast)]

@Landolt & mmmhh: so wie ich die PWM Funktion des Timers bis jetzt 
verstanden habe, ist es doch wie folgt: der Zähler des Timers (TCNTx) 
zählt von Null bis TOP, von dort wieder runter auf Null, wieder hoch auf 
TOP usw. Wenn ich nun das TOP per OCRxA oder OCRxB auf einen Wert 
kleiner (oder auch größer) als den aktuellen Zählerstand ändere (da TOP 
eben genau diesen Werten entspricht), so läuft der Zähler des Timers 
(TCNTx) über/bis zum max. möglichen Wert (hier: 2^8 da 8-Bit Zähler). 
Den Zähler selbst stört das aber nicht, er zählt dann wieder ganz normal 
von null an wieder weiter nach dem Überlauf (oder von 0xFF eben runter 
Richtung null). Somit hätte ich einmalig ein einziges "unsauberes" PWM 
weil eben nicht bis zu OCRxA gezählt wird, sondern bis 2^8. Sofern OCRxA 
aber konstant bleibt, ist das eine einmalige Sache und im Anschluss 
läuft der Zähler des Timers zw. Null und OCRxA=TOP (bzw. OCRxB). Oder 
habe ich das völlig falsch verstanden?

[Hans Schmidt (Gast)]

mmmhh schrieb:
> Schon mal OCR0B bzw OCR2B etwas kleiner als OCR0A bzw OCR2A angegeben?

OCR0B soltle im Mode 5 komplett außen vor sein, als TOP wird immer OCRxA 
genommen, oder?

[Stefan F. (Gast)]

Da ich sonst keinen weiteren möglichen Fehler entdecken kann, klammere 
ich mich an den letzten Strohhalm: Nimm mal die config.h und die uart.h 
raus.

[S. Landolt (Gast)]

> OCR0B soltle im Mode 5 komplett außen vor sein
?
Einfach mal ausprobieren wie von mmmhh vorgeschlagen, also z.B. 
OCR0B=$A0. Dann blinkt das nämlich bei mir an OC0B, während OC0A 
konstant bleibt.

[Hans Schmidt (Gast)]

Was auch immer das Datenblatt unter 
https://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48_88_168_megaAVR-Data-Sheet-40002074.pdf 
sagt, entweder ist da ein Fehler drin, oder ich kapiere es gar nicht. 
Habe mich schon gewundert, dass z.B. in der Tabelle Table 15-8 immer 
OCRA genannt ist (und nicht OCRnA) und auch an anderer Stelle kleinere 
Ungereimtheiten sind. Auf jeden Fall hat OCRnB einen entscheidenden 
Einfluss auf das Verhalten! Meine Vermutung ist, dass der eine OCR Werte 
der Vergleichswert ist, während der andere TOP festlegt. Sind beide 
ungleich, dann gibt es auch einen PWM am Ausgangspin.

@Landolt: danke für deine Hartnäckigkeit, das war der entscheidende 
Tipp!!!

@all: nutze nun den fast PWM mode und bin glücklich damit. Funktioniert 
alles wie es soll, auch wenn die Phase nun bei Änderungen nicht sauber 
ist. Aber die wird eh nur alle ~2min in kleinen Schritten geändert.

[S. Landolt (Gast)]

> Sind beide ungleich, dann gibt es auch einen PWM am Ausgangspin.

Nicht ganz - OCRnB, welches den Tastgrad der PWM festlegt, muss kleiner 
als der TOP-Wert, d.h. OCRnA, sein, Letzteres bestimmt die Frequenz.

[S. Landolt (Gast)]

... im Modus 5, natürlich.
Und falls Sie eine, mit OCRnA festgelegte Frequenz mit Tastgrad 0.5 
möchten, einfach (1 << COM0A0) (statt (1 << COM0A1)) setzen.

[Hans Schmidt (Gast)]

ja, der Code ist recht gut dokumentiert... Sollte man oben ja sehen und 
die Info hängt mit dran ;-) Aber solche Dinge werde ich auch in zehn 
Jahren noch wissen, denn ich habe schon locker 36h gegrübelt und zig 
Werte per LEDs und seriell ausgegeben weil ich verzweifelte. Das bleibt 
hängen

[Stefan F. (Gast)]

In meinem Datenblatt steht in der Fußnote zur Tabelle:

"A special case occurs when OCR0B equals TOP and COM0B1 is set. In this 
case, the Compare Match is ignored, but the set or clear is done at 
TOP."

Heisst das nicht, dass das Vorhaben des TO von Anfang an hätte 
funktionieren müssen?

[Hans Schmidt (Gast)]

@Stefan: das steht bei mir auch da drin und hatte ich auch so 
verstanden, deswegen hatte ich ja auch noch meine Begründung/Erklärung 
30.12.2020 18:07 geschrieben. Das Silizium ist aber anders gestrickt...

[Stefan F. (Gast)]

Wenn nur der zweite Compare Ausgang nicht funktioniert hätte, wäre ich 
ja vielleicht noch experimentiell drauf gekommen. Aber dass der erste 
Ausgang auch ausfällt wenn OCRnA=OCRnB, das ist schon sehr fies.

Ich werde mir das mal als Textdatei neben das Datenblatt legen. Denn 
irgendwann in den nächsten 10 Jahren wird es bestimmt auch mir passieren 
und dann erinnere ich mich nicht mehr an diesen Thread.

[Stefan F. (Gast)]

Wie ist das denn mit Timer 1, haben wir da die gleiche Abweichung 
zwischen Datenblatt und Chip?

[Stefan F. (Gast)]

Dieses mal ist ausnahmsweise nicht Microchip der Schuldige. Der fehler 
befindet sich schon im Datenblatt von Atmel Rev. A – 06/2016.

[Stefan F. (Gast)]

Ich habe gerade getestet: TTimer 1 ist auch betroffen. Ich würde das so 
zusammen fassen:

Fall: Timer Phase Correct PWM Mode mit OCRnA als TOP.

Die OCR Register sind falsch beschrieben. 
OCRnB (=Pulsbreite) muss >0 und <TOP sein, sonst erhält man kein
Signal am OCRnB Ausgang.

Der OCRnA Ausgang kann in diesem Modus kein PWM Signal erzeugen.

Hat das schon jemand Microchip gemeldet?

[S. Landolt (Gast)]

> Der OCRnA Ausgang kann in diesem Modus kein PWM Signal erzeugen.

Ist das nicht eine reine Definitions- oder Ansichtssache? Da OCRA=TOP 
wäre das "PWM Signal" doch allenfalls ein Nadelimpuls, wenn überhaupt, 
oder?

[Stefan F. (Gast)]

S. Landolt schrieb:
> Ist das nicht eine reine Definitions- oder Ansichtssache? Da OCRA=TOP
> wäre das "PWM Signal" doch allenfalls ein Nadelimpuls, wenn überhaupt,
> oder?

Man würde einen symmetrisches PWM Signal mit 50/50 Tastverhältnis 
erwarten, denn es geht im den Phase Correct Mode.

Der Zähler zählt immer abwechselnd hoch und runter. Bei Erreichen von 
TOP (OCRnA) geht der Ausgang auf LOW, bei Erreichen vom BOTTOM (0) geht 
der Ausgang auf HIGH.

Im Datenblatt steht:

"the Output Compare (OC1x) is cleared on the compare match between TCNT1 
and OCR1x while upcounting, and set on the compare match while 
downcounting."

Tatsächlich passiert folgendes:

OCnA geht einmal auf HIGH und bleibt dann so.
OCnB verhält sich wie beschrieben, aber nur wenn OCRnB >0 und <TOP ist.

Das war mein Code:

    // Phase correct PWM, Prescaler 256, output A+B 
    TCCR1A = (1<<WGM11) + (1<<WGM10) + (1<<COM1A1) + (1<<COM1B1);
    TCCR1B = (1<<WGM13) + (1<<CS12);

    // Set TOP value
    OCR1A = 0x8000;

    // Set pulse width
    OCR1B = 0x7FF0;

    // Output compare outputs A+B
    DDRB = (1<<PB1) + (1<<PB2);

[S. Landolt (Gast)]

> Man würde einen symmetrisches PWM Signal mit 50/50
> Tastverhältnis erwarten

Man vielleicht, ich nicht unbedingt. Aber:
Beitrag "Re: PWM mit Timer0 & 2 mit ATmega168PA läuft nicht"

[Veit D. (devil-elec)]

Hallo,

lässt sich hier jemand verunsichern?  :-)
Auf welche Timereinstellung bezieht sich denn der angebliche Fehler im 
Manual? Der TO hat nämlich eine völlig konfuse Timereinstellung.

Die Timer sollen laut TO im Phase Correct Mode arbeiten. In welchen 
denn?
Da schau ich mir seine WGM Bits an und stelle fest in dem mit 
einstellbaren TOP Wert in OCRxA. Danach sehe ich in seinem Code das er 
jeweils den Compare Wert für Channel A und B gleich gesetzt hat. Da kann 
nichts toggeln. Welche Pulsweite soll sich ändern?
A bestimmt die Periodendauer und B die Pulsweite. Wenn beide gleich sind 
pulst nichts, es liegt Ub an.
Das entspricht 100% Duty Cycle. Genauso muss das auch sein. Alles andere 
wäre ein Fehler.

Wenn B = 0, liegt dauerhaft Masse an, 0% Duty Cycle.
Wenn B = TOP, liegt dauerhaft Ub an, 100% Duty Cycle.
Irgendwas dazwischen erzeugt eine Pulsweite.
50% Duty erhält man nur mit OCRnB = OCRnA / 2.

Der TO hat 2 Möglichkeiten.
a) In diesem Timermode kann er nur einen Ausgang nutzen, nämlich OCRnB 
und kann damit die Frequenz und Pulsweite selbst einstellen.
b) Man nimmt den anderen Phase Correct Mode mit TOP = 255. Dann kann man 
die Frequenz nur noch mittels Prescaler einstellen und beide Ausgänge 
OCRnA und OCRnB für PWM nutzen.

Bsp. nach Möglichkeit a) für einen ATmega328PB, sollte ohne weitere 
Überprüfung zum 168 kompatibel sein. Die Pinbelegung könnte vielleicht 
etwas abweichen.

/*
  Timer-Demo
  ATmega328PB
  31.12.2020
*/

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

void setTimer0PWM(const uint8_t, const uint8_t);
void runTimer0(const uint16_t);
void stopTimer0(void);

void setTimer2PWM(const uint8_t, const uint8_t);
void runTimer2(const uint16_t);
void stopTimer2(void);

int main(void)
{
    DDRD  = DDRD | _BV(PD5);   // OC0B Ausgang
    DDRD  = DDRD | _BV(PD3);   // OC2B Ausgang
    
    setTimer0PWM(200, 150);     // TOP, Duty
    runTimer0(8);               // Prescaler
    
    setTimer2PWM(200, 50);          
    runTimer2(8);            
       
    sei();                      // Interrupts enabled
    
    while (1) 
    {
    }
}

// ****** Funktionen ********* //

// ****** TIMER 0 ************ //
void setTimer0PWM(const uint8_t top, const uint8_t duty)   //  Phase Correct, Mode 5
{   
    TCCR0A = 0;             // Reset
    TCCR0B = 0; 
    TIMSK0 = 0; 
    TCNT0 = 0;  
    OCR0A  = top;           // Compare Match Register <= 255 
    OCR0B  = duty;          // Duty Cycle <= TOP
    TCCR0A = _BV(COM0B1) | _BV(WGM00);  // toggle OC0B pin
    TCCR0B = _BV(WGM02);
}  

void runTimer0 (const uint16_t prescaler)
{
    switch (prescaler) {  // set Prescaler Clock Select Bits
        case    1 : TCCR0B = TCCR0B | _BV(CS00);              break;
        case    8 : TCCR0B = TCCR0B | _BV(CS01);              break;
        case   64 : TCCR0B = TCCR0B | _BV(CS01) | _BV(CS00);  break;
        case  256 : TCCR0B = TCCR0B | _BV(CS02);              break;
        case 1024 : TCCR0B = TCCR0B | _BV(CS02) | _BV(CS00);  break;
        default :  break;
    }
}

void stopTimer0 (void)
{
    TCCR0B = TCCR0B & ~(_BV(CS02) | _BV(CS01) | _BV(CS00));
}


// ****** TIMER 2 ************ //
void setTimer2PWM(const uint8_t top, const uint8_t duty)   // Phase Correct, Mode 5
{
    TCCR2A = 0;             // Reset
    TCCR2B = 0;  
    TIMSK2 = 0;   
    TCNT2 = 0;   
    OCR2A = top;            // Compare Match Register <= 255 
    OCR2B =  duty;          // Duty Cycle <= TOP
    TCCR2A = _BV(COM2B1) | _BV(WGM20);    // toggle OC2B pin
    TCCR2B = _BV(WGM22);
}

void runTimer2 (const uint16_t prescaler)
{
    switch (prescaler) {  // set Prescaler Clock Select Bits
        case    1 : TCCR2B = TCCR2B | _BV(CS20);                break;
        case    8 : TCCR2B = TCCR2B | _BV(CS21);                break;
        case   32 : TCCR2B = TCCR2B | _BV(CS21) | _BV(CS20);    break;
        case   64 : TCCR2B = TCCR2B | _BV(CS22);                break;
        case  128 : TCCR2B = TCCR2B | _BV(CS22) | _BV(CS20);    break;
        case  256 : TCCR2B = TCCR2B | _BV(CS22) | _BV(CS21);    break;
        case 1024 : TCCR2B = TCCR2B | _BV(CS22) | _BV(CS21) | _BV(CS20);    break;
        default :  break;
    }
}

void stopTimer2 (void)
{
    TCCR2B = TCCR2B & ~(_BV(CS22) | _BV(CS21) | _BV(CS20));
}

[Stefan F. (Gast)]

Veit D. schrieb:
> 50% Duty erhält man nur mit OCRnB = OCRnA / 2.

Passt. Ich habe da wohl etwas missverstanden.

> cWenn B = TOP, liegt dauerhaft Ub an, 100% Duty Cycle.

Genau das ist eben nicht der Fall. Wenn OCRnB=TOP ist bleibt der Ausgang 
permanent auf LOW.

[Veit D. (devil-elec)]

Hallo,

noch ein Bsp. im Mode 1 Phase Correct, damit sollte der TO nun klar 
kommen.
Wie gesagt, ggf. Pinbelegung überprüfen.

/*
  Timer-Demo PWM-2
  ATmega328PB
  31.12.2020
  Timer Mode: Phase Correct Mode 1, TOP = 255
*/

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

void setTimer0PWM(const uint8_t, const uint8_t);
void runTimer0(const uint16_t);
void stopTimer0(void);

void setTimer2PWM(const uint8_t, const uint8_t);
void runTimer2(const uint16_t);
void stopTimer2(void);

int main(void)
{
    DDRD  = DDRD | _BV(PD6);   // OC0A Ausgang 
    DDRD  = DDRD | _BV(PD5);   // OC0B Ausgang
    DDRB  = DDRB | _BV(PB3);   // OC2A Ausgang
    DDRD  = DDRD | _BV(PD3);   // OC2B Ausgang
    
    setTimer0PWM(210, 30);      // Duty-A, Duty-B
    setTimer2PWM(105, 40);          
              
    sei();                      // Interrupts enabled
    
    runTimer0(8);               // Prescaler
    runTimer2(8);  
    
    while (1) 
    {
    }
}

// ****** Funktionen ********* //

// ****** TIMER 0 ************ //
void setTimer0PWM(const uint8_t dutyA, const uint8_t dutyB)   //  Phase Correct, Mode 1
{    
    TCCR0A = 0;    // Reset
    TCCR0B = 0; 
    TIMSK0 = 0; 
    TCNT0 = 0;  
    OCR0A  = dutyA;           // Duty Cycle <= 255
    OCR0B  = dutyB;           // Duty Cycle <= 255
    TCCR0A = _BV(COM0A1) | _BV(COM0B1) | _BV(WGM00);  // toggle OC0A und OC0B pin
}  

void runTimer0 (const uint16_t prescaler)
{
    switch (prescaler) {  // set Prescaler Clock Select Bits
        case    1 : TCCR0B = TCCR0B | _BV(CS00);              break;
        case    8 : TCCR0B = TCCR0B | _BV(CS01);              break;
        case   64 : TCCR0B = TCCR0B | _BV(CS01) | _BV(CS00);  break;
        case  256 : TCCR0B = TCCR0B | _BV(CS02);              break;
        case 1024 : TCCR0B = TCCR0B | _BV(CS02) | _BV(CS00);  break;
        default :  break;
    }
}

void stopTimer0 (void)
{
    TCCR0B = TCCR0B & ~(_BV(CS02) | _BV(CS01) | _BV(CS00));
}


// ****** TIMER 2 ************ //
void setTimer2PWM(const uint8_t dutyA, const uint8_t dutyB)   // Phase Correct, Mode 1
{
    TCCR2A = 0;    // Reset
    TCCR2B = 0;  
    TIMSK2 = 0;   
    TCNT2 = 0;   
    OCR2A = dutyA;           // Duty Cycle <= 255
    OCR2B = dutyB;           // Duty Cycle <= 255
    TCCR2A = _BV(COM2A1) | _BV(COM2B1) | _BV(WGM20);    // toggle OC2A und OC2B pin
}

void runTimer2 (const uint16_t prescaler)
{
    switch (prescaler) {  // set Prescaler Clock Select Bits
        case    1 : TCCR2B = TCCR2B | _BV(CS20);                break;
        case    8 : TCCR2B = TCCR2B | _BV(CS21);                break;
        case   32 : TCCR2B = TCCR2B | _BV(CS21) | _BV(CS20);    break;
        case   64 : TCCR2B = TCCR2B | _BV(CS22);                break;
        case  128 : TCCR2B = TCCR2B | _BV(CS22) | _BV(CS20);    break;
        case  256 : TCCR2B = TCCR2B | _BV(CS22) | _BV(CS21);    break;
        case 1024 : TCCR2B = TCCR2B | _BV(CS22) | _BV(CS21) | _BV(CS20);    break;
        default :  break;
    }
}

void stopTimer2 (void)
{
    TCCR2B = TCCR2B & ~(_BV(CS22) | _BV(CS21) | _BV(CS20));
}

[Stefan F. (Gast)]

Kapitel 2.9.5 Phase Correct PWM sagt

"The extreme values for the OCRnx Register represents special cases when 
generating a PWM waveform output in the phase correct PWM mode. If the 
OCRnx is set equal to BOTTOM the output will be continuously low"

[x] check

"and if set equal to TOP the output will be set to high for non-inverted 
PWM mode."

[ ] nope, funktioniert nicht, wenn OCRnA den TOP Wert bestimmt.

[Veit D. (devil-elec)]

Stefan ⛄ F. schrieb:

>> cWenn B = TOP, liegt dauerhaft Ub an, 100% Duty Cycle.
>
> Genau das ist eben nicht der Fall. Wenn OCRnB=TOP ist bleibt der Ausgang
> permanent auf LOW.

Zeige mir einmal deinen kompletten Code, auf das Wesentliche reduziert, 
aber komplett.

[Kosmo Polit (Gast)]

Veit D. schrieb:
> Zeige mir einmal deinen kompletten Code, auf das Wesentliche reduziert,
> aber komplett.

Und jetzt bitte als Datei-Anhang damit hier nicht so ein
Chaos entsteht.

[Stefan F. (Gast)]

Stefan ⛄ F. schrieb:
> Das war mein Code:

  
     // Phase correct PWM, Prescaler 256, output A+B
     TCCR1A = (1<<WGM11) + (1<<WGM10) + (1<<COM1A1) + (1<<COM1B1);
     TCCR1B = (1<<WGM13) + (1<<CS12);
 
     // Set TOP value
     OCR1A = 0x8000;
 
     // Set pulse width
     OCR1B = 0x7FF0;
 
     // Output compare outputs A+B
     DDRB = (1<<PB1) + (1<<PB2);

Ich habe die Arduino IDE verwendet und genau das in die setup() Funktion 
geschrieben. loop() ist leer. Wenn ich bei OCR1B den gleichen Wert 
verwende wie bei OCR1A, dann bleibt der OC1B (PB2) Ausgang auf LOW.

[S. Landolt (Gast)]

Merkwürdig.
Mangels eines ATmega168PA verwende ich einen ATmega328P, und bei dem 
geht PB2 auf high; in Assembler:

    puti    TCCR1A,(1<<WGM11)+(1<<WGM10)+(1<<COM1B1)
    puti    TCCR1B,(1<<WGM13)+(1<<CS11)
    putiw   OCR1A,$8000
    putiw   OCR1B,$8000
    sbi     DDRB,2

[S. Landolt (Gast)]

Dito bei einem ATmega48PA.

[c-hater (Gast)]

S. Landolt schrieb:

> Mangels eines ATmega168PA verwende ich einen ATmega328P, und bei dem
> geht PB2 auf high; in Assembler:
>

>     puti    TCCR1A,(1<<WGM11)+(1<<WGM10)+(1<<COM1B1)
>     puti    TCCR1B,(1<<WGM13)+(1<<CS11)
>     putiw   OCR1A,$8000
>     putiw   OCR1B,$8000
>     sbi     DDRB,2
>

Also, wenn du schon in Beispielcode eigene Macros verwendest, solltest 
du aber auch die passenden Includes dazu posten, damit es 
nachvollziehbar wird.

Natürlich ist hier klar, was die Intention ist und es ist auch 
kinderleicht, sich selber die passenden Macros zu bauen. Aber vermutlich 
nicht für jeden...

[S. Landolt (Gast)]

> Natürlich ist hier klar, was die Intention ist

Eben!

> Aber vermutlich nicht für jeden...

Aber für die hier Beteiligten ganz sicher.

[Veit D. (devil-elec)]

Hallo,

ich habe das auch nochmal nachvollzogen und die Ausgänge gehen auf High, 
also 100% Duty Cycle.

Ich weiß aber wo das Problem liegt. "Arduino IDE" ist die entscheidende 
Information. In der Arduino IDE muss man die Timerkonfiguration anders 
angehen. Alle Timer sind für PWM (analogWrite) vorbelegt. Wenn man mit 
setup() und loop() programmiert ist das alles im Hintergrund 
vorbereitet. Hier muss man vorher alle Timerregister nullen, also auch 
TIMSK1 usw.. Kannst ja mal vor deiner Änderung alle Timerregister 
auslesen.

Oder man programmiert in der Arduino IDE klassisch mit

int main(void)
{
  while(1)
  {
  }
}

dann wird nichts vorbelegt usw.

[Veit D. (devil-elec)]

c-hater schrieb:
> S. Landolt schrieb:
>
>> Mangels eines ATmega168PA verwende ich einen ATmega328P, und bei dem
>> geht PB2 auf high; in Assembler:
>>

>>     puti    TCCR1A,(1<<WGM11)+(1<<WGM10)+(1<<COM1B1)
>>     puti    TCCR1B,(1<<WGM13)+(1<<CS11)
>>     putiw   OCR1A,$8000
>>     putiw   OCR1B,$8000
>>     sbi     DDRB,2
>>

>
> Also, wenn du schon in Beispielcode eigene Macros verwendest, solltest
> du aber auch die passenden Includes dazu posten, damit es
> nachvollziehbar wird.

Mit Verlaub, die stehen alle im Headerfile des Controllers. Das sollte 
auch jedem Assembler Programmierer bewusst bzw. bekannt sein. Warum soll 
man Standard defines nochmal neu in eigene Makros gießen? Zudem sich 
genau diese Benennung im Manual wieder findet. Einfach gehts nicht 
fremden Code zu lesen.

[S. Landolt (Gast)]

Nein, c-hater meinte die Makros puti und putiw; er wollte aber wohl 
nur mal wieder meckern.

Ihnen, Veit Devil, wünsche ich einen guten Rutsch ins Neue Jahr!

[Veit D. (devil-elec)]

Hallo S.Landolt,

ach'so, alles klar. Dachte das sind Standard Assemblerbefehle. Naja 
egal. Habs verstanden. Ebenfalls guten und gesunden Rutsch ins neue 
Jahr!

[c-hater (Gast)]

S. Landolt schrieb:

> Nein, c-hater meinte die Makros puti und /putiw/

Genau.

> er wollte aber wohl
> nur mal wieder meckern.

Nein. Überleg' dir doch einfach mal, was passiert, wenn jemand ohne 
Assemblerkenntnisse versucht, deinen Beispielcode zu verwenden...

Er wird zu der Erkenntnis kommen, dass Assembler Scheiße und unbenutzbar 
ist, weil nix funktioniert.

Ist es das, was du willst?

[S. Landolt (Gast)]

an c-hater:

> Er wird zu der Erkenntnis kommen, dass Assembler Scheiße
> und unbenutzbar ist, weil nix funktioniert.
Mit einer solchen Einstellung und Befähigung wäre der hypothetisch 
Interessierte für Assembler ohnehin verloren.

> Ist es das, was du willst?
Mir doch egal - ich bin kein Assembler-Priester.

Und nun: Da sprach der Prinz von Pakistan ...

[c-hater (Gast)]

S. Landolt schrieb:

> Mit einer solchen Einstellung und Befähigung wäre der hypothetisch
> Interessierte für Assembler ohnehin verloren.

Verloren, bevor er es überhaupt jemals ernsthaft benutzt hat.

>> Ist es das, was du willst?
> Mir doch egal - ich bin kein Assembler-Priester.

Meinetwegen.

Aber, wenn das Ziel war, kryptische, in ihrer Wirkung im Detail nur noch 
sehr schwer nachvollziehbare Makros zu verwenden, kannst du aber auch 
gleich C-Code schreiben. Denn das genau ist ja, was C tut...

[Wer readln will, muss vorher writeln! (Gast)]

Das wäre eine gute Gelegenheit gewesen, ein Makro auch "Putin" zu 
nennen, wenn es schon "Puti" und "Putiw" gibt.

[Veit D. (devil-elec)]

Hallo,

@ c-hater, dass ist einem Streit doch gar nicht würdig. Das Forum ist 
voller Code Beispiele mit Funktionsaufrufen wo die Funktionsdefinitionen 
fehlen. Dafür aber brauchbare Namen verwendet wurden, sodass jeder 
halbwegs im Saft stehende weiß was gemeint ist und kann es 
nachprogrammieren. Notfalls fragt man nach. Oft ist es auch das Ziel nur 
einen Hinweis zu geben und nicht alles gleich offen für copy paste zu 
legen. Du legst doch auch nicht alles offen was du programmierst. Lasse 
das Jahr bitte ruhig ausklingen. Ich bitte darum. Im nächsten Jahr den 
Puls nicht gleich wieder hochfahren.  :-)

Noch ein Bsp. wie das bei mir in der Arduino IDE aussehen würde. Ich 
verwende hierfür allerdings einen ATmega2560. In diesem Bsp. ist ICR1 
für TOP zuständig. Atomic Block kann man sicherlich weglassen, habe ich 
mir allerdings so angewöhnt, weil sei() im Hintergrund aktiviert wird.

/*
  IDE 1.8.13
  avr-gcc 10.2.0
  Arduino Mega2560
  31.12.2020
  Timer 1 - Phase Correct Mode 10
*/

#include <util/atomic.h>

const byte pinPhaseA = 11;    // Pin OCR1A (am Uno/Nano Pin  9)
const byte pinPhaseB = 12;    // Pin OCR1B (am Uno/Nano Pin 10)
const unsigned int PRESCALER = 8;
const unsigned int TOP = 243;      
const unsigned int DUTYA = 210;   // <= TOP
const unsigned int DUTYB = 60;    // <= TOP

void setup (void)
{
  pinMode(pinPhaseA, OUTPUT);
  pinMode(pinPhaseB, OUTPUT);
  setTimer1(TOP, DUTYA, DUTYB);
  runTimer1(PRESCALER);
}

void loop (void)
{
  
}


// ****** Funktionen ******* //
void setTimer1 (const unsigned int top, const unsigned int dutyA, const unsigned int dutyB)
{
  ATOMIC_BLOCK (ATOMIC_RESTORESTATE)  // Mode 10, Phase Correct
  {
    TCCR1B = 0;             // Resets
    TCCR1A = 0;             //
    TIMSK1 = 0;             //
    TCNT1  = 0;             //
    ICR1 = top;
    OCR1A  = dutyA;
    OCR1B  = dutyB;
    TCCR1A = _BV(COM1B1) | _BV(COM1A1) | _BV(WGM11); 
    TCCR1B = _BV(WGM13);                         
  }                 
}


void runTimer1 (const unsigned int prescaler)
{
  ATOMIC_BLOCK (ATOMIC_RESTORESTATE)
  {
    switch (prescaler) {  // set Prescaler Clock Select Bits
      case    1 : TCCR1B |= _BV(CS10);              break;
      case    8 : TCCR1B |= _BV(CS11);              break;
      case   64 : TCCR1B |= _BV(CS11) | _BV(CS10);  break;
      case  256 : TCCR1B |= _BV(CS12);              break;
      case 1024 : TCCR1B |= _BV(CS12) | _BV(CS10);  break;
      default :   TCCR1B |= _BV(CS11);              break;
    }  
  }
}


void stopTimer1 (void)
{
  ATOMIC_BLOCK (ATOMIC_RESTORESTATE)
  {
    TCCR1B &= ~( _BV(CS12) | _BV(CS11) | _BV(CS10) );
  }
}

[Stefan F. (Gast)]

S. Landolt schrieb:
> Mangels eines ATmega168PA verwende ich einen ATmega328P, und bei dem
> geht PB2 auf high;

Ich hatte auch einen ATmega368P verwendet, auf einem Arduino Nano Klon.

Veit D. schrieb:
> Alle Timer sind für PWM (analogWrite) vorbelegt.
> Hier muss man vorher alle Timerregister nullen

Interessant, das wusste ich nicht. Ich dachte, Arduino reserviert nur 
den Timer 0. Probiere ich gleich mal aus....

Ich das Problem nun nicht mehr reproduzieren. Bei dem angehängten Sketch 
gehen alle 6 Ausgänge auf High. Ich komme mir blöd vor. Trotzdem Danke 
Veit.

[Stefan F. (Gast)]

Hans,

ich habe gerade dein Programm ausprobiert (ohne serielle Ausgabe) und
bei mir gehen alle 4 Timer Ausgänge auf High. Also kann ich auch dein
Problem nicht reproduzieren.

Ich habe einen ATmega328P auf einem Arduino Nano Klon verwendet, sowie
avr-gcc 5.4.0 unter Debian Linux (dieses mal ohne Arduino Software).

Ich kann mir nur vorstellen, dass in deiner config.h irgend etwas
relevantes drin steht. Die hast du uns leider nicht gezeigt.

[Hans Schmidt (Gast)]

Hallo zusammen,

da ist man mal 48h nicht am PC und dann geht es hier so hoch her...
Die config.h ist absolut unspektakulär:

#ifndef CONFIG_H_
#define CONFIG_H_

  #ifndef F_CPU
    #warning "F_CPU war noch nicht definiert, wird auf 14745600 festgesetzt"
    #define F_CPU 14745600UL
  #endif
  // Baudrate der UART definieren
  #define UART_BAUD_RATE 115200UL
  // Debuglevel festlegen (0 = keine Meldungen, 1 = Standard Ausgaben, 2 = erweiterte Ausgaben, 3 = alle Ausgaben)
  #define DEBUG 0

#endif

Wie gesagt: bin mittlerweile auch glücklich. Ich habe nur absolut Null 
Ahnung (mal wieder würde meine Frau und andere sagen) was da passiert 
ist...

[Stefan F. (Gast)]

Hans Schmidt schrieb:
> Wie gesagt: bin mittlerweile auch glücklich

Was heißt das, funktionieren deine Ausgänge jetzt? Wenn ja: Warum? Was 
hast du geändert?

[Hans Schmidt (Gast)]

@Stefan:
Hans Schmidt schrieb:
> @all: nutze nun den fast PWM mode und bin glücklich damit. Funktioniert
> alles wie es soll, auch wenn die Phase nun bei Änderungen nicht sauber
> ist. Aber die wird eh nur alle ~2min in kleinen Schritten geändert.

@all: nach euren Hilfen, Hinweisen und verständlichen Erklärungen bin 
ich nun doch wieder beim phasenkorrekten PWM gelandet. Ich finde es nur 
"fies", das es im Datenblatt nich schöner erklärt ist/wird. Egal, Leben 
ist kein Ponyhof.
Danke euch 2021 kann nur besser werden.

Hans

[Stefan F. (Gast)]

Hans Schmidt schrieb:
> bin ich nun doch wieder beim phasenkorrekten PWM gelandet

Und es klappt auch dieses mal, nehme ich an. Aber warum? Was hast du 
korrigiert?

[S. Landolt (Gast)]

Donnerwetter - da hat jemand aber einen besonders eifrigen Fan, um nicht 
zu sagen Claqueur; jeder noch so banale Beitrag wird beklatscht. 
Wirklich ganz erstaunlich.

[Stefan F. (Gast)]

Es ist ein interessantes Problem, dessen Lösung ich gerne wüsste. 
Insbesondere weil ich es selbst nicht reproduzieren kann.

[S. Landolt (Gast)]

Falls Ihnen doch noch ein Licht aufgeht, trösten Sie sich: ich hatte 
eben auch einen Moment gestutzt, bevor ich Ihren Beitrag begriff.


Da ich aber nun schon mal hier bin: ich wünsche allen hier ein gutes 
Neues Jahr (den meisten von Herzen, einigen mit (virtuellem) 
Handschlag), möge es zumindest nicht schlechter werden als 2020.

[c-hater (Gast)]

S. Landolt schrieb:

> Da ich aber nun schon mal hier bin: ich wünsche allen hier ein gutes
> Neues Jahr (den meisten von Herzen, einigen mit (virtuellem)
> Handschlag), möge es zumindest nicht schlechter werden als 2020.

Naja, das wäre ja nun kaum mehr möglich. Abgesehen vom (idiotischerweise 
leider immer noch real möglichen weltweiten nuklearen Schlagabtausch) 
fällt mir da nichts mehr ein, was es noch mieser machen könnte, als 2020 
war.

Möge also dein Wunsch in Erfüllung gehen, die Chancen dafür sind relativ 
gut...

[Hans Schmidt (Gast)]

Stefan ⛄ F. schrieb:
> Hans Schmidt schrieb:
>> bin ich nun doch wieder beim phasenkorrekten PWM gelandet
>
> Und es klappt auch dieses mal, nehme ich an. Aber warum? Was hast du
> korrigiert?

Eine Bedingung/Prüfung in den Code eingebaut die bei jeder Änderung der 
OCR Register zum Zuge kommt und dadurch sichergestellt ist, dass in 
allen Fällen OCRnA > OCRnB ist.

[Stefan F. (Gast)]

Hans Schmidt schrieb:
> Eine Bedingung/Prüfung in den Code eingebaut die bei jeder Änderung der
> OCR Register zum Zuge kommt und dadurch sichergestellt ist, dass in
> allen Fällen OCRnA > OCRnB ist.

Aber OCRnA muss doch gar nicht > OCRnB sein!

[Hans Schmidt (Gast)]

Kommt drauf an wie du es siehst, bzw. ich habe es ggf. immer noch nicht 
verstanden... Technisch hast du Recht und B dürfte auch größer als A 
sein. Aber was bringt das?
Der Zähler läuft von Null rauf auf TOP und wieder runter auf Null. Und 
TOP wird an der Stelle mit durch A festgelegt. Wenn ich also B größer 
als A setze, wird dieser Wert (vom Zähler) nie erreicht und ist somit 
wirkungslos.

[Stefan F. (Gast)]

Hans Schmidt schrieb:
> Der Zähler läuft von Null rauf auf TOP und wieder runter auf Null. Und
> TOP wird an der Stelle mit durch A festgelegt. Wenn ich also B größer
> als A setze, wird dieser Wert (vom Zähler) nie erreicht und ist somit
> wirkungslos.

Das ist richtig. So weit sollst du auch gar nicht gehen, sondern nur bis 
B gleich TOP. Solange du um 1 darunter bleibst kommst du nie auf die 
maximal mögliche Pulsbreite von 100%.

[Veit D. (devil-elec)]

Hallo,

ebenfalls gesundes Neues in die lustige Runde.

Ansonsten, blickt hier noch einer durch welchen Code der TO aktuell hat? 
Ich nicht. Deswegen nur ganz pauschal formuliert für den TO.
Es kommt darauf an welchen Timermode du verwendest.

Dabei hast du im Phase Correct Modus nur 5 Möglichkeiten - mit Timer 1 
erklärt. TOP ist fest auf 0xFF oder 0x01FF oder 0x03FF festgenagelt.
Damit kannste du die Pins OCnA und OCnB für PWM verwenden. Bedingung, 
die PWM Werte dürfen TOP nicht überschreiten.

Oder du nimmst den Mode mit ICRn als TOP.
Dann haste auch beide Pins OCnA und OCnB frei.
Bedingung, die PWM Werte dürfen TOP (ICR1) nicht überschreiten.

Oder du nimmst den Mode mit OCRnA als TOP.
Dann haste den Pins OCnB für PWM frei.
Bedingung, der PWM Wert darf TOP (OCRnA) nicht überschreiten.

Beim Update von OCRnA und OCRnB sind diese gepuffert. Das heißt die 
Änderung erfolgt immer zum richtigen Zeitpunkt. ICRn ist nicht 
gepuffert. Falls du Letzteres zur Laufzeit änderst kann es kurz zucken. 
Falls du die Frequenz ändern möchtest.

Und lass dich von der auf/ab Zählweise in diesem Mode nicht 
durcheinanderbringen. Für deine Einstellerei ist das unbedeutend. Das 
dient "nur" der richtigen Phasenlage. Sieht man schön wenn man beide 
Ausgänge am Oszi betrachtet.

Alles weitere nur mit entsprechenden Code.

[Veit D. (devil-elec)]

und wieder schrieb im Beitrag #6536073:
> @Veit
>
> DAS ist mal eine vernünftige Erklärung. DU solltest die Datenblätter
> schreiben!

Ich nehme es dankend zur Kenntnis.