STM32F303 Wakeup Timer löst keine Interrupts aus

[Stefan F. (Gast)]

Ich möchte erreichen, dass der Wakeup Timer alle 2 Sekunden einen 
Interrupt auslöst damit die LED an PA5 blinkt. Sie bleibt aber leider 
dunkel. Sieht jemand, was ich falsch mache?

#include "stm32f3xx.h"
#include <stdio.h>

uint32_t SystemCoreClock=8000000;

// Delay loop for the default 8 MHz CPU clock with optimizer enabled
void delay(uint32_t msec)
{
    for (uint32_t j=0; j<2000UL*msec; j++)
    {
        __NOP();
    }
}

// Redirect standard output to the serial port
int _write(int file, char *ptr, int len)
{
    for (int i=0; i<len; i++)
    {
        while(!(USART2->ISR & USART_ISR_TXE));
        USART2->TDR = *ptr++;
    }
    return len;
}

void initSerial()
{
    // Use system clock for USART2
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_USART2EN);
    MODIFY_REG(RCC->CFGR3, RCC_CFGR3_USART2SW, RCC_CFGR3_USART2SW_0);

    // PA2 (TxD) shall use the alternate function 7 (see Reference manual)
    MODIFY_REG(GPIOA->AFR[0], GPIO_AFRL_AFRL2, 7U<<GPIO_AFRL_AFRL2_Pos);
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODER2, GPIO_MODER_MODER2_1);

    // Set baudrate
    USART2->BRR = (SystemCoreClock / 2400);

    // Enable transmitter of USART2
    USART2->CR1 = USART_CR1_UE + USART_CR1_TE;
}

void init_io()
{
    // Enable Port A
    SET_BIT(RCC->AHBENR, RCC_AHBENR_GPIOAEN);

    // PA5 = Output for the LED (High=On, Low=Off)
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODER5, GPIO_MODER_MODER5_0);
}

void initRtc()
{
    // Enable the power interface
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_PWREN);

    // Enable the power of the backup domain
    SET_BIT(PWR->CR, PWR_CR_DBP);

    // Enable LSE oscillator with medium driver power
    MODIFY_REG(RCC->BDCR, RCC_BDCR_LSEDRV, RCC_BDCR_LSEDRV_1);
    SET_BIT(RCC->BDCR, RCC_BDCR_LSEON);

    // Wait until LSE oscillator is ready
    while(!READ_BIT(RCC->BDCR, RCC_BDCR_LSERDY)) {}

    // Select LSE as clock source for the RTC
    MODIFY_REG(RCC->BDCR, RCC_BDCR_RTCSEL, RCC_BDCR_RTCSEL_LSE);

    // Enable the RTC
    SET_BIT(RCC->BDCR, RCC_BDCR_RTCEN);

    // Enable write access to the RTC registers
    WRITE_REG(RTC->WPR, 0xCA);
    WRITE_REG(RTC->WPR, 0x53);

    // Stop the wakeup timer to allow configuration update
    CLEAR_BIT(RTC->CR, RTC_CR_WUTE);

    // Wait until the wakeup timer is ready for configuration update
    while (!READ_BIT(RTC->ISR, RTC_ISR_WUTWF)) {};

    // The wakeup period is 2 clock pulses
    WRITE_REG(RTC->WUTR,1);

    // Clock source of the wakeup timer is 1 Hz
    MODIFY_REG(RTC->CR, RTC_CR_WUCKSEL, RTC_CR_WUCKSEL_2);

    // Enable the wakeup timer with interrupts
    SET_BIT(RTC->CR, RTC_CR_WUTE + RTC_CR_WUTIE);

    // Enable interrupt in NVIC
    NVIC_EnableIRQ(RTC_WKUP_IRQn);
}

void RTC_WKUP_IRQHandler(void)
{
    // Clear interrupt flag
    CLEAR_BIT(RTC->ISR, RTC_ISR_WUTF);

    // Toggle LED 
    GPIOA->ODR ^= GPIO_ODR_5;
}

int main(void)
{
    init_io();
    initRtc();
    initSerial();
    while(1)
    {
        printf("Time %ld\n",RTC->TR);
        delay(500);
    }
}

An der seriellen Ausgabe via printf() erkenne ich, dass die Uhr läuft. 
Der ausgegebene Zahlenwert ändert sich jede Sekunde. Nur der Interrupt 
wird nie aufgerufen. Hier hänge ich fest.

Als Hardware dient ein Nucleo-64 Board mit STM32F303RE ohne externe 
Beschaltung. Stromversorgung über USB Kabel.

[Stefan F. (Gast)]

Ich habe es selbst heraus gefunden: Knackpunkt war, dass ich mich noch 
um die EXTI Register kümmern musste.

Ich habe dazu noch eine Frage (weiter unten).

#include "stm32f3xx.h"
#include <stdio.h>

void init_io()
{
    // Enable Port A
    SET_BIT(RCC->AHBENR, RCC_AHBENR_GPIOAEN);

    // PA5 = Output for the LED
    MODIFY_REG(GPIOA->MODER, GPIO_MODER_MODER5, GPIO_MODER_MODER5_0);
}

void initRtc()
{
    // Enable the power interface
    SET_BIT(RCC->APB1ENR, RCC_APB1ENR_PWREN);

    // Enable access to the backup domain
    SET_BIT(PWR->CR, PWR_CR_DBP);

    // Enable LSE oscillator with medium driver power
    MODIFY_REG(RCC->BDCR, RCC_BDCR_LSEDRV, RCC_BDCR_LSEDRV_1);
    SET_BIT(RCC->BDCR, RCC_BDCR_LSEON);

    // Wait until LSE oscillator is ready
    while(!READ_BIT(RCC->BDCR, RCC_BDCR_LSERDY)) {}

    // Select LSE as clock source for the RTC
    MODIFY_REG(RCC->BDCR, RCC_BDCR_RTCSEL, RCC_BDCR_RTCSEL_LSE);

    // Enable the RTC
    SET_BIT(RCC->BDCR, RCC_BDCR_RTCEN);

    // Enable write access to the RTC registers
    WRITE_REG(RTC->WPR, 0xCA);
    WRITE_REG(RTC->WPR, 0x53);

    // Enter initialzation mode for changes to RTC->TR, RTC->DR and RTC->PRER
    // SET_BIT(RTC->ISR, RTC_ISR_INIT);

    // Wait until the initialization mode is active
    // while (!READ_BIT(RTC->ISR, RTC_ISR_INITF)) {};

    // The RTC prescaler is already set to (127+1)*(255+1) = 32768 by default
    // WRITE_REG(RTC->PRER,(127<<RTC_PRER_PREDIV_A_Pos)+255);

    // End the initialization mode
    // CLEAR_BIT(RTC->ISR, RTC_ISR_INIT);

    // Stop the wakeup timer to allow configuration update
    CLEAR_BIT(RTC->CR, RTC_CR_WUTE);

    // Wait until the wakeup timer is ready for configuration update
    while (!READ_BIT(RTC->ISR, RTC_ISR_WUTWF)) {};

    // Clock source of the wakeup timer is 1 Hz
    MODIFY_REG(RTC->CR, RTC_CR_WUCKSEL, RTC_CR_WUCKSEL_2);

    // The wakeup period is 0+1 clock pulses
    WRITE_REG(RTC->WUTR,0);

    // Enable the wakeup timer with interrupts
    SET_BIT(RTC->CR, RTC_CR_WUTE + RTC_CR_WUTIE);

    // Optional: disable write access to the RTC registers
    // WRITE_REG(RTC->WPR, 0xFF);

    // Enable EXTI20 interrupt on rising edge
    SET_BIT(EXTI->IMR, EXTI_IMR_MR20);
    SET_BIT(EXTI->RTSR, EXTI_RTSR_TR20);
    NVIC_EnableIRQ(RTC_WKUP_IRQn);

    // Clear (old) pending interrupt flags
    CLEAR_BIT(RTC->ISR, RTC_ISR_WUTF);
    SET_BIT(EXTI->PR, EXTI_PR_PR20);
}

void RTC_WKUP_IRQHandler(void)
{
    // Clear interrupt flag
    CLEAR_BIT(RTC->ISR, RTC_ISR_WUTF);
    SET_BIT(EXTI->PR, EXTI_PR_PR20);

    // Toggle LED
    GPIOA->ODR ^= GPIO_ODR_5;
}

int main(void)
{
    init_io();
    initRtc();
    while(1){};
}

Ist es korrekt, dass ich in der ISR das Interrupt-Flag doppelt 
zurücksetzen muss (in der RTC und im NVIC)? Es scheint nötig zu sein, 
aber vielleicht geht es eleganter.

[pegel (Gast)]

Das mit dem EXTI 20 habe ich durch anlegen mit CubeMX auch gerade heraus 
gefunden.

Der IRQHandler sieht so aus:

/**
  * @brief  Handle Wake Up Timer interrupt request.
  * @param  hrtc RTC handle
  * @retval None
  */
void HAL_RTCEx_WakeUpTimerIRQHandler(RTC_HandleTypeDef *hrtc)
{
  /* Get the pending status of the WAKEUPTIMER Interrupt */
  if(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTF) != RESET)
  {
    /* WAKEUPTIMER callback */
    HAL_RTCEx_WakeUpTimerEventCallback(hrtc);
    
    /* Clear the WAKEUPTIMER interrupt pending bit */
    __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);
  }

  /* Clear the EXTI's line Flag for RTC WakeUpTimer */
  __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG();
  
  /* Change RTC state */
  hrtc->State = HAL_RTC_STATE_READY;
}

Bei der Auswahl des Interrupt in CubeMX heisst der:

"RTC wakeup-interrupt through EXTI line 20"

[Stefan F. (Gast)]

Danke, ich hatte das im CubeMx nicht gefunden. Danke, dein Auszug 
bestätigt, dass es wohl so gemacht werden muss.