STM32F07VG Discovery - Timer + Sleep

[Robin H. (robin_h319)]

Hallo zusammen,

ich fange gerade an mich mit dem STM32F407 zu beschäftigen. Vorher habe 
ich öfters den MSP430G2553 und Arduino programmiert.

Ich bin gerade auf der Suche nach einem simplen Code Beispiel und blicke 
bei dem STM32 noch nicht ganz durch.

Ich möchte eigentlich etwas ähnliches wie ich es beim MSP430 oder 
Arduino umgesetzt habe:


init();
while(1){
  // programm laufen lassen
  // interrupts einschalten
  // enter sleep mode
  // interrupts ausschalten
  // ggf. flag bearbeiten
}

ISR(TIMERX_XY_vect){
  // flag setzen
  // ggf. LPMX_bits + GIE beim exit ausschalten
}

Interrupts alle x ms mit TIM3 hinbekommen ist kein Problem - dafür gibt 
es ja genügend Beispiele. Nur mit den Sleep Modes klappt es leider 
nicht.. Oder wird die Clock im Sleep Mode für den TIM3 ausgeschaltet?

Ich habe es mit PWR_EnterSTANDBYMode(); probiert.

Grüße,
Robin

[Robin H. (robin_h319)]

Hier noch etwas Code dazu - ist im endeffekt eins der Examples zu TIM 
die man in der Atollic IDE findet. Das was fehlt, wäre das Betreten 
eines LPM

TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
TIM_OCInitTypeDef  TIM_OCInitStructure;
__IO uint16_t CCR1_Val = 54618;
__IO bool TIM3_flag = false;
uint16_t PrescalerValue = 0;

void initTimer(void);

int main(void)
{
    // other init stuff
    initTimer();
    TIM_ITConfig(TIM3, TIM_IT_CC1, ENABLE);
    TIM_Cmd(TIM3, ENABLE);

    while (1)
    {
      if (TIM3_flag == true){
                // do stuff
        TIM3_flag = false;
      }
        // do stuff

    }
}

void initTimer(void){
  // Init GPIOD
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
  GPIO_InitTypeDef  GPIO_InitStructure;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOD, &GPIO_InitStructure);
  GPIO_SetBits(GPIOD,GPIO_Pin_14);

  // Init interrupt
  NVIC_InitTypeDef NVIC_InitStructure;

  /* TIM3 clock enable */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);

  /* Enable the TIM3 gloabal Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  /* Compute the prescaler value */
  PrescalerValue = (uint16_t) ((SystemCoreClock / 2) / 500000) - 1;

  /* Time base configuration */
  TIM_TimeBaseStructure.TIM_Period = 65535;
  TIM_TimeBaseStructure.TIM_Prescaler = 0;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;

  TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);

  /* Prescaler configuration */
  TIM_PrescalerConfig(TIM3, PrescalerValue, TIM_PSCReloadMode_Immediate);

  /* Output Compare Timing Mode configuration: Channel1 */
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Timing;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_Pulse = CCR1_Val;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

  TIM_OC1Init(TIM3, &TIM_OCInitStructure);

  TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Disable);
}

und aus der ISR:

uint16_t capture = 0;
extern __IO uint16_t CCR1_Val;
extern __IO bool TIM3_flag;

void TIM3_IRQHandler(void)
{
  if (TIM_GetITStatus(TIM3, TIM_IT_CC1) != RESET)
  {
    TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);

    TIM3_flag = true;

   capture = TIM_GetCapture1(TIM3);
    TIM_SetCompare1(TIM3, capture + CCR1_Val);
  }
}

Kann ich den TIM3 in verbindung mit sleep modes überhaupt nutzen? Wenn 
ja, wie muss ich die Sleep modes einstellen.

Danke für die Hilfe

[Dr. Sommer (Gast)]

Robin H. schrieb:
> Nur mit den Sleep Modes klappt es leider
> nicht.. Oder wird die Clock im Sleep Mode für den TIM3 ausgeschaltet?

Versuch's doch erstmal mit dem einfachsten Sleep Mode, bei dem nur der 
Prozessor-Kern abgeschaltet wird:

__WFI ();

oder

__asm__ volatile ("wfi");

Dabei bleiben alle zuvor aktivierten Peripherie-Einheiten an, und der 
Prozessor wacht bei Interrupts wieder auf.

Robin H. schrieb:
> if (TIM3_flag == true){
>                 // do stuff
>         TIM3_flag = false;
>       }
Bei den ARM's kannst du die eigentliche Verarbeitung auch problemlos in 
der ISR machen, du musst nicht Flags setzen und das in der main() 
machen. Indem du anderen Interrupts eine höhere Priorität zuweist, 
können die eventuell lange laufende andere ISR's unterbrechen - somit 
ist die "Regel", keine langen Verarbeitungen in der ISR zu machen, 
hinfällig. Die main() sieht dann nur noch so aus:

int main () {
  // Initialisierungen ...
  __enable_irq (); // Interrupts ein
  while (1) {
    __WFI (); // Schlafen
  }
}

Und der Rest kommt in die ISR's. Das entspricht dann einer 100% 
asynchronen Programmierung.

[Stefan F. (Gast)]

> Oder wird die Clock im Sleep Mode für den TIM3 ausgeschaltet?

Kommt auf den konkreten Sleep Modus an. Siehe 
http://stefanfrings.de/stm32/index.html#power

[Robin H. (robin_h319)]

Dr. Sommer schrieb:
> Versuch's doch erstmal mit dem einfachsten Sleep Mode, bei dem nur der
> Prozessor-Kern abgeschaltet wird:__WFI ();oder__asm__ volatile
> ("wfi");Dabei bleiben alle zuvor aktivierten Peripherie-Einheiten an,
> und der
> Prozessor wacht bei Interrupts wieder auf.

Super, danke. Mit __WFI(); hat sofort geklappt!

Dr. Sommer schrieb:
> Indem du anderen Interrupts eine höhere Priorität zuweist,
> können die eventuell lange laufende andere ISR's unterbrechen - somit
> ist die "Regel", keine langen Verarbeitungen in der ISR zu machen,
> hinfällig.

Werde ich mir mal anschauen. Bin gerade dabei Interrupts mit 
Statemachines (Yakindu State Chart Tools) zu verbinden und möchte eine 
möglichst "hardware unabhängige" Lösung erarbeiten, quasi ne Art 
Template/Pattern. Vielleicht sollte ich bei ARM's einen anderen Ansatz 
wählen.

Viele Grüße und Danke,
Robin

[Dr. Sommer (Gast)]

Robin H. schrieb:
> Vielleicht sollte ich bei ARM's einen anderen Ansatz
> wählen.

Würde ich gar nicht - State Machines kann man wunderbar in ISR's packen, 
und in einem Interrupt immer jeweilig auf die entsprechenden Ereignisse 
reagieren und den Zustand ändern. Wenn du im Interrupt gar nichts machst 
außer Flags zu setzen, kannst du die ISR auch ganz weglassen, und die 
Interrupt-Flags direkt in der main() abfragen...