STM32: Timer funktioniert nicht

[Pete K. (pete77)]

Hallo,

ich möchte gerne Timer-gesteuert eine LED blinken lassen (STM32F107RC 
mit CoIDE und winarm 4.6.

Aber irgendwie passt meine Timer-Routine nicht, der Interrupt-Handler 
wird nicht aufgerufen.
Stimmt die Initialisierung des Timers oder fehlt das noch etwas?

(Muss ja falsch sein, sonst würde es funktionieren :-)

#include "stm32f10x.h"
#include "stm32f10x_conf.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
#include "stm32f10x_usart.h"
#include "stm32f10x_tim.h"
//#include "stm32f10x_spi.h"
//#include "stm32f10x_i2c.h"
//#include <stdio.h>

/***************************************************************************//**
 * Declare function prototypes
 ******************************************************************************/
void SetupClock(void);
void SetupUSART(void);
void SetupTimer(void);
void USART1_SendString(char* data);



// *************** main *************

int main(void)
{
  volatile int i;


  SetupClock();
  SetupUSART();
  SetupTimer();

  GPIO_InitTypeDef GPIO_InitStructure;
  /* Initialize LED which connected to PB11, Enable the Clock*/
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  /* Configure the GPIO_LED pin */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructure);

  while (1) {

    //GPIOB->ODR ^= GPIO_Pin_10;
    /* delay */
    //for(i=0;i<0x300000;i++);

    //USART1_SendString("in while\n\r");


  }
}

void USART1_SendString(char* data)
{
  while (*data)
  {
    USART_SendData(USART1, (uint16_t) *data);
    while(USART_GetFlagStatus(USART1, USART_FLAG_TC)==RESET);
    data++;
  }
}

void SetupTimer(void)
{

  TIM_TimeBaseInitTypeDef  TIM_TimeBase_InitStructure;

  /* Enable TIM2 clock */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);  // sollten 72Mhz sein

  TIM_TimeBase_InitStructure.TIM_Prescaler = 7200; // (72Mhz/7200 = 10khz)
  TIM_TimeBase_InitStructure.TIM_ClockDivision = 10;  // nach Prescaler=1kHz
  TIM_TimeBase_InitStructure.TIM_CounterMode = TIM_CounterMode_Down;
  TIM_TimeBase_InitStructure.TIM_Period = 1000; // Eine Sekunde

  TIM_TimeBaseInit(TIM2, &TIM_TimeBase_InitStructure);

  TIM_ClearFlag(TIM2, TIM_FLAG_Update);



  TIM_Cmd(TIM2, ENABLE);
  USART1_SendString("in SetupTimer\n\r");
}

//timer 2 interrupt
void TIM2_IRQHandler(void)
{
  USART1_SendString("in TIM1\n\r");
  //if interrupt happens the do this
  if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
  {
    //clear interrupt and start counting again to get precise freq
    TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

    //toggle led
    GPIOB->ODR ^= GPIO_Pin_10;
    USART1_SendString("in TIM2\n\r");
  }
}

/***************************************************************************//**
 * @brief Setup clocks
 ******************************************************************************/
void SetupClock()
{
      RCC_DeInit ();                    /* RCC system reset(for debug purpose)*/
      RCC_HSEConfig (RCC_HSE_ON);       /* Enable HSE (external Quarz)        */

      while (RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET); // Wait till HSE is ready

      /* Enable USART1 and GPIOA clock                                        */
      RCC_APB2PeriphClockCmd (RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);

      /* Configure PLLs *********/
      /* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
      RCC_PREDIV2Config(RCC_PREDIV2_Div5);
      RCC_PLL2Config(RCC_PLL2Mul_8);
      RCC_PLL2Cmd(ENABLE);  // Enable PLL2
      while (RCC_GetFlagStatus(RCC_FLAG_PLL2RDY) == RESET); // Wait till PLL2 is ready

      /* PLL1 configuration: PLLCLK = (PLL2 / 5) * 9 = 72 MHz */
      RCC_PREDIV1Config(RCC_PREDIV1_Source_PLL2, RCC_PREDIV1_Div5);
      RCC_PLLConfig(RCC_PLLSource_PREDIV1, RCC_PLLMul_9);
      RCC_PLLCmd (ENABLE);
      while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET); // Wait till PLL is ready

}
/***************************************************************************//**
 * @brief Init USART1
 ******************************************************************************/
void SetupUSART()
{
      GPIO_InitTypeDef  GPIO_InitStructure;
      USART_InitTypeDef USART_InitStructure;

      /* Enable GPIOA clock                                                   */
      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

      /* Configure USART1 Rx (PA10) as input floating                         */
      GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;
      GPIO_Init(GPIOA, &GPIO_InitStructure);

      /* Configure USART1 Tx (PA9) as alternate function push-pull            */
      GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_9;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
      GPIO_Init(GPIOA, &GPIO_InitStructure);

      /* USART1 configured as follow:
            - BaudRate = 115200 baud
            - Word Length = 8 Bits
            - One Stop Bit
            - No parity
            - Hardware flow control disabled (RTS and CTS signals)
            - Receive and transmit enabled
            - USART Clock disabled
            - USART CPOL: Clock is active low
            - USART CPHA: Data is captured on the middle
            - USART LastBit: The clock pulse of the last data bit is not output to
                             the SCLK pin
      */
      USART_InitStructure.USART_BaudRate            = 115200;
      USART_InitStructure.USART_WordLength          = USART_WordLength_8b;
      USART_InitStructure.USART_StopBits            = USART_StopBits_1;
      USART_InitStructure.USART_Parity              = USART_Parity_No ;
      USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
      USART_InitStructure.USART_Mode                = USART_Mode_Rx | USART_Mode_Tx;
      USART_Init(USART1, &USART_InitStructure);
      USART_Cmd(USART1, ENABLE);
}

[(prx) A. K. (prx)]

Timer-Interrupt konfigurieren. Also Priorität definieren und 
einschalten.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Pete K. schrieb:
> void TIM2_IRQHandler(void)
> {
>   USART1_SendString("in TIM1\n\r");

Keine gute Idee. Lass ihn lieber nur die LED toggeln. Immerhin möchtest 
du diesen String mit 10kHz aus der UART rausdrücken, das kann nicht gut 
gehen.

So könnte die Interruptfreigabe für Timer 1 aussehen, kannst du leicht 
für Timer 2 anpassen:

// Timer interrupt
/* TIM Interrupts enable */
NVIC_InitTypeDef NVIC_InitStructure;
//
TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
/* Enable and set TIM1 Interrupt to the lowest priority */
/* Enable the TIM1 global Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = TIM1_UP_TIM16_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
TIM_Cmd(TIM1, ENABLE);
TIM_ClearITPendingBit(TIM1,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3);

[Pete K. (pete77)]

Habe das jetzt hinzugefügt (inkl. "misc.h") , funtktioniert aber immer 
noch nicht. D.h. der Timer-Interrupt wird nicht aufgerufen.

/* TIM Interrupts enable */
  NVIC_InitTypeDef NVIC_InitStructure;
  //
  TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
  /* Enable and set TIM1 Interrupt to the lowest priority */
  /* Enable the TIM1 global Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
  TIM_Cmd(TIM2, ENABLE);
  TIM_ClearITPendingBit(TIM2,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2 | TIM_IT_CC3);

[(prx) A. K. (prx)]

Dürfte nichts an der (Nicht-) Funktion ändern, aber NVIC sollte man per 
CMSIS Initialisieren, nicht mit den veralteten Funktionen der ST-Lib.

[Pete K. (pete77)]

Funktionieren die mitgelieferten Funktionen der ST-Lib nicht?
Der Compiler/Linker wirft keine Fehlermeldungen.

[(prx) A. K. (prx)]

Doch, sie funktionieren. Sie sind aber nur noch drin, damit Altprogramme 
aus der Zeit vor CMSIS übersetzbar bleiben.

[Pete K. (pete77)]

Ich kann es drehen und wenden, wie ich will, der IRQ-Handler wird nicht 
angesprungen.

[Martin Beuttenmüller (Gast)]

Ich kann mich irren, doch ich verstehe Deine PLL-Init so, dass Du
einen 25MHz Quarz verwendest. "Normal" sind doch eher 8MHz.
Mein Denkfehler oder eine Spezialanwendung ?

Dessweiteren hab' ich schon öfter gelesen, dass -gerade bei STM-
die gewünschten Peripherien eingeschaltet werden müssen.
GPIO und UART kann ich erkennen, doch bei den Timern bin ich
unsicher ...

Sind nur "Denkanstöße", bin selber (noch) am Lernen ...

Gruß
Martin

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

A. K. schrieb:
> Doch, sie funktionieren. Sie sind aber nur noch drin, damit Altprogramme
> aus der Zeit vor CMSIS übersetzbar bleiben.

So wie CMSIS aussieht, sind das nur marginale Unterschiede. Aber zeig 
uns doch mal bitte, wie das mit CMSIS aussehen würde.

Pete K. schrieb:
> RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);  // sollten 72Mhz sein

Das sieht verdächtig aus. Ich habe Timer2 noch nicht benutzt, aber der 
Timer1 wird so gestartet:

RCC_APB2PeriphClockCmd(TIM1_CLK, ENABLE);

Wenn du dir allerdings sicher bist, das APB1 für Timer2 zuständig ist, 
will ich nichts gesagt haben. Du solltest mal in der Hauptschleife 
checken, ob der Timer überhaupt rennt.

Pete K. schrieb:
> TIM_ClearITPendingBit(TIM2,TIM_IT_Update | TIM_IT_CC1 | TIM_IT_CC2 | 
TIM_IT_CC3);

Bei Timer2 brauchst du m.W. die CC Interrupts nicht zu löschen, da er 
sie gar nicht hat.

[Pete K. (pete77)]

So, jetzt funktioniert es. Timer2 liegt bei dem STM32F107C auf AHB1, das 
stimmt soweit.

Die 25Mhz als externen Qaarz habe ich gewählt, weil ich noch Ethernet 
anschließen will (später :-). Anbei ein paar Folien, die ich zum Thema 
PLL gefunden habe.

Die PLL-Initialisierung habe ich herausgenommen und als Compiler-Symbol 
HSE_VALUE=25000000 übergeben.

Hier nun der funktionierende Code für einen 1 Sek. Timer:

void SetupTimer(void)
{

  TIM_TimeBaseInitTypeDef  TIM_TimeBase_InitStructure;
  NVIC_InitTypeDef  NVIC_InitStructure;
  uint16_t PrescalerValue;

  USART1_SendString("in SetupTimer1\n");

  /* Enable TIM2 clock */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);  // sollten 36Mhz sein

  PrescalerValue = (uint16_t) 36000 - 1;   // Vorteiler berechnen  (36Mhz/36000 = 1khz)
  TIM_TimeBase_InitStructure.TIM_Prescaler = PrescalerValue; //
  TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;  // nach Prescaler=1kHz
  TIM_TimeBase_InitStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBase_InitStructure.TIM_Period = 1000; // Eine Sekunde (=1000*1kHz=1s)

  TIM_TimeBaseInit(TIM2, &TIM_TimeBase_InitStructure);

  //Timer Vorteiler-Taktkonfiguration
  TIM_PrescalerConfig(TIM2, PrescalerValue, TIM_PSCReloadMode_Immediate); // Auto-Reload

  NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  NVIC_Init(&NVIC_InitStructure);

  // Timer Interruptkonfiguration
  TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);                        // Interrupt bei Überlauf  

  TIM_ClearFlag(TIM2, TIM_FLAG_Update);

  // Enable and set TIM1 Interrupt to the lowest priority
  // Enable the TIM1 global Interrupt
  NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  TIM_Cmd(TIM2, ENABLE);
  TIM_ClearITPendingBit(TIM2,TIM_IT_Update);

  USART1_SendString("in SetupTimer2\n");
}

//timer 2 interrupt
extern  void TIM2_IRQHandler(void)
{  
  //if interrupt happens the do this
  if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
  {
    //clear interrupt and start counting again to get precise freq
    TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    //toggle led
    GPIOB->ODR ^= GPIO_Pin_10;
  }

}

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Na, das sind doch gute Nachrichten.
Pete K. schrieb:
> So, jetzt funktioniert es. Timer2 liegt bei dem STM32F107C auf AHB1, das
> stimmt soweit.
Ahh, ok. Ich fummele hier auch am 103RB des VL Discovery rum.
Pete K. schrieb:

> NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
>     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
>   NVIC_Init(&NVIC_InitStructure);
> 
>   // Timer Interruptkonfiguration
>   TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);                        // Interrupt bei Überlauf  
> 
>   TIM_ClearFlag(TIM2, TIM_FLAG_Update);
> 
>   // Enable and set TIM1 Interrupt to the lowest priority
>   // Enable the TIM1 global Interrupt
>   NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
>   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
>   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
>   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
>   NVIC_Init(&NVIC_InitStructure);

Öh, gehts erst, wenn man es zweimal macht? Wars das? War bei mir bis 
jetzt nicht nötig, aber kann ja sein. Bei der STM Doku weiss man ja 
immer nicht, wo man nachschauen muss.

[Pete K. (pete77)]

Bei der STM32 Perip. Lib ist ja auch ein chm-File als Hilfe enthalten. 
leider funktioniert das bei mir nach der Umstellung der ST-Seite nicht 
mehr. Die erste Seite wird so aufgerufen:
mk:@MSITStore:C:\winarm\STM32F10x_StdPeriph_Lib_V3.5.0\stm32f10x_stdperi 
ph_lib_um.chm::/index.html

??

Anbei noch die Folien, hatte ich im obigen Post vergessen.

Was es war, kann ich nicht mehr so genau sagen.

[Martin Beutenmüller (Gast)]

Wow!

Die 25MHz sind erklärter Maßen beabsichtigt,
das Problem scheint gelöst zu sein ...

... meine Anerkennung hast Du!
Martin