STM32F446 - Timer kommt zu oft?

[Wühlhase (Gast)]

Nachdem ich hier unlängst so viel nützliche Hilfe erhalten habe, möchte 
ich euch gerne noch ein Problem vorlegen-ich hoffe, es gibt eine 
einfache Erklärung.

Ich hab einen Timer (Tim6) auf einem STM32F446 am Laufen, der regelmäßig 
einen Interrupt reinwirft. Die Taktkonfiguration hab ich nicht 
angefaßt-kommt noch. Der Timer soll regelmäßig zur Tasterauswertung 
genutzt werden.

Jetzt stehe ich vor einem Rätsel: Der Timer kommt praktisch sofort und 
dauernd, obwohl er mit den momentanen Einstellungen völlig unbrauchbar 
lahm sein müßte.

void initTimer(){
  //Initialize timer6 for check user buttons per periodic interrupt
  RCC -> APB1ENR |= RCC_APB1ENR_TIM6EN;
  TIM6 -> DIER |= TIM_DIER_UIE;
  TIM6 -> PSC = 65000;
  TIM6 -> ARR = 1;
}

Selbst wenn der Timer mit 45MHz (maximaler Takt auf dem jeweiligen 
Peripherie-Bus) angehauen wird, dürfte der Interrupt nur alle 20s oder 
so kommen.

Dafür hab ich noch einen interessanten Effekt in der main:

void main(){
  initClock();
  initNVIC();
  initPins();
  initTimer();

  TIM6 -> CR1 |= TIM_CR1_CEN;
  int i;
  //Test Pin Init
  for(;;){
    //empty loop
    i++;
  }
}

Eigentlich möchte ich gerne in der Dauerschleife bleiben. Stattdessen 
rauscht er da ein einziges Mal durch-und das wars dann. Ich hab an der 
Stelle i++ einen Haltepunkt gesetzt, der zuverlässig nur ein Einziges 
Mal angesprungen wird. Die Zeile i++ war auch nur um zu vermeiden daß 
der Compiler das möglicherweise wegoptimiert...

Das ganze Projekt ist im Anhang. Ich hoffe jemand kennt das Problem...
Vielen Dank schonmal. :)

[Nico W. (nico_w)]

Wühlhase schrieb:
> dürfte der Interrupt nur alle 20s oder so kommen.

Nicht ganz. Mindestens das ARR funkt dir aktuell dazwischen. Ich denke 
eher das der Interrupt mit 690Hz freuert.


Bin gerade Unterwegs am Handy und kann dein angehängtes Paket nicht 
ansehen. Den Handler hast du implementiert mit Flag löschen? Sonst 
springt er in den Default Handler und das wars dann.


Und mach ggf. dein i Mal volatile.

[Christopher J. (christopher_j23)]

Wühlhase schrieb:
> void initTimer(){
>   //Initialize timer6 for check user buttons per periodic interrupt
>   RCC -> APB1ENR |= RCC_APB1ENR_TIM6EN;
>   TIM6 -> DIER |= TIM_DIER_UIE;
>   TIM6 -> PSC = 65000;
>   TIM6 -> ARR = 1;
> }
>
> Selbst wenn der Timer mit 45MHz (maximaler Takt auf dem jeweiligen
> Peripherie-Bus) angehauen wird, dürfte der Interrupt nur alle 20s oder
> so kommen.

Wenn der Prescaler deines Timers mit 45MHz befeuert wird, dann taktet 
dein Timer mit 45MHz/(PSC+1) ~= 45e6/65e3 Hz ~= 692Hz, so wie Nico 
gesagt hatte. Der Timer zählt dann von 0 bis ARR, löst dann einen 
Interrupt aus und fängt dann wieder bei 0 an. Der Interrupt feuert 
demnach mit ca. 350Hz, also etwa alle 3ms.

Bei PSC = 44999 würde dein Timer mit 1kHz takten und ARR = 499 würde 
dann zu einer Interruptfrequenz von 2 Hz führen. Beim Prescaler muss man 
aufpassen, dass der Teiler, der tatsächlich herauskommt PSC+1 ist, weil 
PSC=0 natürlich nicht durch Null teilt ;) Bei ARR ist das Ähnlich, weil 
der bei Null anfängt zu zählen. Bei großen Zahlen spielt das +1 nicht so 
die große Rolle aber wenn man einen Vorteiler von 2 will und PSC=2 setzt 
liegt man schon ordentlich daneben.

[Niklas G. (erlkoenig)]

Du musst den Timer im Interrupt zurücksetzen, sonst wird der Interrupt 
sofort neu aufgerufen. Das muss direkt am Anfang der ISR passieren, 
sonst wirkt es nicht. Bei der Gelegenheit solltest du auch das UIF 
abfragen, um andere Events oder fälschlich aufgerufene ISR's 
auszufiltern:

void TIM6_DAC_IRQHandler(void){ // "void" vergessen!
  if ((TIM6->SR & TIM_SR_UIF) == 0) return;
  TIM6->SR = ~TIM_SR_UIF;
  // ...
}

Wenn du nicht möchtest dass der Timer-Interrupt sofort nach dem 
Einschalten (setzen von CEN) kommt, sondern erst nach einmaligem 
Ablaufen, musst du das Einschalten derart ändern:

TIM6->CR1 = TIM_CR1_CEN | TIM_CR1_URS;
__DSB ();
TIM6->EGR = TIM_EGR_UG;
__DSB ();
TIM6->CR1 = TIM_CR1_CEN;

Btw, "button1isHolded" ist Quatsch; es heißt "held" und nicht 
"holded"...

[Wühlhase (Gast)]

Es lag tatsächlich am Rücksetzen des Interrupt-Flags. Hach, so langsam 
hab ich das Gefühl ich bekomme den STM32 gezähmt...das Teil macht mir 
immer Spaß. :)

Vielen Dank.

Noch eine Frage...um ein Bit in einem Register zu manipulieren gibt es 
ja gewisse Defines in der Bibliothek...z.B. 'GPIO_BSRR_BR0'

Daneben gibt es auch (fast?) immer sowas wie 'GPIO_BSRR_BR0_Msk' oder 
'GPIO_BSRR_BR0_Pos'.

Was hat es mit denen auf sich? Ich hab mir davon mal die Deklaration im 
stm32f446xx.h-file angesehen, aber ich kann damit nicht viel anfangen...

[Niklas G. (erlkoenig)]

Wühlhase schrieb:
> Daneben gibt es auch (fast?) immer sowas wie 'GPIO_BSRR_BR0_Msk' oder
> 'GPIO_BSRR_BR0_Pos'.

- "GPIO_BSRR_BR0_Msk" ist identisch zu "GPIO_BSRR_BR0" (ich glaube 
letzteres ist nur zur Abwärtskompatibilität vorhanden).
- "GPIO_BSRR_BR0_Pos" ist der Index des niedrigsten Bits des jeweiligen 
Bitfelds im Register. Das kann man nutzen um einen Wert an die richtige 
Stelle zu shiften.

Mit diesen Definitionen kann man variable Werte in Register schreiben. 
BSRR ist aber ein schlechtes Beispiel, daher hier mit TIM_CR1_CKD:

void setClockDivision (uint8_t ckd) {
  TIM2->CR1 = (TIM2->CR1 & ~TIM_CR1_CKD_Msk) | (((uint16_t) ckd) << TIM_CR1_CKD_Pos);
}

Oder auch Werte abfragen:

uint8_t getClockDivision (void) {
  return (TIM2->CR1 & TIM_CR1_CKD_Msk) >> TIM_CR1_CKD_Pos;
}

Etwas kürzer gehts mit den vordefinierten Makros:

void setClockDivision (uint8_t ckd) {
  MODIFY_REG(TIM2->CR1, TIM_CR1_CKD_Msk, ((uint16_t) ckd) << TIM_CR1_CKD_Pos);
}
uint8_t getClockDivision (void) {
  return READ_BIT(TIM2->CR1, TIM_CR1_CKD_Msk) >> TIM_CR1_CKD_Pos;
}