WebSVN – LedShow – Diff – /trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_ll_rtc.c

 /**
   ******************************************************************************
   * @file    stm32f1xx_ll_rtc.c
   * @author  MCD Application Team
   * @brief   RTC LL module driver.
   ******************************************************************************
   * @attention
+  *
-  * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
+  * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
+  * All rights reserved.</center></h2>
+  *
-  * Redistribution and use in source and binary forms, with or without modification,
+  * This software component is licensed by ST under BSD 3-Clause license,
-  * are permitted provided that the following conditions are met:
+  * the "License"; You may not use this file except in compliance with the
-  *   1. Redistributions of source code must retain the above copyright notice,
-  *      this list of conditions and the following disclaimer.
-  *   2. Redistributions in binary form must reproduce the above copyright notice,
-  *      this list of conditions and the following disclaimer in the documentation
-  *      and/or other materials provided with the distribution.
+  * License. You may obtain a copy of the License at:
-  *   3. Neither the name of STMicroelectronics nor the names of its contributors
-  *      may be used to endorse or promote products derived from this software
+  *                        opensource.org/licenses/BSD-3-Clause
-  *      without specific prior written permission.
-  *
-  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  *
   ******************************************************************************
   */
 #if defined(USE_FULL_LL_DRIVER)
 /* Includes ------------------------------------------------------------------*/
 #include "stm32f1xx_ll_rtc.h"
 #include "stm32f1xx_ll_cortex.h"
 #define IS_LL_RTC_MINUTES(__MINUTES__)        ((__MINUTES__) <= 59U)
 #define IS_LL_RTC_SECONDS(__SECONDS__)        ((__SECONDS__) <= 59U)
 #define IS_LL_RTC_CALIB_OUTPUT(__OUTPUT__) (((__OUTPUT__) == LL_RTC_CALIB_OUTPUT_NONE) || \
                                             ((__OUTPUT__) == LL_RTC_CALIB_OUTPUT_RTCCLOCK) || \
                                             ((__OUTPUT__) == LL_RTC_CALIB_OUTPUT_ALARM) || \
                                             ((__OUTPUT__) == LL_RTC_CALIB_OUTPUT_SECOND))
 /**
   * @}
   */
 /* Private function prototypes -----------------------------------------------*/
 /* Exported functions --------------------------------------------------------*/
   LL_RTC_DisableWriteProtection(RTCx);
   /* Set Initialization mode */
   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
+  {
-    LL_RTC_WriteReg(RTCx,CNTL, 0x0000);
+    LL_RTC_WriteReg(RTCx, CNTL, 0x0000);
-    LL_RTC_WriteReg(RTCx,CNTH, 0x0000);
+    LL_RTC_WriteReg(RTCx, CNTH, 0x0000);
-    LL_RTC_WriteReg(RTCx,PRLH, 0x0000);
+    LL_RTC_WriteReg(RTCx, PRLH, 0x0000);
-    LL_RTC_WriteReg(RTCx,PRLL, 0x8000);
+    LL_RTC_WriteReg(RTCx, PRLL, 0x8000);
-    LL_RTC_WriteReg(RTCx,CRH,  0x0000);
+    LL_RTC_WriteReg(RTCx, CRH,  0x0000);
-    LL_RTC_WriteReg(RTCx,CRL,  0x0020);
+    LL_RTC_WriteReg(RTCx, CRL,  0x0020);
     /* Reset Tamper and alternate functions configuration register */
-    LL_RTC_WriteReg(BKP,RTCCR, 0x00000000U);
+    LL_RTC_WriteReg(BKP, RTCCR, 0x00000000U);
-    LL_RTC_WriteReg(BKP,CR,    0x00000000U);
+    LL_RTC_WriteReg(BKP, CR,    0x00000000U);
-    LL_RTC_WriteReg(BKP,CSR,   0x00000000U);
+    LL_RTC_WriteReg(BKP, CSR,   0x00000000U);
     /* Exit Initialization Mode */
-    if(LL_RTC_ExitInitMode(RTCx) == ERROR)
+    if (LL_RTC_ExitInitMode(RTCx) != ERROR)
+    {
+      /* Wait till the RTC RSF flag is set */
+      status = LL_RTC_WaitForSynchro(RTCx);
-      return ERROR;
+      /* Clear RSF Flag */
+      LL_RTC_ClearFlag_RS(RTCx);
+      /* Enable the write protection for RTC registers */
+      LL_RTC_EnableWriteProtection(RTCx);
+    }
-    /* Wait till the RTC RSF flag is set */
-    status = LL_RTC_WaitForSynchro(RTCx);
-    /* Clear RSF Flag */
-    LL_RTC_ClearFlag_RS(RTCx);
+  }
+  else
+  {
-  /* Enable the write protection for RTC registers */
+    /* Enable the write protection for RTC registers */
-  LL_RTC_EnableWriteProtection(RTCx);
+    LL_RTC_EnableWriteProtection(RTCx);
+  }
   return status;
+}
 /**
   /* Check the parameters */
   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
   assert_param(IS_LL_RTC_ASYNCH_PREDIV(RTC_InitStruct->AsynchPrescaler));
   assert_param(IS_LL_RTC_CALIB_OUTPUT(RTC_InitStruct->OutPutSource));
   /* Waiting for synchro */
-  if(LL_RTC_WaitForSynchro(RTCx) != ERROR)
+  if (LL_RTC_WaitForSynchro(RTCx) != ERROR)
+  {
     /* Set Initialization mode */
     if (LL_RTC_EnterInitMode(RTCx) != ERROR)
+    {
       /* Clear Flag Bits */
       LL_RTC_ClearFlag_ALR(RTCx);
       LL_RTC_ClearFlag_OW(RTCx);
       LL_RTC_ClearFlag_SEC(RTCx);
-      if(RTC_InitStruct->OutPutSource != LL_RTC_CALIB_OUTPUT_NONE)
+      if (RTC_InitStruct->OutPutSource != LL_RTC_CALIB_OUTPUT_NONE)
+      {
         /* Disable the selected Tamper Pin */
         LL_RTC_TAMPER_Disable(BKP);
+      }
       /* Set the signal which will be routed to RTC Tamper Pin */
       LL_RTC_SetOutputSource(BKP, RTC_InitStruct->OutPutSource);
       /* Configure Synchronous and Asynchronous prescaler factor */
       LL_RTC_SetAsynchPrescaler(RTCx, RTC_InitStruct->AsynchPrescaler);
       /* Exit Initialization Mode */
       LL_RTC_ExitInitMode(RTCx);
       status = SUCCESS;
+    }
+  }
   return status;
+}
   * @param  RTC_Format This parameter can be one of the following values:
   *         @arg @ref LL_RTC_FORMAT_BIN
   *         @arg @ref LL_RTC_FORMAT_BCD
   * @param  RTC_TimeStruct pointer to a RTC_TimeTypeDef structure that contains
   *                        the time configuration information for the RTC.
   * @note  The user should call LL_RTC_TIME_StructInit() or the structure
   *        of time need to be initialized  before time init()
   * @retval An ErrorStatus enumeration value:
   *          - SUCCESS: RTC Time register is configured
   *          - ERROR: RTC Time register is not configured
   */
   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
+  {
     /* Check the input parameters format */
     if (RTC_Format != LL_RTC_FORMAT_BIN)
+    {
-    counter_time = (uint32_t)(((uint32_t)RTC_TimeStruct->Hours * 3600U) + \
+      counter_time = (uint32_t)(((uint32_t)RTC_TimeStruct->Hours * 3600U) + \
-                        ((uint32_t)RTC_TimeStruct->Minutes * 60U) + \
+                                ((uint32_t)RTC_TimeStruct->Minutes * 60U) + \
-                        ((uint32_t)RTC_TimeStruct->Seconds));
+                                ((uint32_t)RTC_TimeStruct->Seconds));
       LL_RTC_TIME_Set(RTCx, counter_time);
+    }
     else
+    {
-     counter_time = (((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)) * 3600U) + \
+      counter_time = (((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)) * 3600U) + \
-              ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Minutes)) * 60U) + \
+                      ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Minutes)) * 60U) + \
-              ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Seconds))));
+                      ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Seconds))));
       LL_RTC_TIME_Set(RTCx, counter_time);
+    }
     status = SUCCESS;
+  }
   /* Exit Initialization mode */
   * @param  RTC_Format This parameter can be one of the following values:
   *         @arg @ref LL_RTC_FORMAT_BIN
   *         @arg @ref LL_RTC_FORMAT_BCD
   * @param  RTC_AlarmStruct pointer to a @ref LL_RTC_AlarmTypeDef structure that
   *                         contains the alarm configuration parameters.
   * @note   the user should call LL_RTC_ALARM_StructInit()  or the structure
   *         of Alarm need to be initialized  before Alarm init()
   * @retval An ErrorStatus enumeration value:
   *          - SUCCESS: ALARM registers are configured
   *          - ERROR: ALARM registers are not configured
   */
   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
+  {
     /* Check the input parameters format */
     if (RTC_Format != LL_RTC_FORMAT_BIN)
+    {
-    counter_alarm = (uint32_t)(((uint32_t)RTC_AlarmStruct->AlarmTime.Hours * 3600U) + \
+      counter_alarm = (uint32_t)(((uint32_t)RTC_AlarmStruct->AlarmTime.Hours * 3600U) + \
-                        ((uint32_t)RTC_AlarmStruct->AlarmTime.Minutes * 60U) + \
+                                 ((uint32_t)RTC_AlarmStruct->AlarmTime.Minutes * 60U) + \
-                        ((uint32_t)RTC_AlarmStruct->AlarmTime.Seconds));
+                                 ((uint32_t)RTC_AlarmStruct->AlarmTime.Seconds));
       LL_RTC_ALARM_Set(RTCx, counter_alarm);
+    }
     else
+    {
-     counter_alarm = (((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)) * 3600U) + \
+      counter_alarm = (((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)) * 3600U) + \
-              ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)) * 60U) + \
+                       ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)) * 60U) + \
-              ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds))));
+                       ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds))));
       LL_RTC_ALARM_Set(RTCx, counter_alarm);
+    }
     status = SUCCESS;
+  }
   /* Exit Initialization mode */
   uint32_t tmp = 0U;
   /* Check the parameter */
   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
-    /* Wait till RTC is in INIT state and if Time out is reached exit */
+  /* Wait till RTC is in INIT state and if Time out is reached exit */
+  tmp = LL_RTC_IsActiveFlag_RTOF(RTCx);
+  while ((timeout != 0U) && (tmp != 1U))
+  {
+    if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
+    {
+      timeout --;
+    }
     tmp = LL_RTC_IsActiveFlag_RTOF(RTCx);
-    while ((timeout != 0U) && (tmp != 1U))
+    if (timeout == 0U)
+    {
-      if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
-      {
-        timeout --;
-      }
-      tmp = LL_RTC_IsActiveFlag_RTOF(RTCx);
-      if (timeout == 0U)
-      {
-        status = ERROR;
+      status = ERROR;
-      }
+    }
+  }
-   /* Disable the write protection for RTC registers */
+  /* Disable the write protection for RTC registers */
   LL_RTC_DisableWriteProtection(RTCx);
   return status;
+}
 /**
   * @brief  Exit the RTC Initialization mode.
 ErrorStatus LL_RTC_ExitInitMode(RTC_TypeDef *RTCx)
+{
   __IO uint32_t timeout = RTC_INITMODE_TIMEOUT;
   ErrorStatus status = SUCCESS;
   uint32_t tmp = 0U;
   /* Check the parameter */
   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
   /* Disable initialization mode */
   LL_RTC_EnableWriteProtection(RTCx);
   /* Wait till RTC is in INIT state and if Time out is reached exit */
   tmp = LL_RTC_IsActiveFlag_RTOF(RTCx);
   while ((timeout != 0U) && (tmp != 1U))
+  {
     if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
   /* Enter Initialization mode */
   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
+  {
-   LL_RTC_TIME_Set(RTCx, TimeCounter);
+    LL_RTC_TIME_Set(RTCx, TimeCounter);
-   status = SUCCESS;
+    status = SUCCESS;
+  }
   /* Exit Initialization mode */
   LL_RTC_ExitInitMode(RTCx);
   return status;
+}
 /**
   * @brief  Set Alarm Counter.
   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
   /* Enter Initialization mode */
   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
+  {
-     LL_RTC_ALARM_Set(RTCx, AlarmCounter);
+    LL_RTC_ALARM_Set(RTCx, AlarmCounter);
-     status = SUCCESS;
+    status = SUCCESS;
+  }
   /* Exit Initialization mode */
   LL_RTC_ExitInitMode(RTCx);
   return status;

Subversion Repositories LedShow

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_ll_rtc.c – Rev 2 → 9