STM32F4 Timer PWM + Interrupt

[Florian K. (f-kae)]

Hallo zusammen,
ich möchte gerne auf meinem STM32F407VGT am Pin PC7 einen akustischen 
Signalgeber per PWM ansteuern.
Grundsätzlich funktioniert das auch schon allerdings möchte ich per 
Interrupt nach mehrmaligem ausführen des Signals, den Timer wieder 
austellen.

Hier erst einmal der Code:

volatile uint8_t beeps = 0;

void BuzzerInit(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  TIM_TimeBaseInitTypeDef TIM_TimeBase_InitStructure;
  TIM_OCInitTypeDef TIM_OC_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;

  GPIO_InitStructure.GPIO_Pin = buzzerPin;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(buzzerPort, &GPIO_InitStructure);
  
  GPIO_PinAFConfig(buzzerPort, GPIO_PinSource7, GPIO_AF_TIM8);
  
  TIM_TimeBase_InitStructure.TIM_ClockDivision = 0;
  TIM_TimeBase_InitStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBase_InitStructure.TIM_Prescaler = 41999; // 168.000.000 / 42.000 = 4000 (1s = 4000 Ticks)
  TIM_TimeBase_InitStructure.TIM_Period = 1599; // 1600 / 4000 = 0,4 (Überlauf nach 0,4 Sekunden)
  TIM_TimeBaseInit(TIM8, &TIM_TimeBase_InitStructure);
  
  
  TIM_OC_InitStructure.TIM_OCMode = TIM_OCMode_PWM2;
  TIM_OC_InitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;
  TIM_OC_InitStructure.TIM_OCNIdleState = TIM_OCNIdleState_Set;
  TIM_OC_InitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OC_InitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;
  TIM_OC_InitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OC_InitStructure.TIM_OutputNState = TIM_OutputNState_Disable;
  TIM_OC_InitStructure.TIM_Pulse = 1199;  // Buzzer 0,1s an 0,3s aus
  TIM_OC2Init(TIM8, &TIM_OC_InitStructure); //Channel 2
  
  TIM_OC2PreloadConfig(TIM8, TIM_OCPreload_Enable);
  TIM_ARRPreloadConfig(TIM8, ENABLE);
  
  /* Main Output Enable */
  TIM_CtrlPWMOutputs(TIM8, ENABLE);

  /* Enable Timer-Update */
  TIM_ITConfig(TIM8, TIM_IT_Update, ENABLE); //DIESE ZEILE ERZEUGT MEIN PROBLEM!!!!!


  /* TIM8 Update Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = TIM8_UP_TIM13_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0E;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0E;
  NVIC_Init(&NVIC_InitStructure);
  
}

void BuzzerBeep(uint8_t beeptimes)
{
  beeps = beeptimes;
    
  /* TIM8 counter enable */
  TIM_Cmd(TIM8, ENABLE);
}

void TIM8_UP_TIM13_Handler(void)
{
  //TIM_ClearFlag(TIM8, TIM_FLAG_Update);
  //TIM_ClearITPendingBit(TIM8, TIM_IT_Update);
  LedYellowOn();
  
  if (beeps > 1)
  {
     beeps--;
  }
  else
  {
     beeps = 0;
     /* TIM8 counter disable */
     TIM_Cmd(TIM8, DISABLE);
  }
}

Sobald ich die Zeile zur Aktivierung des Interrupt-Updates einfüge, 
bleibt das Programm hängen... Ich verstehe echt nicht was hier das 
Problem ist.

Den Handler habe ich noch zu keinem Zeitpunkt erreicht!!!


Timer8 und GPIOC werden schon vorher mit Clock versorgt.

[Florian K. (f-kae)]

Kann mir hier niemand weiter helfen?

[asdfg (Gast)]

Deinen TIM8_UP_TIM13_Handler in der Vektortabelle
an der richtigen Stelle eingetragen?

[Christian (Gast)]

Hast du mal einen anderen IRQ Channel ausprobiert? Zb.

NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;

und dann

void TIM8_IRQHandler(void){
  TIM_ClearITPendingBit(TIM8, TIM_IT_Update);
  ...
}

[Christian (Gast)]

Achso ich sehe jetzt erst dass dein Problem wo anders auftaucht. Vergiss 
es ;)

[Christian (Gast)]

Warum ist das hier auskommentier?

[c]
  //TIM_ClearFlag(TIM8, TIM_FLAG_Update);
  //TIM_ClearITPendingBit(TIM8, TIM_IT_Update);
[\c]

So wie ich es in erinnerung habe, bleibt er in dem Interrupt hängen, 
wenn man diese Befehle nicht ausführt. Vielleicht springst du ja 
einmalig in den Interrupt-Handler und bleibst da dann hängen?!

[dummy (Gast)]

>Vielleicht springst du ja
>einmalig in den Interrupt-Handler und bleibst da dann hängen?!

Nicht einmalig, sondern immer wieder bis das Flag gelöscht wird.

[Christian (Gast)]

dummy schrieb:
>>Vielleicht springst du ja
>>einmalig in den Interrupt-Handler und bleibst da dann hängen?!
>
> Nicht einmalig, sondern immer wieder bis das Flag gelöscht wird.

Achso nagut, dann wars so rum ;-)

[Mike R. (thesealion)]

Florian K. schrieb:
>

> NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0E;
> NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0E;
>

Das funktioniert so auch nicht. Das NVIC Register hat insgesamt nur 4 
Bit für die Prioritäten.

Du kannst mit

void NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)

 einstellen, wie sich die 4 Bit aufteilen. Aber 2 mal 15 Werte hast du 
nicht zur Verfügung.

Allerdings sollte das nicht zu einem kompletten "Aufhängen" führen.

Mike

[Florian K. (f-kae)]

Hi,
nun kamen ja doch noch ein paar Antworten, schön :)


asdfg schrieb:
> Deinen TIM8_UP_TIM13_Handler in der Vektortabelle
> an der richtigen Stelle eingetragen?

Ich habe den Handler in der Datei "stm32f4xx_it.c" platziert und in der 
entsprechenenden Header-Datei bekannt gemacht.

Christian schrieb:
> Warum ist das hier auskommentier?
>
>

>   //TIM_ClearFlag(TIM8, TIM_FLAG_Update);
>   //TIM_ClearITPendingBit(TIM8, TIM_IT_Update);
>

>
> So wie ich es in erinnerung habe, bleibt er in dem Interrupt hängen,
> wenn man diese Befehle nicht ausführt. Vielleicht springst du ja
> einmalig in den Interrupt-Handler und bleibst da dann hängen?!

Ich habe Testweise, Teile des Codes auskommentiert. Allerdings sollte, 
wenn der Handler überhaupt erreicht wird die gelbe LED angehen 
(LedYellowOn()) aber das tut sie nicht, daher gehe ich davon aus, dass 
der Handler garnicht erreicht wird und der Fehler durch die konkrete 
Zeile oder in Kombination mit einer anderen entsteht.

Mike S. schrieb:
>> NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0E;
>> NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0E;
>>
> Das funktioniert so auch nicht. Das NVIC Register hat insgesamt nur 4
> Bit für die Prioritäten.
>
> Du kannst mitvoid NVIC_PriorityGroupConfig(uint32_t NVIC_PriorityGroup)
>  einstellen, wie sich die 4 Bit aufteilen. Aber 2 mal 15 Werte hast du
> nicht zur Verfügung.

In der SP-Library steht dazu:

uint8_t NVIC_InitTypeDef::NVIC_IRQChannelPreemptionPriority 

Specifies the pre-emption priority for the IRQ channel specified in NVIC_IRQChannel. This parameter can be a value between 0 and 15 as described in the table MISC_NVIC_Priority_Table A lower priority value indicates a higher priority

und

uint8_t NVIC_InitTypeDef::NVIC_IRQChannelSubPriority 

Specifies the subpriority level for the IRQ channel specified in NVIC_IRQChannel. This parameter can be a value between 0 and 15 as described in the table MISC_NVIC_Priority_Table A lower priority value indicates a higher priority

Ich bin immer nun immer noch nicht weiter mit dem Problem...

[Uwe B. (derexponent)]

bist du dir mit dem Namen vom ISR-Handler sicher !?!

normalerweise lautet der :

"TIM8_UP_TIM13_IRQHandler"

[Florian K. (f-kae)]

Uwe B. schrieb:
> bist du dir mit dem Namen vom ISR-Handler sicher !?!
>
> normalerweise lautet der :
>
> "TIM8_UP_TIM13_IRQHandler"

Ohhhh, du hast recht!

Vielen, vielen Dank schon einmal!
Ich werde es heute Abend testen und dann berichten :)

[Florian K. (f-kae)]

OK,
es lag an der falschen Bezeichnung des Handlers!

Vielen Dank an Uwe B.! :D

Gruß,
Florian

[Christian (Gast)]

Hat der Compiler nicht gemeckert, dass er den IRQ-Handler nicht kennt??

[Florian K. (f-kae)]

Christian schrieb:
> Hat der Compiler nicht gemeckert, dass er den IRQ-Handler nicht kennt??

Naja ich hab halt meine eigene Funktion definiert, ist ja nichts 
verkehrt dran, nur der Interrupt konnte halt nicht dort reinspringen.

Die "Freischaltung" des Handlers war ja richtig:
  NVIC_InitStructure.NVIC_IRQChannel = TIM8_UP_TIM13_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0E;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0E;
  NVIC_Init(&NVIC_InitStructure);

[Christian (Gast)]

Ah okay, verstehe ;)