STM32F1 STOPMode RTC Wakeup

[Alexander H. (alex95)]

Hallo zusammen,

wie schon in der Überschrift erwähnt versuche ich einen STM32F103C8T aus 
dem STOPMode mit Hilfe eines RTC-Alarms aufzuwecken. Im SleepMode klappt 
das auch schon. Nur im STOPMode wacht der STM32 nicht mehr auf. Nur ein 
Signal auf dem entsprechend konfiguriertem Pin PA0 schafft hier Abhilfe.
Hier ein Auszug aus meiner main.c:

  __HAL_RTC_ALARM_EXTI_ENABLE_RISING_EDGE();
  __HAL_RTC_ALARM_EXTI_ENABLE_IT();

  HAL_GPIO_WritePin(LED_A_GPIO_Port, LED_A_Pin, SET);
  HAL_RTC_SetAlarm_IT(&hrtc, &alarm_a, RTC_FORMAT_BIN);
  HAL_SuspendTick();

  HAL_PWR_EnterSTOPMode(PWR_MAINREGULATOR_ON, PWR_STOPENTRY_WFI);
//  HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);

  HAL_ResumeTick();
  SystemClock_Config();
  HAL_GPIO_WritePin(LED_A_GPIO_Port, LED_A_Pin, RESET);

Da ja laut STM Dokumentation die EXTI_Line17 speziell im STOPMode 
konfiguriert werden muss, habe ich die zwei oberen Zeilen verwendet, was 
jedoch kein Unterschied macht. Ich habe Zwar schon einige Beiträge zu 
dem Thema gefunden. Entweder wurde hier jedoch der SleepMode verwendet 
oder nicht die HAL Librarys genutzt.
Ich hoffe jemand kennt sich besser mit dem Thema aus und kann mir 
helfen.

Gruß Alex

[Magerquark (Gast)]

Ich benutze die die HAL nicht, sondern mache das "Native". Sieht bei mir 
ziemlich ähnlich aus.
Bei mir habe ich aber noch folgenden Code für den  RTC-Interrupt:

void RTCAlarm_IRQHandler()
{
  if((RTC->CRL&RTC_CRL_ALRF)!=0)
  {
    RTC->CRL &= ~RTC_CRL_ALRF;
  }
  EXTI->PR = EXTI_EMR_MR17;
}

Ob das nötig ist? Ich steck da nach einigen Jahren nicht mehr drin.

[Alexander H. (alex95)]

Erstmal danke für die Antwort.
Meine Interruptcode setzt eigentlich auch das Flag zurück. Hier die 
entsprechende Stelle:

void RTC_IRQHandler(void)
{
  /* USER CODE BEGIN RTC_IRQn 0 */

  /* USER CODE END RTC_IRQn 0 */
  HAL_RTCEx_RTCIRQHandler(&hrtc);
  /* USER CODE BEGIN RTC_IRQn 1 */
  HAL_RTC_AlarmIRQHandler(&hrtc);
  HAL_GPIO_TogglePin(LED_B_GPIO_Port, LED_B_Pin);

  /* USER CODE END RTC_IRQn 1 */
}

Wie sieht denn deine "Native" Konfiguration aus falls du die noch hast?

[Magerquark (Gast)]

Bitte sehr.
Den folgenden Code habe zum Testen des Stop-Modes verwendet. 
Sicherheithalber habe ich nichts bereinigt und den Code einfach roh hier 
eingestellt (abgekippt). Also bitte nicht schlagen.

void RTC_IRQHandler()
{
  if((RTC->ISR&RTC_ISR_ALRAF)!=0)
  {
    RTC->ISR ^= RTC_ISR_ALRAF;
  }
  EXTI->PR = EXTI_EMR_MR17;
}

int Test_StopMode(bool LSI_Enabled)
{
  // Delay und LED blinken lassen
  if(1==2)
  {
    RCC->AHBENR |= RCC_AHBENR_GPIOAEN;
    GPIOA->MODER = 0x28000100; // GPIO_MODER_MODER4_0*1;
    for(int i=0; i<20; i++)
    {
      GPIOA->ODR ^= 0x010;
      for(int i=0; i<500000; i++)
      {
        __asm("nop");
      }
    }
  }

  // fCPU = 1MHz
  RCC->CFGR |= RCC_CFGR_HPRE_DIV8;

  // alle GPIO auf Input mit Pulldown
  RCC->AHBENR |= RCC_AHBENR_GPIOAEN;
  GPIOA->PUPDR = 0xa6aaa8aa; // außer PA13/PA14 (SWD-Debug) und PA4 (LED)
  RCC->AHBENR |= RCC_AHBENR_GPIOBEN;
  GPIOB->PUPDR = 0x00000008; // Achtung: bei 0xaaaaaaaa ist PB1 möglicherweise (aber wann/warum???) floating!
  RCC->AHBENR |= RCC_AHBENR_GPIOFEN;
  GPIOF->PUPDR = 0x0000000a;

  // GPIOA4 (LED) auf Ausgang (all Pulldown, except PA4 (LED-Output) and PA13/PA14 (SWD-Debug))
  GPIOA->MODER = 0x28000100;
  // GPIOA->MODER = 0x00000100; // PA4 (LED)
  GPIOB->MODER = 0x00000000;
  GPIOF->MODER = 0x00000000;

  RCC->APB1ENR |= RCC_APB1ENR_PWREN;

  bool Interrupt = true;

  // Start LSI-Timer
  if(LSI_Enabled)
  {
    RCC->CSR |= RCC_CSR_LSION;
    while((RCC->CSR&RCC_CSR_LSIRDY)==0)
    {
      __asm("nop");
    }

    PWR->CR |= PWR_CR_DBP;

    RCC->BDCR |= RCC_BDCR_BDRST;
    RCC->BDCR = 0;
    RCC->BDCR |= RCC_BDCR_RTCSEL_0*2; // LSE RTC
    RCC->BDCR |= RCC_BDCR_RTCEN;

    // Disable write protection
    RTC->WPR = 0xCA;
    RTC->WPR = 0x53;

    // Change Prescaler
    RTC->ISR |= RTC_ISR_INIT;
    while((RTC->ISR&RTC_ISR_INITF)==0)
    {
      __asm("nop");
    }
    // RTC->PRER = 0x00090013; // T =   5ms (= (0x09+1)*(0x0013+1)/40000Hz)
    // RTC->PRER = 0x000f0018; // T =  10ms (= (0x0f+1)*(0x0018+1)/40000Hz)
    // RTC->PRER = 0x000f0031; // T =  20ms (= (0x0f+1)*(0x0031+1)/40000Hz)
    // RTC->PRER = 0x000f00f9; // T = 100ms (= (0x0f+1)*(0x00f9+1)/40000Hz)
    // RTC->PRER = 0x000f09c3; // T = 1.00s (= (0x0f+1)*(0x09c3+1)/40000Hz)
    // RTC->PRER = 0x000f3fff; // T = 6.55s (= (0x0f+1)*(0x3fff+1)/40000Hz)
    const int msT = 100;  // max. 8192ms
    RTC->PRER = 0x00090000+msT*4-1;

    RTC->ISR ^= RTC_ISR_INIT;

    if(Interrupt)
        {
          EXTI->RTSR |= EXTI_FTSR_TR17; // rising edge
          EXTI->IMR |= EXTI_IMR_MR17;
          EXTI->PR |= EXTI_EMR_MR17;
          NVIC_Init(RTC_IRQn, 3, ENABLE);
        }
      else
        {
          EXTI->RTSR |= EXTI_RTSR_TR17; // rising edge
          EXTI->EMR |= EXTI_EMR_MR17;
        }

    // Alarm bei jeder Sekunde
    RTC->ALRMAR = RTC_ALRMAR_MSK4 | RTC_ALRMAR_MSK3 | RTC_ALRMAR_MSK2 | RTC_ALRMAR_MSK1;
    RTC->CR |= RTC_CR_ALRAE | RTC_CR_ALRAIE;

    // Enable write protection
    RTC->WPR = 0xFE;
    RTC->WPR = 0x64;
  }

  while(true)
  {
    // Sleep
    PWR->CR |= PWR_CR_LPDS;
    SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
    if(Interrupt)
        {
          __WFI();
        }
      else
        {
          if((RTC->ISR&RTC_ISR_ALRAF)!=0)
          {
            RTC->ISR ^= RTC_ISR_ALRAF;
          }
          // Debug: Prüfen ob Dauerschlaf, wenn RTC_ISR_ALRAF bereits beim Aufruf von "__WFE()" gesetzt ist: (ist aber alles Ok)
          if(1==2)
          {
            while((RTC->ISR&RTC_ISR_ALRAF)==0)
            {
              __asm("nop");
            }
          }
          __WFE();
        }
    SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk);

    // Toggle LED
    if(1==1)
    {
      GPIOA->ODR ^= 0x010; // Toggle LED
      for(int i=0; i<-1000; i++)
      {
        __asm("nop");
      }
    }
  }

  //
  // - 16.11.2016
  //
  // - VCC = 3.46V
  //
  // - Interrupt = true;
  //
  // - Programm im Flash
  //
  // - LSI_Enabled==FALSE
  //   xMHz /   xms ->  5.5µA
  //
  // - LSI_Enabled==TRUE
  //   1MHz /   5ms -> 17.9µA (20.1µA im SRAM)
  //   1MHz /  10ms -> 12.3µA (13.4µA im SRAM)
  //   1MHz /  20ms ->  9.5µA (19.1µA im SRAM)
  //   1MHz / 100ms ->  7.3µA ( 7.4µA im SRAM)
  //   1MHz /  6.5s ->  6.7µA ( 6.7µA im SRAM)
  //   8MHz /   5ms -> 11.8µA
  //   8MHz /  10ms ->  9.3µA
  //   8MHz / 100ms ->  7.0µA
  //   8MHz /  6.5s ->  6.7µA
  //
  // -> Ergebnis
  //    - I(xMHz, x) = 5.5µA
  //    - I(1MHz, t) = 6.7µA + 11.2µA*5ms/t
  //    - I(8MHz, t) = 6.7µA +  5.1µA*5ms/t
  //    - Verbrauch in SRAM und FLASH gleich (etwas langsamer vermutlich wegen fehledem Optimize-Compiler-Flag)

  // - Stromaufnahme in Pausephase - im Flash (30.03.2017)
  //   VCC/V |  I/µA
  //   ------+-------
  //     2.0 |  5.5
  //     2.5 |  6.0
  //     3.0 |  6.5
  //     3.3 |  6.9 +1mA@1MHz für 50µs; +2.2mA@8MHz für 10µs; +0.2µA mit IWDG
  //     3.5 |  7.2
  //     4.0 |  7.9
  //     4.5 |  8.9
  //     5.0 |  19..12 sinkt nach und nach
  return 0;
}

[Alexander H. (alex95)]

Vielen Dank schonmal,
Ich habe beide Programme jetzt miteinander verglichen und wie du schon 
geschrieben hast machen beide ungefähr das Gleiche.
Das Problem lag in meinem Fall bei den Interrupt Handlern.
Ich habe bei mir nur den RTC_IRQHandler benutzt, welcher auch 
automatisch von CubeMX generiert wird.
Gefehlt hat der spezielle RTC_Alarm_IRQHandler. Dieser musste bei mir 
selbst geschrieben werden. Mich wundert jetzt nur, dass dieser auch bei 
dir fehlt oder ich übersehe auch nur wieder etwas.
Mich würde nur noch interessieren, ob ich die Einstellung für den Alarm 
Interrupt in CubeMX nur nicht gefunden habe oder ob man diese immer 
manuell vornehmen muss. Falls jemand auch CubeMX benutzt kann er ja mal 
seine Ideen hier schreiben. Ich nutze die Version 5.0.1.

[Magerquark (Gast)]

Ich Trottel hab den Code aus meinem STM32F0-Ordner genommen. Der Code 
für den STM32F1 sieht anders aus. Dort verwende ich auch den 
RTCAlarm_IRQHandler. (Bzw. wenn unbenötigt nötig würde es aber auch ohne 
Interrupt per "Event" gehen.)

[Stefan F. (Gast)]

Ist mir auch schon mal passiert. Leider spuckt der Compiler keine 
Fehlermeldung aus, wenn die C-Funktion des Interrupt Handlers den 
falschen Namen hat.

Ich glaube, man müsste die ganzen Weak referenzen aus der 
startup_stm32.s entfernen. Kennt jemand eine elegantere Lösung, diesen 
Fehler zu vermeiden?