ATMega32: PWM _und_ Timer Overflow, Expertenfrage

[Sascha N. (sadaniro)]

Hi,

ich habe ein merkwürdiges Problem mit dem ATMega32@16Mhz. Dieser soll 
zur Ansteuerung von 4 Servomotoren verwendet werden. Die Generierung der 
PWM-Signale klappt soweit sehr gut. Ich verwende alle vier möglichen 
PWM-Kanäle (Timer0, Timer1 (OC1A, OC1B) und Timer2).
Das Modul zur PWM-Erzeugung enthält eine Initialisierungsfunktion, die 
die Timer intialisiert und vier weitere mit denen die Pulsbreite zur 
Laufzeit festgelegt wird:

...

void initPWM()
{
  // Note: _BV(x) => 1 << x
  // (converts a bit number into a byte value)
  
  //-- Timer 0 (for pwm_8_1 alias OC0 alias PB3, Low Resolution)
  // Mode: Fast PWM
  // => WGM00 = 1, WGM01 = 1
  // Prescaler = 1024 => f= 61,03 Hz
  // => CS02 and !CS01 and CS00
  //Clear OC0 on compare match, set OC0 at BOTTOM,
  //(non-inverting mode)
  // => !COM00 and COM01
  TCCR0 = _BV(WGM00) | _BV(WGM01) | _BV(COM01) | _BV(CS02) | _BV(CS00);
  // Set PB3 in Data Direction Register as output pin
  DDRB |= _BV(PB3);

  //-- Timer 1 (for pwm_16_1/pwm_16_2 alias PD4/PD5 alias OC1A/OCAB, High Resolution)
  // Mode: Phase and Frequency Correct PWM
  // WGM13 = 1 , WGM12 = WGM11 = WGM10 = 0
  // Set OC1A/OC1B on compare match when upcounting.
  // Clear OC1A/OC1B on compare match when downcounting.
  // COM1A1 = COM1B1 = 1 , COM1A0 = COM1B0 = 1 
  TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(COM1A0) | _BV(COM1B0);
  // [!CS12 && CS11 && !CS13) => Prescaler = 8
  TCCR1B = _BV(WGM13) | _BV(CS11);
  // Set PD4/Pd5 in the Data Direction Register as output pin
  DDRD |= _BV(PD4) | _BV(PD5);
  // Set the upper limit of Timer 1 (=> 50 Hz pwm freq.)
  ICR1 = TIMER1_TOP;  
  
  //-- Timer 2 (for pwm_8_2 alias OC0 alias PB3, Low Resolution)
  // Mode: Fast PWM
  // => WGM21=1 and WGM20=1
  // Clear OC2 on compare match, set OC2 at BOTTOM,
  // (non-inverting mode)
  // COM21 = 1 COM20=0
  // Prescaler = 1024 => f= 61,03 Hz
  // => CS22 and CS21 and CS20
  TCCR2 = _BV(WGM21) | _BV(WGM20) | _BV(COM21) | _BV(CS22) | _BV(CS21) | _BV(CS20);
  // Set PD7 in the Data Direction Register as output pin 
  DDRD |= _BV(PD7);  
}

// Sets a pulswidth between 0 and 20000 µs (0% and 100% of 20 ms) on PWM Channel 1 (OC1A/PD5)
void setPwm16_1(uint16 pulsWidth)
{
  if(pulsWidth >= 0 && pulsWidth <= TIMER1_TOP)
  {    
    // as closer as we reach the TOP Value as smaller the pulse becomes
    // since we use the inverted Mode
    // Output Compare Register 1A = TOP Value - pulsWidth
    OCR1A = TIMER1_TOP - pulsWidth;
  }
}

// Sets a pulswidth between 0 and 20000 µs (0% and 100% of 20 ms) on PWM Channel 2 (OC1B/PD4)
void setPwm16_2(uint16 pulsWidth)
{
  if(pulsWidth >= 0 && pulsWidth <= TIMER1_TOP)
  {
    // as closer as we reach the TOP Value as smaller becomes the pulse (inverted mode)
    // Output Compare Register 1B = TOP Value - pulsWidth
    OCR1B  = TIMER1_TOP - pulsWidth;
  }  
}

// Sets a pulswidth between 0 and 256 (0% and 100% of 1/(61,03 Hz) = 15,87 ms) on PWM Channel 3 (OC0/PB3)
void setPwm8_1(uint8 pulsWidth)
{
  OCR0 = pulsWidth;  
}

// Sets a pulswidth between 0 and 256 (0% and 100% of 1/(61,03 Hz) = 15,87 ms ) on PWM Channel 4 (OC2/PD7)
void setPwm8_2(uint8 pulsWidth)
{
  OCR2 = pulsWidth;  
}

Wie erwähnt klappt das im Prinzip ganz gut. Jetzt geht es daraum die 
Servoparameter über zwei Taster zu verändern, da ich die viele 
Pulsweiten für die Anwendung durch experimentieren ermitteln muss. Dazu 
nutze ich den Timer2 Overflow Interrupt um zyklisch die Tasterwerte 
abzufragen. Soweit ich das Datenblatt verstanden habe ist es möglich 
sowohl den Timer2 zur PWM-Erzeugung (Fast PWM Mode) als auch den Timer 2 
Overflow Interrupt zu nutzen, oder?

Bevor ich die Interrupt-Routine vorstelle will ich nochmal auf ein für 
diese Experimente entscheidendes Modul eingehen, dass die Datenstruktur 
definiert mit dem die vier PWM-Parameter verändert werden können:

// Represents a pwm parameter
struct pwmParameter
{
  // name of the pwm parameter
  char name[10];
  // value of the pwm parameter
  uint16 value;
  // max value of the pwm parameter value (255  for 8-bit pwm, 20000 for 16-bit pwm)
  uint16 maxValue;
  // pointer to the next parameter (lsingle-linked-list)
  struct pwmParameter* next;
  // Pointer to a function which increases the pwm parameter value by one ( + 1)
  void (*increase)(struct pwmParameter*);
  // // Pointer to a function which decreases the pwm parameter value by one  (- 1)
  void (*decrease)(struct pwmParameter*);
  // Updates the pwm parameter. Not needed to be called after increase/decrease! Its called within increase/decrease functions
  void (*update)(struct pwmParameter*);
};

typedef struct pwmParameter* psPwmParameter;

// Initializes the pwm parameters (Should be called before getFirstParameter() is called!!!)
void initPwmParameters(void);
// Gets the first parameter of the of the linked-list of parameters
psPwmParameter getFirstParameter(void);

void increase(psPwmParameter);
void decrease(psPwmParameter);

void updatePwm16_1(psPwmParameter);
void updatePwm16_2(psPwmParameter);
void updatePwm8_1(psPwmParameter);
void updatePwm8_2(psPwmParameter);

struct pwmParameter pwm16_1 = {"pwm16_1", (uint16) 1500,(uint16) 20000u, 0, &increase, &decrease, &updatePwm16_1};
struct pwmParameter pwm16_2 = {"pwm16_2", (uint16) 1500, (uint16)20000u, 0, &increase, &decrease, &updatePwm16_2 };
struct pwmParameter pwm8_1 = {"pwm8_1", (uint16)20, (uint16)255, 0 , &increase, &decrease, &updatePwm8_1};
struct pwmParameter pwm8_2 = {"pwm8_2", (uint16)20, (uint16)255, 0, &increase, &decrease, &updatePwm8_2};

// initialize function (bind together the linked-list
void initPwmParameters()
{
  pwm16_1.next = &pwm16_2;
  pwm16_2.next = &pwm8_1;
  pwm8_1.next = &pwm8_2;
  pwm8_2.next = &pwm16_1; 
}

// Gets the first parameter of a single linked list of pwm parameters
psPwmParameter getFirstParameter(void)
{
  return &pwm16_1;
}

void increase(psPwmParameter parameter)
{
  if( parameter->value < parameter->maxValue )
    parameter->value = (parameter->value)++;

  parameter->update(parameter);
}

void decrease(psPwmParameter parameter)
{
  if( parameter->value > 0 )
    parameter->value = (parameter->value)--;
  
  parameter->update(parameter);
}

void updatePwm16_1(psPwmParameter pwm16_1)
{
  setPwm16_1(pwm16_1->value);
}

void updatePwm16_2(psPwmParameter pwm16_2)
{
  setPwm16_2((pwm16_2->value));
}

void updatePwm8_1(psPwmParameter pwm8_1)
{
  setPwm8_1((uint8) (pwm8_1->value));
}

void updatePwm8_2(psPwmParameter pwm8_2)
{
  setPwm8_2((uint8) (pwm8_2->value));
}

Das Modul in dem die Interrupt-Routine definiert wird und die mit dem 
ersten pwm Parameter (element der verketteten Liste) initialisiert wird 
sieht wie folgt aus:

volatile uint8 SW_PrescalerCounter;
// Value of the software prescaler. The value affects the effective interrupt frequency. 
// Higher values lead to slower up-/downcounting of the current parameter.
const uint8 SW_PRESCALER = 2;
// counter used to measure how long _both_ buttons are pressed. 
volatile uint8 changeModeCounter;
// The Threshold value used to changed the mode.
const uint8 CHANGEMODETHRESHOLD = 30;

// Displays the current parameter
void displayCurrentParameter(void);

// pointer to the (current) struct pwmParameter. Will be initialized when  InitPwmParameterConfigurationControl(...) is called.
psPwmParameter current = 0;

void InitPwmParameterConfigurationControl(psPwmParameter firstPwmParameter)
{
  current = firstPwmParameter;
}

// ISR-Routine is called each time the timer 2 overflows (61,04 times per second)
// An additional software prescaler reduces the frequency to 61,04 / 2 = 30,52 Hz
ISR(TIMER2_OVF_vect)
{  
  // Additional SW Prescaler
  if((SW_PrescalerCounter++ % SW_PRESCALER) != 0)
  {
    return;
  }
  // button s1 pressed?
  if(!(PIND & _BV(PD3)))
  {
    current->decrease(current);
  }
  // button s2 pressed?
  if(!(PIND & _BV(PD1)))
  {
    current->increase(current);
  }
  // both pressed (means that the user wants to change the pwm parameter to configure)?
  if(!(PIND & _BV(PD3)) & !(PIND & _BV(PD1)))
  {
    changeModeCounter++;  
    
    // pressed _both_ buttons long enough?
    if(changeModeCounter == CHANGEMODETHRESHOLD)
    {      
        changeModeCounter = 0;
        // change the current pwm param to configure
        current = current->next;
        // sleep 1 ms.
        sleep_ms(1);
      //  clearDisplay();
    }
  }
  // print the current parameter on the display
  displayCurrentParameter();
}

void displayCurrentParameter()
{
  writeToDisplay_s(0,1,current->name);  
  writeToDisplay_uint16(8,1,current->value);
}

Jedenfalls funktioniert das Verändern des aktuelle PWM-Parameter 
prinzipiell gut über die beiden Taster und es klappt auch der Wechsel 
des aktuellen parameters zum nächsten. Die vier PWN-Signale werden auch 
generiert ABER nur wenn ich den Timer 2 Overflow Interrupt NICHT 
aktiviert habe, d.h. wenn ich am Anfang des Programs einmal alle vier 
set_pwm_xx-Funktionen mit hardcodierten Werten aufrufe und dann nichts 
mehr (while(1);).  Wenn ich die Werte mit dem obigen Interrupt Routine 
ändere funktioniert zwar das verändern des aktuellen parameters (sehe 
ich an ausgaben am Display) aber es werden KEINE PWM-Signale (weder 
Timer2 noch Timer1 und Timer0) mehr erzeugt.

Liegt es vielleicht am sleep_ms(1) in der ISR?

Meint ihr die Interrupt-Routine ist zu lang??  Da ich mit einem 
Prescaler von 1024 arbeite müssten doch genügend Takte zur Verfügung 
stehen?

Es muss sich um einen systematischen Fehler handeln, da beide Teile 
einzeln (PWM-signalerzeugung selbst als auch der Teil zur Veränderung 
der Parameter zur laufzeit) funktionieren.

Bin mal gespannt was ihr dazu meint, Laut den Antworten im Forum die ich 
bisher gelesen habe müsste es eigentlich funktionieren. Vielen Dank 
schonmal!

[Sascha N. (Gast)]

Hat keiner ne Idee?

[Sascha N. (Gast)]

Hmm.. kann mir wirklich keiner helfen?

[Oliver (Gast)]

Sascha N. schrieb:
> Hmm.. kann mir wirklich keiner helfen?

Code komplett als Anhang posten
Frage bzw. Problem kurz und prägnant formulieren.

Dann klappst auch mit der Hilfe. Durch den Wust in deiner Frage arbeitet 
sich freiwillig keiner durch.

Oliver

[... (Gast)]

Sascha N. schrieb:
> Liegt es vielleicht am sleep_ms(1) in der ISR?
>
> Meint ihr die Interrupt-Routine ist zu lang??  Da ich mit einem
> Prescaler von 1024 arbeite müssten doch genügend Takte zur Verfügung
> stehen?

Möglich, das sleep in der ISR ist jedenfalls keine gute Idee. Das 
"clearDisplay();" (OK auskommentiert) und das 
"displayCurrentParameter();" sind ebenfalls daneben.
Setz einfach ein Flag und mach die Ausgaben in main.

In Deinem Fall scheint das zwar nicht allzu kritisch zu sein (zumindest 
wenn in main eine leere Schleife steht), Du verlierst eventuell ein paar 
Interrupts und Deine Tasten reagieren etwas träge, schön ist das aber 
trotzdem nicht.

Ansonsten fehlt ein großer Teil Deines Programms ==> Fehler in Zeile 42
Eventuell geht Dir einfach der Ram aus.

PS:
Das hier ist auch ziemlich daneben:

parameter->value = (parameter->value)++;

Eine Variable sich selbst zuzuweisen und sie anschließend zu erhöhen 
macht irgendwie keinen Sinn.
Also entweder so:

parameter->value++;

Oder so:

parameter->value = parameter->value + 1;

Beim decrease das Gleiche dann analog.