Stm32f1, Keil-RTOS, STANDBY.

#include "stm32f10x.h"

#include "stdio.h"
#include "string.h"

#include "rtl.h"

uint8_t StandByAvailable = 1;

OS_TID t_LIFE_LED;
OS_TID t_STANDBY;

void RCC_Configuration (void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    EXTI_InitTypeDef EXTI_InitStructure;
	
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOC, &GPIO_InitStructure);	

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
	
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0);
    EXTI_InitStructure.EXTI_Line = EXTI_Line0;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_Init(&EXTI_InitStructure); 
}

void EXTI0_IRQHandler(void)
{
    EXTI_ClearITPendingBit(EXTI_Line0);
	
    StandByAvailable = (StandByAvailable ^ 1);
}

void RTC_Configuration (void)
{
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
    PWR_BackupAccessCmd(ENABLE);
	
    if(PWR_GetFlagStatus(PWR_FLAG_SB) != RESET)
    {
        PWR_ClearFlag(PWR_FLAG_SB);
        RTC_WaitForSynchro();
    }

    if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
    {
        BKP_DeInit();
        RCC_LSEConfig(RCC_LSE_ON);
        while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {};
        RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
        RCC_RTCCLKCmd(ENABLE);
        RTC_WaitForSynchro();
        RTC_WaitForLastTask();
        RTC_ITConfig(RTC_IT_SEC, ENABLE);
        RTC_WaitForLastTask();
        RTC_SetPrescaler(32767);
        RTC_WaitForLastTask();
        RTC_SetCounter((12*3600 + 13*60 + 14));
        RTC_WaitForLastTask();
        BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
    }
    else
    {
        RTC_WaitForSynchro();
        RTC_ITConfig(RTC_IT_SEC, ENABLE);
        RTC_WaitForLastTask();
    }
}

void RTC_IRQHandler(void)
{
  if (RTC_GetITStatus(RTC_IT_SEC) != RESET)
  {
    RTC_ClearITPendingBit(RTC_IT_SEC);
    RTC_WaitForLastTask();

    if (GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_9))
    {
        GPIOC->BRR = GPIO_Pin_9;
    }
    else
    {
        GPIOC->BSRR = GPIO_Pin_9;
    }
  }
}

void NVIC_Configuration(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

    NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 15;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 15;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

    NVIC_Init(&NVIC_InitStructure);
}

__task void f_LIFE_LED (void)
{
   while (1)
   {
    if (GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_8))
    {
        GPIOC->BRR = GPIO_Pin_8;
    }
    else
    {
        GPIOC->BSRR = GPIO_Pin_8;
    }
    os_dly_wait (100);
   }
}

__task void f_STANDBY (void)
{
   os_itv_set (500);

   while (1)
   {
        os_itv_wait ();
        if (StandByAvailable)
        {
            RTC_SetAlarm(RTC_GetCounter()+ 5);
            RTC_WaitForLastTask();
            PWR_EnterSTANDBYMode();
        }
   }
}

__task void init (void)
{
    os_tsk_prio_self (100);

    t_LIFE_LED = os_tsk_create (f_LIFE_LED, 1);
    t_STANDBY = os_tsk_create (f_STANDBY, 1);
        
    os_tsk_delete_self ();
}


int main (void)
{
    SystemInit ();

    RTC_Configuration ();
    RCC_Configuration ();
    NVIC_Configuration();

    os_sys_init(init);
}