mbed library sources
Fork of mbed-src by
targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_rtc.c@394:83f921546702, 2014-11-07 (annotated)
- Committer:
- mbed_official
- Date:
- Fri Nov 07 15:45:07 2014 +0000
- Revision:
- 394:83f921546702
- Parent:
- targets/cmsis/TARGET_STM/TARGET_NUCLEO_L152RE/stm32l1xx_hal_rtc.c@354:e67efb2aab0e
Synchronized with git revision aab52cb7ec5a665869e507dd988bbfd55b7e087e
Full URL: https://github.com/mbedmicro/mbed/commit/aab52cb7ec5a665869e507dd988bbfd55b7e087e/
Tests: Fix cpputest testrunner
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
mbed_official | 354:e67efb2aab0e | 1 | /** |
mbed_official | 354:e67efb2aab0e | 2 | ****************************************************************************** |
mbed_official | 354:e67efb2aab0e | 3 | * @file stm32l1xx_hal_rtc.c |
mbed_official | 354:e67efb2aab0e | 4 | * @author MCD Application Team |
mbed_official | 354:e67efb2aab0e | 5 | * @version V1.0.0 |
mbed_official | 354:e67efb2aab0e | 6 | * @date 5-September-2014 |
mbed_official | 354:e67efb2aab0e | 7 | * @brief RTC HAL module driver. |
mbed_official | 354:e67efb2aab0e | 8 | * This file provides firmware functions to manage the following |
mbed_official | 354:e67efb2aab0e | 9 | * functionalities of the Real Time Clock (RTC) peripheral: |
mbed_official | 354:e67efb2aab0e | 10 | * + Initialization and de-initialization functions |
mbed_official | 354:e67efb2aab0e | 11 | * + RTC Time and Date functions |
mbed_official | 354:e67efb2aab0e | 12 | * + RTC Alarm functions |
mbed_official | 354:e67efb2aab0e | 13 | * + Peripheral Control functions |
mbed_official | 354:e67efb2aab0e | 14 | * + Peripheral State functions |
mbed_official | 354:e67efb2aab0e | 15 | * |
mbed_official | 354:e67efb2aab0e | 16 | @verbatim |
mbed_official | 354:e67efb2aab0e | 17 | ============================================================================== |
mbed_official | 354:e67efb2aab0e | 18 | ##### Backup Domain Operating Condition ##### |
mbed_official | 354:e67efb2aab0e | 19 | ============================================================================== |
mbed_official | 354:e67efb2aab0e | 20 | [..] The real-time clock (RTC) and the RTC backup registers can be powered |
mbed_official | 354:e67efb2aab0e | 21 | from the VBAT voltage when the main VDD supply is powered off. |
mbed_official | 354:e67efb2aab0e | 22 | To retain the content of the RTC backup registers and supply the RTC |
mbed_official | 354:e67efb2aab0e | 23 | when VDD is turned off, VBAT pin can be connected to an optional |
mbed_official | 354:e67efb2aab0e | 24 | standby voltage supplied by a battery or by another source. |
mbed_official | 354:e67efb2aab0e | 25 | |
mbed_official | 354:e67efb2aab0e | 26 | [..] To allow the RTC operating even when the main digital supply (VDD) is turned |
mbed_official | 354:e67efb2aab0e | 27 | off, the VBAT pin powers the following blocks: |
mbed_official | 354:e67efb2aab0e | 28 | (#) The RTC |
mbed_official | 354:e67efb2aab0e | 29 | (#) The LSE oscillator |
mbed_official | 354:e67efb2aab0e | 30 | (#) PC13 to PC15 I/Os (when available) |
mbed_official | 354:e67efb2aab0e | 31 | |
mbed_official | 354:e67efb2aab0e | 32 | [..] When the backup domain is supplied by VDD (analog switch connected to VDD), |
mbed_official | 354:e67efb2aab0e | 33 | the following pins are available: |
mbed_official | 354:e67efb2aab0e | 34 | (#) PC14 and PC15 can be used as either GPIO or LSE pins |
mbed_official | 354:e67efb2aab0e | 35 | (#) PC13 can be used as a GPIO or as the RTC_AF1 pin |
mbed_official | 354:e67efb2aab0e | 36 | |
mbed_official | 354:e67efb2aab0e | 37 | [..] When the backup domain is supplied by VBAT (analog switch connected to VBAT |
mbed_official | 354:e67efb2aab0e | 38 | because VDD is not present), the following pins are available: |
mbed_official | 354:e67efb2aab0e | 39 | (#) PC14 and PC15 can be used as LSE pins only |
mbed_official | 354:e67efb2aab0e | 40 | (#) PC13 can be used as the RTC_AF1 pin |
mbed_official | 354:e67efb2aab0e | 41 | |
mbed_official | 354:e67efb2aab0e | 42 | ##### Backup Domain Reset ##### |
mbed_official | 354:e67efb2aab0e | 43 | ================================================================== |
mbed_official | 354:e67efb2aab0e | 44 | [..] The backup domain reset sets all RTC registers and the RCC_BDCR register |
mbed_official | 354:e67efb2aab0e | 45 | to their reset values. |
mbed_official | 354:e67efb2aab0e | 46 | [..] A backup domain reset is generated when one of the following events occurs: |
mbed_official | 354:e67efb2aab0e | 47 | (#) Software reset, triggered by setting the BDRST bit in the |
mbed_official | 354:e67efb2aab0e | 48 | RCC Backup domain control register (RCC_BDCR). |
mbed_official | 354:e67efb2aab0e | 49 | (#) VDD or VBAT power on, if both supplies have previously been powered off. |
mbed_official | 354:e67efb2aab0e | 50 | |
mbed_official | 354:e67efb2aab0e | 51 | ##### Backup Domain Access ##### |
mbed_official | 354:e67efb2aab0e | 52 | ================================================================== |
mbed_official | 354:e67efb2aab0e | 53 | [..] After reset, the backup domain (RTC registers, RTC backup data |
mbed_official | 354:e67efb2aab0e | 54 | registers and backup SRAM) is protected against possible unwanted write |
mbed_official | 354:e67efb2aab0e | 55 | accesses. |
mbed_official | 354:e67efb2aab0e | 56 | [..] To enable access to the RTC Domain and RTC registers, proceed as follows: |
mbed_official | 354:e67efb2aab0e | 57 | (+) Enable the Power Controller (PWR) APB1 interface clock using the |
mbed_official | 354:e67efb2aab0e | 58 | __PWR_CLK_ENABLE() function. |
mbed_official | 354:e67efb2aab0e | 59 | (+) Enable access to RTC domain using the HAL_PWR_EnableBkUpAccess() function. |
mbed_official | 354:e67efb2aab0e | 60 | (+) Select the RTC clock source using the __HAL_RCC_RTC_CONFIG() function. |
mbed_official | 354:e67efb2aab0e | 61 | (+) Enable RTC Clock using the __HAL_RCC_RTC_ENABLE() function. |
mbed_official | 354:e67efb2aab0e | 62 | |
mbed_official | 354:e67efb2aab0e | 63 | |
mbed_official | 354:e67efb2aab0e | 64 | ##### How to use this driver ##### |
mbed_official | 354:e67efb2aab0e | 65 | ================================================================== |
mbed_official | 354:e67efb2aab0e | 66 | [..] |
mbed_official | 354:e67efb2aab0e | 67 | (+) Enable the RTC domain access (see description in the section above). |
mbed_official | 354:e67efb2aab0e | 68 | (+) Configure the RTC Prescaler (Asynchronous and Synchronous) and RTC hour |
mbed_official | 354:e67efb2aab0e | 69 | format using the HAL_RTC_Init() function. |
mbed_official | 354:e67efb2aab0e | 70 | |
mbed_official | 354:e67efb2aab0e | 71 | *** Time and Date configuration *** |
mbed_official | 354:e67efb2aab0e | 72 | =================================== |
mbed_official | 354:e67efb2aab0e | 73 | [..] |
mbed_official | 354:e67efb2aab0e | 74 | (+) To configure the RTC Calendar (Time and Date) use the HAL_RTC_SetTime() |
mbed_official | 354:e67efb2aab0e | 75 | and HAL_RTC_SetDate() functions. |
mbed_official | 354:e67efb2aab0e | 76 | (+) To read the RTC Calendar, use the HAL_RTC_GetTime() and HAL_RTC_GetDate() functions. |
mbed_official | 354:e67efb2aab0e | 77 | |
mbed_official | 354:e67efb2aab0e | 78 | *** Alarm configuration *** |
mbed_official | 354:e67efb2aab0e | 79 | =========================== |
mbed_official | 354:e67efb2aab0e | 80 | [..] |
mbed_official | 354:e67efb2aab0e | 81 | (+) To configure the RTC Alarm use the HAL_RTC_SetAlarm() function. |
mbed_official | 354:e67efb2aab0e | 82 | You can also configure the RTC Alarm with interrupt mode using the HAL_RTC_SetAlarm_IT() function. |
mbed_official | 354:e67efb2aab0e | 83 | (+) To read the RTC Alarm, use the HAL_RTC_GetAlarm() function. |
mbed_official | 354:e67efb2aab0e | 84 | |
mbed_official | 354:e67efb2aab0e | 85 | ##### RTC and low power modes ##### |
mbed_official | 354:e67efb2aab0e | 86 | ================================================================== |
mbed_official | 354:e67efb2aab0e | 87 | [..] The MCU can be woken up from a low power mode by an RTC alternate |
mbed_official | 354:e67efb2aab0e | 88 | function. |
mbed_official | 354:e67efb2aab0e | 89 | [..] The RTC alternate functions are the RTC alarms (Alarm A and Alarm B), |
mbed_official | 354:e67efb2aab0e | 90 | RTC wakeup, RTC tamper event detection and RTC time stamp event detection. |
mbed_official | 354:e67efb2aab0e | 91 | These RTC alternate functions can wake up the system from the Stop and |
mbed_official | 354:e67efb2aab0e | 92 | Standby low power modes. |
mbed_official | 354:e67efb2aab0e | 93 | [..] The system can also wake up from low power modes without depending |
mbed_official | 354:e67efb2aab0e | 94 | on an external interrupt (Auto-wakeup mode), by using the RTC alarm |
mbed_official | 354:e67efb2aab0e | 95 | or the RTC wakeup events. |
mbed_official | 354:e67efb2aab0e | 96 | [..] The RTC provides a programmable time base for waking up from the |
mbed_official | 354:e67efb2aab0e | 97 | Stop or Standby mode at regular intervals. |
mbed_official | 354:e67efb2aab0e | 98 | Wakeup from STOP and STANDBY modes is possible only when the RTC clock source |
mbed_official | 354:e67efb2aab0e | 99 | is LSE or LSI. |
mbed_official | 354:e67efb2aab0e | 100 | |
mbed_official | 354:e67efb2aab0e | 101 | @endverbatim |
mbed_official | 354:e67efb2aab0e | 102 | ****************************************************************************** |
mbed_official | 354:e67efb2aab0e | 103 | * @attention |
mbed_official | 354:e67efb2aab0e | 104 | * |
mbed_official | 354:e67efb2aab0e | 105 | * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2> |
mbed_official | 354:e67efb2aab0e | 106 | * |
mbed_official | 354:e67efb2aab0e | 107 | * Redistribution and use in source and binary forms, with or without modification, |
mbed_official | 354:e67efb2aab0e | 108 | * are permitted provided that the following conditions are met: |
mbed_official | 354:e67efb2aab0e | 109 | * 1. Redistributions of source code must retain the above copyright notice, |
mbed_official | 354:e67efb2aab0e | 110 | * this list of conditions and the following disclaimer. |
mbed_official | 354:e67efb2aab0e | 111 | * 2. Redistributions in binary form must reproduce the above copyright notice, |
mbed_official | 354:e67efb2aab0e | 112 | * this list of conditions and the following disclaimer in the documentation |
mbed_official | 354:e67efb2aab0e | 113 | * and/or other materials provided with the distribution. |
mbed_official | 354:e67efb2aab0e | 114 | * 3. Neither the name of STMicroelectronics nor the names of its contributors |
mbed_official | 354:e67efb2aab0e | 115 | * may be used to endorse or promote products derived from this software |
mbed_official | 354:e67efb2aab0e | 116 | * without specific prior written permission. |
mbed_official | 354:e67efb2aab0e | 117 | * |
mbed_official | 354:e67efb2aab0e | 118 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
mbed_official | 354:e67efb2aab0e | 119 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
mbed_official | 354:e67efb2aab0e | 120 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
mbed_official | 354:e67efb2aab0e | 121 | * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
mbed_official | 354:e67efb2aab0e | 122 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
mbed_official | 354:e67efb2aab0e | 123 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
mbed_official | 354:e67efb2aab0e | 124 | * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
mbed_official | 354:e67efb2aab0e | 125 | * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
mbed_official | 354:e67efb2aab0e | 126 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
mbed_official | 354:e67efb2aab0e | 127 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
mbed_official | 354:e67efb2aab0e | 128 | * |
mbed_official | 354:e67efb2aab0e | 129 | ****************************************************************************** |
mbed_official | 354:e67efb2aab0e | 130 | */ |
mbed_official | 354:e67efb2aab0e | 131 | |
mbed_official | 354:e67efb2aab0e | 132 | /* Includes ------------------------------------------------------------------*/ |
mbed_official | 354:e67efb2aab0e | 133 | #include "stm32l1xx_hal.h" |
mbed_official | 354:e67efb2aab0e | 134 | |
mbed_official | 354:e67efb2aab0e | 135 | /** @addtogroup STM32L1xx_HAL_Driver |
mbed_official | 354:e67efb2aab0e | 136 | * @{ |
mbed_official | 354:e67efb2aab0e | 137 | */ |
mbed_official | 354:e67efb2aab0e | 138 | |
mbed_official | 354:e67efb2aab0e | 139 | /** @defgroup RTC RTC |
mbed_official | 354:e67efb2aab0e | 140 | * @brief RTC HAL module driver |
mbed_official | 354:e67efb2aab0e | 141 | * @{ |
mbed_official | 354:e67efb2aab0e | 142 | */ |
mbed_official | 354:e67efb2aab0e | 143 | |
mbed_official | 354:e67efb2aab0e | 144 | #ifdef HAL_RTC_MODULE_ENABLED |
mbed_official | 354:e67efb2aab0e | 145 | |
mbed_official | 354:e67efb2aab0e | 146 | /* Private typedef -----------------------------------------------------------*/ |
mbed_official | 354:e67efb2aab0e | 147 | /* Private define ------------------------------------------------------------*/ |
mbed_official | 354:e67efb2aab0e | 148 | /* Private macro -------------------------------------------------------------*/ |
mbed_official | 354:e67efb2aab0e | 149 | /* Private variables ---------------------------------------------------------*/ |
mbed_official | 354:e67efb2aab0e | 150 | /* Private function prototypes -----------------------------------------------*/ |
mbed_official | 354:e67efb2aab0e | 151 | /* Private functions ---------------------------------------------------------*/ |
mbed_official | 354:e67efb2aab0e | 152 | /** @defgroup RTC_Exported_Functions RTC Exported Functions |
mbed_official | 354:e67efb2aab0e | 153 | * @{ |
mbed_official | 354:e67efb2aab0e | 154 | */ |
mbed_official | 354:e67efb2aab0e | 155 | |
mbed_official | 354:e67efb2aab0e | 156 | /** @defgroup RTC_Exported_Functions_Group1 Initialization and de-initialization functions |
mbed_official | 354:e67efb2aab0e | 157 | * @brief Initialization and Configuration functions |
mbed_official | 354:e67efb2aab0e | 158 | * |
mbed_official | 354:e67efb2aab0e | 159 | @verbatim |
mbed_official | 354:e67efb2aab0e | 160 | =============================================================================== |
mbed_official | 354:e67efb2aab0e | 161 | ##### Initialization and de-initialization functions ##### |
mbed_official | 354:e67efb2aab0e | 162 | =============================================================================== |
mbed_official | 354:e67efb2aab0e | 163 | [..] This section provides functions allowing to initialize and configure the |
mbed_official | 354:e67efb2aab0e | 164 | RTC Prescaler (Synchronous and Asynchronous), RTC Hour format, disable |
mbed_official | 354:e67efb2aab0e | 165 | RTC registers Write protection, enter and exit the RTC initialization mode, |
mbed_official | 354:e67efb2aab0e | 166 | RTC registers synchronization check and reference clock detection enable. |
mbed_official | 354:e67efb2aab0e | 167 | (#) The RTC Prescaler is programmed to generate the RTC 1Hz time base. |
mbed_official | 354:e67efb2aab0e | 168 | It is split into 2 programmable prescalers to minimize power consumption. |
mbed_official | 354:e67efb2aab0e | 169 | (++) A 7-bit asynchronous prescaler and a 13-bit synchronous prescaler. |
mbed_official | 354:e67efb2aab0e | 170 | (++) When both prescalers are used, it is recommended to configure the |
mbed_official | 354:e67efb2aab0e | 171 | asynchronous prescaler to a high value to minimize power consumption. |
mbed_official | 354:e67efb2aab0e | 172 | (#) All RTC registers are Write protected. Writing to the RTC registers |
mbed_official | 354:e67efb2aab0e | 173 | is enabled by writing a key into the Write Protection register, RTC_WPR. |
mbed_official | 354:e67efb2aab0e | 174 | (#) To configure the RTC Calendar, user application should enter |
mbed_official | 354:e67efb2aab0e | 175 | initialization mode. In this mode, the calendar counter is stopped |
mbed_official | 354:e67efb2aab0e | 176 | and its value can be updated. When the initialization sequence is |
mbed_official | 354:e67efb2aab0e | 177 | complete, the calendar restarts counting after 4 RTCCLK cycles. |
mbed_official | 354:e67efb2aab0e | 178 | (#) To read the calendar through the shadow registers after Calendar |
mbed_official | 354:e67efb2aab0e | 179 | initialization, calendar update or after wakeup from low power modes |
mbed_official | 354:e67efb2aab0e | 180 | the software must first clear the RSF flag. The software must then |
mbed_official | 354:e67efb2aab0e | 181 | wait until it is set again before reading the calendar, which means |
mbed_official | 354:e67efb2aab0e | 182 | that the calendar registers have been correctly copied into the |
mbed_official | 354:e67efb2aab0e | 183 | RTC_TR and RTC_DR shadow registers.The HAL_RTC_WaitForSynchro() function |
mbed_official | 354:e67efb2aab0e | 184 | implements the above software sequence (RSF clear and RSF check). |
mbed_official | 354:e67efb2aab0e | 185 | |
mbed_official | 354:e67efb2aab0e | 186 | @endverbatim |
mbed_official | 354:e67efb2aab0e | 187 | * @{ |
mbed_official | 354:e67efb2aab0e | 188 | */ |
mbed_official | 354:e67efb2aab0e | 189 | |
mbed_official | 354:e67efb2aab0e | 190 | /** |
mbed_official | 354:e67efb2aab0e | 191 | * @brief Initializes the RTC peripheral |
mbed_official | 354:e67efb2aab0e | 192 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 193 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 194 | * @retval HAL status |
mbed_official | 354:e67efb2aab0e | 195 | */ |
mbed_official | 354:e67efb2aab0e | 196 | HAL_StatusTypeDef HAL_RTC_Init(RTC_HandleTypeDef *hrtc) |
mbed_official | 354:e67efb2aab0e | 197 | { |
mbed_official | 354:e67efb2aab0e | 198 | /* Check the RTC peripheral state */ |
mbed_official | 354:e67efb2aab0e | 199 | if(hrtc == HAL_NULL) |
mbed_official | 354:e67efb2aab0e | 200 | { |
mbed_official | 354:e67efb2aab0e | 201 | return HAL_ERROR; |
mbed_official | 354:e67efb2aab0e | 202 | } |
mbed_official | 354:e67efb2aab0e | 203 | |
mbed_official | 354:e67efb2aab0e | 204 | /* Check the parameters */ |
mbed_official | 354:e67efb2aab0e | 205 | assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance)); |
mbed_official | 354:e67efb2aab0e | 206 | assert_param(IS_RTC_HOUR_FORMAT(hrtc->Init.HourFormat)); |
mbed_official | 354:e67efb2aab0e | 207 | assert_param(IS_RTC_ASYNCH_PREDIV(hrtc->Init.AsynchPrediv)); |
mbed_official | 354:e67efb2aab0e | 208 | assert_param(IS_RTC_SYNCH_PREDIV(hrtc->Init.SynchPrediv)); |
mbed_official | 354:e67efb2aab0e | 209 | assert_param(IS_RTC_OUTPUT(hrtc->Init.OutPut)); |
mbed_official | 354:e67efb2aab0e | 210 | assert_param(IS_RTC_OUTPUT_POL(hrtc->Init.OutPutPolarity)); |
mbed_official | 354:e67efb2aab0e | 211 | assert_param(IS_RTC_OUTPUT_TYPE(hrtc->Init.OutPutType)); |
mbed_official | 354:e67efb2aab0e | 212 | |
mbed_official | 354:e67efb2aab0e | 213 | if(hrtc->State == HAL_RTC_STATE_RESET) |
mbed_official | 354:e67efb2aab0e | 214 | { |
mbed_official | 354:e67efb2aab0e | 215 | /* Initialize RTC MSP */ |
mbed_official | 354:e67efb2aab0e | 216 | HAL_RTC_MspInit(hrtc); |
mbed_official | 354:e67efb2aab0e | 217 | } |
mbed_official | 354:e67efb2aab0e | 218 | |
mbed_official | 354:e67efb2aab0e | 219 | /* Set RTC state */ |
mbed_official | 354:e67efb2aab0e | 220 | hrtc->State = HAL_RTC_STATE_BUSY; |
mbed_official | 354:e67efb2aab0e | 221 | |
mbed_official | 354:e67efb2aab0e | 222 | /* Disable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 223 | __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 224 | |
mbed_official | 354:e67efb2aab0e | 225 | /* Set Initialization mode */ |
mbed_official | 354:e67efb2aab0e | 226 | if(RTC_EnterInitMode(hrtc) != HAL_OK) |
mbed_official | 354:e67efb2aab0e | 227 | { |
mbed_official | 354:e67efb2aab0e | 228 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 229 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 230 | |
mbed_official | 354:e67efb2aab0e | 231 | /* Set RTC state */ |
mbed_official | 354:e67efb2aab0e | 232 | hrtc->State = HAL_RTC_STATE_ERROR; |
mbed_official | 354:e67efb2aab0e | 233 | |
mbed_official | 354:e67efb2aab0e | 234 | return HAL_ERROR; |
mbed_official | 354:e67efb2aab0e | 235 | } |
mbed_official | 354:e67efb2aab0e | 236 | else |
mbed_official | 354:e67efb2aab0e | 237 | { |
mbed_official | 354:e67efb2aab0e | 238 | /* Clear RTC_CR FMT, OSEL and POL Bits */ |
mbed_official | 354:e67efb2aab0e | 239 | hrtc->Instance->CR &= ((uint32_t)~(RTC_CR_FMT | RTC_CR_OSEL | RTC_CR_POL)); |
mbed_official | 354:e67efb2aab0e | 240 | /* Set RTC_CR register */ |
mbed_official | 354:e67efb2aab0e | 241 | hrtc->Instance->CR |= (uint32_t)(hrtc->Init.HourFormat | hrtc->Init.OutPut | hrtc->Init.OutPutPolarity); |
mbed_official | 354:e67efb2aab0e | 242 | |
mbed_official | 354:e67efb2aab0e | 243 | /* Configure the RTC PRER */ |
mbed_official | 354:e67efb2aab0e | 244 | hrtc->Instance->PRER = (uint32_t)(hrtc->Init.SynchPrediv); |
mbed_official | 354:e67efb2aab0e | 245 | hrtc->Instance->PRER |= (uint32_t)(hrtc->Init.AsynchPrediv << 16); |
mbed_official | 354:e67efb2aab0e | 246 | |
mbed_official | 354:e67efb2aab0e | 247 | /* Exit Initialization mode */ |
mbed_official | 354:e67efb2aab0e | 248 | hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT; |
mbed_official | 354:e67efb2aab0e | 249 | |
mbed_official | 354:e67efb2aab0e | 250 | hrtc->Instance->TAFCR &= (uint32_t)~RTC_TAFCR_ALARMOUTTYPE; |
mbed_official | 354:e67efb2aab0e | 251 | hrtc->Instance->TAFCR |= (uint32_t)(hrtc->Init.OutPutType); |
mbed_official | 354:e67efb2aab0e | 252 | |
mbed_official | 354:e67efb2aab0e | 253 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 254 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 255 | |
mbed_official | 354:e67efb2aab0e | 256 | /* Set RTC state */ |
mbed_official | 354:e67efb2aab0e | 257 | hrtc->State = HAL_RTC_STATE_READY; |
mbed_official | 354:e67efb2aab0e | 258 | |
mbed_official | 354:e67efb2aab0e | 259 | return HAL_OK; |
mbed_official | 354:e67efb2aab0e | 260 | } |
mbed_official | 354:e67efb2aab0e | 261 | } |
mbed_official | 354:e67efb2aab0e | 262 | |
mbed_official | 354:e67efb2aab0e | 263 | /** |
mbed_official | 354:e67efb2aab0e | 264 | * @brief DeInitializes the RTC peripheral |
mbed_official | 354:e67efb2aab0e | 265 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 266 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 267 | * @note This function doesn't reset the RTC Backup Data registers. |
mbed_official | 354:e67efb2aab0e | 268 | * @retval HAL status |
mbed_official | 354:e67efb2aab0e | 269 | */ |
mbed_official | 354:e67efb2aab0e | 270 | __weak HAL_StatusTypeDef HAL_RTC_DeInit(RTC_HandleTypeDef *hrtc) |
mbed_official | 354:e67efb2aab0e | 271 | { |
mbed_official | 354:e67efb2aab0e | 272 | /* Note : This function is defined into this file for library reference. */ |
mbed_official | 354:e67efb2aab0e | 273 | /* Function content is located into file stm32l1xx_hal_rtc_ex.c */ |
mbed_official | 354:e67efb2aab0e | 274 | |
mbed_official | 354:e67efb2aab0e | 275 | /* Return function status */ |
mbed_official | 354:e67efb2aab0e | 276 | return HAL_ERROR; |
mbed_official | 354:e67efb2aab0e | 277 | } |
mbed_official | 354:e67efb2aab0e | 278 | |
mbed_official | 354:e67efb2aab0e | 279 | /** |
mbed_official | 354:e67efb2aab0e | 280 | * @brief Initializes the RTC MSP. |
mbed_official | 354:e67efb2aab0e | 281 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 282 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 283 | * @retval None |
mbed_official | 354:e67efb2aab0e | 284 | */ |
mbed_official | 354:e67efb2aab0e | 285 | __weak void HAL_RTC_MspInit(RTC_HandleTypeDef* hrtc) |
mbed_official | 354:e67efb2aab0e | 286 | { |
mbed_official | 354:e67efb2aab0e | 287 | /* NOTE : This function Should not be modified, when the callback is needed, |
mbed_official | 354:e67efb2aab0e | 288 | the HAL_RTC_MspInit could be implemented in the user file |
mbed_official | 354:e67efb2aab0e | 289 | */ |
mbed_official | 354:e67efb2aab0e | 290 | } |
mbed_official | 354:e67efb2aab0e | 291 | |
mbed_official | 354:e67efb2aab0e | 292 | /** |
mbed_official | 354:e67efb2aab0e | 293 | * @brief DeInitializes the RTC MSP. |
mbed_official | 354:e67efb2aab0e | 294 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 295 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 296 | * @retval None |
mbed_official | 354:e67efb2aab0e | 297 | */ |
mbed_official | 354:e67efb2aab0e | 298 | __weak void HAL_RTC_MspDeInit(RTC_HandleTypeDef* hrtc) |
mbed_official | 354:e67efb2aab0e | 299 | { |
mbed_official | 354:e67efb2aab0e | 300 | /* NOTE : This function Should not be modified, when the callback is needed, |
mbed_official | 354:e67efb2aab0e | 301 | the HAL_RTC_MspDeInit could be implemented in the user file |
mbed_official | 354:e67efb2aab0e | 302 | */ |
mbed_official | 354:e67efb2aab0e | 303 | } |
mbed_official | 354:e67efb2aab0e | 304 | |
mbed_official | 354:e67efb2aab0e | 305 | /** |
mbed_official | 354:e67efb2aab0e | 306 | * @} |
mbed_official | 354:e67efb2aab0e | 307 | */ |
mbed_official | 354:e67efb2aab0e | 308 | |
mbed_official | 354:e67efb2aab0e | 309 | /** @defgroup RTC_Exported_Functions_Group2 RTC Time and Date functions |
mbed_official | 354:e67efb2aab0e | 310 | * @brief RTC Time and Date functions |
mbed_official | 354:e67efb2aab0e | 311 | * |
mbed_official | 354:e67efb2aab0e | 312 | @verbatim |
mbed_official | 354:e67efb2aab0e | 313 | =============================================================================== |
mbed_official | 354:e67efb2aab0e | 314 | ##### RTC Time and Date functions ##### |
mbed_official | 354:e67efb2aab0e | 315 | =============================================================================== |
mbed_official | 354:e67efb2aab0e | 316 | |
mbed_official | 354:e67efb2aab0e | 317 | [..] This section provides functions allowing to configure Time and Date features |
mbed_official | 354:e67efb2aab0e | 318 | |
mbed_official | 354:e67efb2aab0e | 319 | @endverbatim |
mbed_official | 354:e67efb2aab0e | 320 | * @{ |
mbed_official | 354:e67efb2aab0e | 321 | */ |
mbed_official | 354:e67efb2aab0e | 322 | |
mbed_official | 354:e67efb2aab0e | 323 | /** |
mbed_official | 354:e67efb2aab0e | 324 | * @brief Sets RTC current time. |
mbed_official | 354:e67efb2aab0e | 325 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 326 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 327 | * @param sTime: Pointer to Time structure |
mbed_official | 354:e67efb2aab0e | 328 | * @param Format: Specifies the format of the entered parameters. |
mbed_official | 354:e67efb2aab0e | 329 | * This parameter can be one of the following values: |
mbed_official | 354:e67efb2aab0e | 330 | * @arg FORMAT_BIN: Binary data format |
mbed_official | 354:e67efb2aab0e | 331 | * @arg FORMAT_BCD: BCD data format |
mbed_official | 354:e67efb2aab0e | 332 | * @retval HAL status |
mbed_official | 354:e67efb2aab0e | 333 | */ |
mbed_official | 354:e67efb2aab0e | 334 | HAL_StatusTypeDef HAL_RTC_SetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format) |
mbed_official | 354:e67efb2aab0e | 335 | { |
mbed_official | 354:e67efb2aab0e | 336 | uint32_t tmpreg = 0; |
mbed_official | 354:e67efb2aab0e | 337 | |
mbed_official | 354:e67efb2aab0e | 338 | /* Check the parameters */ |
mbed_official | 354:e67efb2aab0e | 339 | assert_param(IS_RTC_FORMAT(Format)); |
mbed_official | 354:e67efb2aab0e | 340 | assert_param(IS_RTC_DAYLIGHT_SAVING(sTime->DayLightSaving)); |
mbed_official | 354:e67efb2aab0e | 341 | assert_param(IS_RTC_STORE_OPERATION(sTime->StoreOperation)); |
mbed_official | 354:e67efb2aab0e | 342 | |
mbed_official | 354:e67efb2aab0e | 343 | /* Process Locked */ |
mbed_official | 354:e67efb2aab0e | 344 | __HAL_LOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 345 | |
mbed_official | 354:e67efb2aab0e | 346 | hrtc->State = HAL_RTC_STATE_BUSY; |
mbed_official | 354:e67efb2aab0e | 347 | |
mbed_official | 354:e67efb2aab0e | 348 | if(Format == FORMAT_BIN) |
mbed_official | 354:e67efb2aab0e | 349 | { |
mbed_official | 354:e67efb2aab0e | 350 | if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET) |
mbed_official | 354:e67efb2aab0e | 351 | { |
mbed_official | 354:e67efb2aab0e | 352 | assert_param(IS_RTC_HOUR12(sTime->Hours)); |
mbed_official | 354:e67efb2aab0e | 353 | assert_param(IS_RTC_HOURFORMAT12(sTime->TimeFormat)); |
mbed_official | 354:e67efb2aab0e | 354 | } |
mbed_official | 354:e67efb2aab0e | 355 | else |
mbed_official | 354:e67efb2aab0e | 356 | { |
mbed_official | 354:e67efb2aab0e | 357 | sTime->TimeFormat = 0x00; |
mbed_official | 354:e67efb2aab0e | 358 | assert_param(IS_RTC_HOUR24(sTime->Hours)); |
mbed_official | 354:e67efb2aab0e | 359 | } |
mbed_official | 354:e67efb2aab0e | 360 | assert_param(IS_RTC_MINUTES(sTime->Minutes)); |
mbed_official | 354:e67efb2aab0e | 361 | assert_param(IS_RTC_SECONDS(sTime->Seconds)); |
mbed_official | 354:e67efb2aab0e | 362 | |
mbed_official | 354:e67efb2aab0e | 363 | tmpreg = (uint32_t)(((uint32_t)RTC_ByteToBcd2(sTime->Hours) << 16) | \ |
mbed_official | 354:e67efb2aab0e | 364 | ((uint32_t)RTC_ByteToBcd2(sTime->Minutes) << 8) | \ |
mbed_official | 354:e67efb2aab0e | 365 | ((uint32_t)RTC_ByteToBcd2(sTime->Seconds)) | \ |
mbed_official | 354:e67efb2aab0e | 366 | (((uint32_t)sTime->TimeFormat) << 16)); |
mbed_official | 354:e67efb2aab0e | 367 | } |
mbed_official | 354:e67efb2aab0e | 368 | else |
mbed_official | 354:e67efb2aab0e | 369 | { |
mbed_official | 354:e67efb2aab0e | 370 | if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET) |
mbed_official | 354:e67efb2aab0e | 371 | { |
mbed_official | 354:e67efb2aab0e | 372 | tmpreg = RTC_Bcd2ToByte(sTime->Hours); |
mbed_official | 354:e67efb2aab0e | 373 | assert_param(IS_RTC_HOUR12(tmpreg)); |
mbed_official | 354:e67efb2aab0e | 374 | assert_param(IS_RTC_HOURFORMAT12(sTime->TimeFormat)); |
mbed_official | 354:e67efb2aab0e | 375 | } |
mbed_official | 354:e67efb2aab0e | 376 | else |
mbed_official | 354:e67efb2aab0e | 377 | { |
mbed_official | 354:e67efb2aab0e | 378 | sTime->TimeFormat = 0x00; |
mbed_official | 354:e67efb2aab0e | 379 | assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sTime->Hours))); |
mbed_official | 354:e67efb2aab0e | 380 | } |
mbed_official | 354:e67efb2aab0e | 381 | assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sTime->Minutes))); |
mbed_official | 354:e67efb2aab0e | 382 | assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sTime->Seconds))); |
mbed_official | 354:e67efb2aab0e | 383 | tmpreg = (((uint32_t)(sTime->Hours) << 16) | \ |
mbed_official | 354:e67efb2aab0e | 384 | ((uint32_t)(sTime->Minutes) << 8) | \ |
mbed_official | 354:e67efb2aab0e | 385 | ((uint32_t)sTime->Seconds) | \ |
mbed_official | 354:e67efb2aab0e | 386 | ((uint32_t)(sTime->TimeFormat) << 16)); |
mbed_official | 354:e67efb2aab0e | 387 | } |
mbed_official | 354:e67efb2aab0e | 388 | |
mbed_official | 354:e67efb2aab0e | 389 | /* Disable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 390 | __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 391 | |
mbed_official | 354:e67efb2aab0e | 392 | /* Set Initialization mode */ |
mbed_official | 354:e67efb2aab0e | 393 | if(RTC_EnterInitMode(hrtc) != HAL_OK) |
mbed_official | 354:e67efb2aab0e | 394 | { |
mbed_official | 354:e67efb2aab0e | 395 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 396 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 397 | |
mbed_official | 354:e67efb2aab0e | 398 | /* Set RTC state */ |
mbed_official | 354:e67efb2aab0e | 399 | hrtc->State = HAL_RTC_STATE_ERROR; |
mbed_official | 354:e67efb2aab0e | 400 | |
mbed_official | 354:e67efb2aab0e | 401 | /* Process Unlocked */ |
mbed_official | 354:e67efb2aab0e | 402 | __HAL_UNLOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 403 | |
mbed_official | 354:e67efb2aab0e | 404 | return HAL_ERROR; |
mbed_official | 354:e67efb2aab0e | 405 | } |
mbed_official | 354:e67efb2aab0e | 406 | else |
mbed_official | 354:e67efb2aab0e | 407 | { |
mbed_official | 354:e67efb2aab0e | 408 | /* Set the RTC_TR register */ |
mbed_official | 354:e67efb2aab0e | 409 | hrtc->Instance->TR = (uint32_t)(tmpreg & RTC_TR_RESERVED_MASK); |
mbed_official | 354:e67efb2aab0e | 410 | |
mbed_official | 354:e67efb2aab0e | 411 | /* Clear the bits to be configured */ |
mbed_official | 354:e67efb2aab0e | 412 | hrtc->Instance->CR &= (uint32_t)~RTC_CR_BCK; |
mbed_official | 354:e67efb2aab0e | 413 | |
mbed_official | 354:e67efb2aab0e | 414 | /* Configure the RTC_CR register */ |
mbed_official | 354:e67efb2aab0e | 415 | hrtc->Instance->CR |= (uint32_t)(sTime->DayLightSaving | sTime->StoreOperation); |
mbed_official | 354:e67efb2aab0e | 416 | |
mbed_official | 354:e67efb2aab0e | 417 | /* Exit Initialization mode */ |
mbed_official | 354:e67efb2aab0e | 418 | hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT; |
mbed_official | 354:e67efb2aab0e | 419 | |
mbed_official | 354:e67efb2aab0e | 420 | /* Wait for synchro */ |
mbed_official | 354:e67efb2aab0e | 421 | if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK) |
mbed_official | 354:e67efb2aab0e | 422 | { |
mbed_official | 354:e67efb2aab0e | 423 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 424 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 425 | |
mbed_official | 354:e67efb2aab0e | 426 | hrtc->State = HAL_RTC_STATE_ERROR; |
mbed_official | 354:e67efb2aab0e | 427 | |
mbed_official | 354:e67efb2aab0e | 428 | /* Process Unlocked */ |
mbed_official | 354:e67efb2aab0e | 429 | __HAL_UNLOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 430 | |
mbed_official | 354:e67efb2aab0e | 431 | return HAL_ERROR; |
mbed_official | 354:e67efb2aab0e | 432 | } |
mbed_official | 354:e67efb2aab0e | 433 | |
mbed_official | 354:e67efb2aab0e | 434 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 435 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 436 | |
mbed_official | 354:e67efb2aab0e | 437 | hrtc->State = HAL_RTC_STATE_READY; |
mbed_official | 354:e67efb2aab0e | 438 | |
mbed_official | 354:e67efb2aab0e | 439 | __HAL_UNLOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 440 | |
mbed_official | 354:e67efb2aab0e | 441 | return HAL_OK; |
mbed_official | 354:e67efb2aab0e | 442 | } |
mbed_official | 354:e67efb2aab0e | 443 | } |
mbed_official | 354:e67efb2aab0e | 444 | |
mbed_official | 354:e67efb2aab0e | 445 | |
mbed_official | 354:e67efb2aab0e | 446 | /** |
mbed_official | 354:e67efb2aab0e | 447 | * @brief Sets RTC current date. |
mbed_official | 354:e67efb2aab0e | 448 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 449 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 450 | * @param sDate: Pointer to date structure |
mbed_official | 354:e67efb2aab0e | 451 | * @param Format: specifies the format of the entered parameters. |
mbed_official | 354:e67efb2aab0e | 452 | * This parameter can be one of the following values: |
mbed_official | 354:e67efb2aab0e | 453 | * @arg FORMAT_BIN: Binary data format |
mbed_official | 354:e67efb2aab0e | 454 | * @arg FORMAT_BCD: BCD data format |
mbed_official | 354:e67efb2aab0e | 455 | * @retval HAL status |
mbed_official | 354:e67efb2aab0e | 456 | */ |
mbed_official | 354:e67efb2aab0e | 457 | HAL_StatusTypeDef HAL_RTC_SetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format) |
mbed_official | 354:e67efb2aab0e | 458 | { |
mbed_official | 354:e67efb2aab0e | 459 | uint32_t datetmpreg = 0; |
mbed_official | 354:e67efb2aab0e | 460 | |
mbed_official | 354:e67efb2aab0e | 461 | /* Check the parameters */ |
mbed_official | 354:e67efb2aab0e | 462 | assert_param(IS_RTC_FORMAT(Format)); |
mbed_official | 354:e67efb2aab0e | 463 | |
mbed_official | 354:e67efb2aab0e | 464 | /* Process Locked */ |
mbed_official | 354:e67efb2aab0e | 465 | __HAL_LOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 466 | |
mbed_official | 354:e67efb2aab0e | 467 | hrtc->State = HAL_RTC_STATE_BUSY; |
mbed_official | 354:e67efb2aab0e | 468 | |
mbed_official | 354:e67efb2aab0e | 469 | if((Format == FORMAT_BIN) && ((sDate->Month & 0x10) == 0x10)) |
mbed_official | 354:e67efb2aab0e | 470 | { |
mbed_official | 354:e67efb2aab0e | 471 | sDate->Month = (uint8_t)((sDate->Month & (uint8_t)~(0x10)) + (uint8_t)0x0A); |
mbed_official | 354:e67efb2aab0e | 472 | } |
mbed_official | 354:e67efb2aab0e | 473 | |
mbed_official | 354:e67efb2aab0e | 474 | assert_param(IS_RTC_WEEKDAY(sDate->WeekDay)); |
mbed_official | 354:e67efb2aab0e | 475 | |
mbed_official | 354:e67efb2aab0e | 476 | if(Format == FORMAT_BIN) |
mbed_official | 354:e67efb2aab0e | 477 | { |
mbed_official | 354:e67efb2aab0e | 478 | assert_param(IS_RTC_YEAR(sDate->Year)); |
mbed_official | 354:e67efb2aab0e | 479 | assert_param(IS_RTC_MONTH(sDate->Month)); |
mbed_official | 354:e67efb2aab0e | 480 | assert_param(IS_RTC_DATE(sDate->Date)); |
mbed_official | 354:e67efb2aab0e | 481 | |
mbed_official | 354:e67efb2aab0e | 482 | datetmpreg = (((uint32_t)RTC_ByteToBcd2(sDate->Year) << 16) | \ |
mbed_official | 354:e67efb2aab0e | 483 | ((uint32_t)RTC_ByteToBcd2(sDate->Month) << 8) | \ |
mbed_official | 354:e67efb2aab0e | 484 | ((uint32_t)RTC_ByteToBcd2(sDate->Date)) | \ |
mbed_official | 354:e67efb2aab0e | 485 | ((uint32_t)sDate->WeekDay << 13)); |
mbed_official | 354:e67efb2aab0e | 486 | } |
mbed_official | 354:e67efb2aab0e | 487 | else |
mbed_official | 354:e67efb2aab0e | 488 | { |
mbed_official | 354:e67efb2aab0e | 489 | assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(sDate->Year))); |
mbed_official | 354:e67efb2aab0e | 490 | datetmpreg = RTC_Bcd2ToByte(sDate->Month); |
mbed_official | 354:e67efb2aab0e | 491 | assert_param(IS_RTC_MONTH(datetmpreg)); |
mbed_official | 354:e67efb2aab0e | 492 | datetmpreg = RTC_Bcd2ToByte(sDate->Date); |
mbed_official | 354:e67efb2aab0e | 493 | assert_param(IS_RTC_DATE(datetmpreg)); |
mbed_official | 354:e67efb2aab0e | 494 | |
mbed_official | 354:e67efb2aab0e | 495 | datetmpreg = ((((uint32_t)sDate->Year) << 16) | \ |
mbed_official | 354:e67efb2aab0e | 496 | (((uint32_t)sDate->Month) << 8) | \ |
mbed_official | 354:e67efb2aab0e | 497 | ((uint32_t)sDate->Date) | \ |
mbed_official | 354:e67efb2aab0e | 498 | (((uint32_t)sDate->WeekDay) << 13)); |
mbed_official | 354:e67efb2aab0e | 499 | } |
mbed_official | 354:e67efb2aab0e | 500 | |
mbed_official | 354:e67efb2aab0e | 501 | /* Disable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 502 | __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 503 | |
mbed_official | 354:e67efb2aab0e | 504 | /* Set Initialization mode */ |
mbed_official | 354:e67efb2aab0e | 505 | if(RTC_EnterInitMode(hrtc) != HAL_OK) |
mbed_official | 354:e67efb2aab0e | 506 | { |
mbed_official | 354:e67efb2aab0e | 507 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 508 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 509 | |
mbed_official | 354:e67efb2aab0e | 510 | /* Set RTC state*/ |
mbed_official | 354:e67efb2aab0e | 511 | hrtc->State = HAL_RTC_STATE_ERROR; |
mbed_official | 354:e67efb2aab0e | 512 | |
mbed_official | 354:e67efb2aab0e | 513 | /* Process Unlocked */ |
mbed_official | 354:e67efb2aab0e | 514 | __HAL_UNLOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 515 | |
mbed_official | 354:e67efb2aab0e | 516 | return HAL_ERROR; |
mbed_official | 354:e67efb2aab0e | 517 | } |
mbed_official | 354:e67efb2aab0e | 518 | else |
mbed_official | 354:e67efb2aab0e | 519 | { |
mbed_official | 354:e67efb2aab0e | 520 | /* Set the RTC_DR register */ |
mbed_official | 354:e67efb2aab0e | 521 | hrtc->Instance->DR = (uint32_t)(datetmpreg & RTC_DR_RESERVED_MASK); |
mbed_official | 354:e67efb2aab0e | 522 | |
mbed_official | 354:e67efb2aab0e | 523 | /* Exit Initialization mode */ |
mbed_official | 354:e67efb2aab0e | 524 | hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT; |
mbed_official | 354:e67efb2aab0e | 525 | |
mbed_official | 354:e67efb2aab0e | 526 | /* Wait for synchro */ |
mbed_official | 354:e67efb2aab0e | 527 | if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK) |
mbed_official | 354:e67efb2aab0e | 528 | { |
mbed_official | 354:e67efb2aab0e | 529 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 530 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 531 | |
mbed_official | 354:e67efb2aab0e | 532 | hrtc->State = HAL_RTC_STATE_ERROR; |
mbed_official | 354:e67efb2aab0e | 533 | |
mbed_official | 354:e67efb2aab0e | 534 | /* Process Unlocked */ |
mbed_official | 354:e67efb2aab0e | 535 | __HAL_UNLOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 536 | |
mbed_official | 354:e67efb2aab0e | 537 | return HAL_ERROR; |
mbed_official | 354:e67efb2aab0e | 538 | } |
mbed_official | 354:e67efb2aab0e | 539 | |
mbed_official | 354:e67efb2aab0e | 540 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 541 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 542 | |
mbed_official | 354:e67efb2aab0e | 543 | hrtc->State = HAL_RTC_STATE_READY ; |
mbed_official | 354:e67efb2aab0e | 544 | |
mbed_official | 354:e67efb2aab0e | 545 | /* Process Unlocked */ |
mbed_official | 354:e67efb2aab0e | 546 | __HAL_UNLOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 547 | |
mbed_official | 354:e67efb2aab0e | 548 | return HAL_OK; |
mbed_official | 354:e67efb2aab0e | 549 | } |
mbed_official | 354:e67efb2aab0e | 550 | } |
mbed_official | 354:e67efb2aab0e | 551 | |
mbed_official | 354:e67efb2aab0e | 552 | /** |
mbed_official | 354:e67efb2aab0e | 553 | * @brief Gets RTC current date. |
mbed_official | 354:e67efb2aab0e | 554 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 555 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 556 | * @param sDate: Pointer to Date structure |
mbed_official | 354:e67efb2aab0e | 557 | * @param Format: Specifies the format of the entered parameters. |
mbed_official | 354:e67efb2aab0e | 558 | * This parameter can be one of the following values: |
mbed_official | 354:e67efb2aab0e | 559 | * @arg FORMAT_BIN: Binary data format |
mbed_official | 354:e67efb2aab0e | 560 | * @arg FORMAT_BCD: BCD data format |
mbed_official | 354:e67efb2aab0e | 561 | * @retval HAL status |
mbed_official | 354:e67efb2aab0e | 562 | */ |
mbed_official | 354:e67efb2aab0e | 563 | HAL_StatusTypeDef HAL_RTC_GetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format) |
mbed_official | 354:e67efb2aab0e | 564 | { |
mbed_official | 354:e67efb2aab0e | 565 | uint32_t datetmpreg = 0; |
mbed_official | 354:e67efb2aab0e | 566 | |
mbed_official | 354:e67efb2aab0e | 567 | /* Check the parameters */ |
mbed_official | 354:e67efb2aab0e | 568 | assert_param(IS_RTC_FORMAT(Format)); |
mbed_official | 354:e67efb2aab0e | 569 | |
mbed_official | 354:e67efb2aab0e | 570 | /* Get the DR register */ |
mbed_official | 354:e67efb2aab0e | 571 | datetmpreg = (uint32_t)(hrtc->Instance->DR & RTC_DR_RESERVED_MASK); |
mbed_official | 354:e67efb2aab0e | 572 | |
mbed_official | 354:e67efb2aab0e | 573 | /* Fill the structure fields with the read parameters */ |
mbed_official | 354:e67efb2aab0e | 574 | sDate->Year = (uint8_t)((datetmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16); |
mbed_official | 354:e67efb2aab0e | 575 | sDate->Month = (uint8_t)((datetmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8); |
mbed_official | 354:e67efb2aab0e | 576 | sDate->Date = (uint8_t)(datetmpreg & (RTC_DR_DT | RTC_DR_DU)); |
mbed_official | 354:e67efb2aab0e | 577 | sDate->WeekDay = (uint8_t)((datetmpreg & (RTC_DR_WDU)) >> 13); |
mbed_official | 354:e67efb2aab0e | 578 | |
mbed_official | 354:e67efb2aab0e | 579 | /* Check the input parameters format */ |
mbed_official | 354:e67efb2aab0e | 580 | if(Format == FORMAT_BIN) |
mbed_official | 354:e67efb2aab0e | 581 | { |
mbed_official | 354:e67efb2aab0e | 582 | /* Convert the date structure parameters to Binary format */ |
mbed_official | 354:e67efb2aab0e | 583 | sDate->Year = (uint8_t)RTC_Bcd2ToByte(sDate->Year); |
mbed_official | 354:e67efb2aab0e | 584 | sDate->Month = (uint8_t)RTC_Bcd2ToByte(sDate->Month); |
mbed_official | 354:e67efb2aab0e | 585 | sDate->Date = (uint8_t)RTC_Bcd2ToByte(sDate->Date); |
mbed_official | 354:e67efb2aab0e | 586 | } |
mbed_official | 354:e67efb2aab0e | 587 | return HAL_OK; |
mbed_official | 354:e67efb2aab0e | 588 | } |
mbed_official | 354:e67efb2aab0e | 589 | |
mbed_official | 354:e67efb2aab0e | 590 | /** |
mbed_official | 354:e67efb2aab0e | 591 | * @} |
mbed_official | 354:e67efb2aab0e | 592 | */ |
mbed_official | 354:e67efb2aab0e | 593 | |
mbed_official | 354:e67efb2aab0e | 594 | /** @defgroup RTC_Exported_Functions_Group3 RTC Alarm functions |
mbed_official | 354:e67efb2aab0e | 595 | * @brief RTC Alarm functions |
mbed_official | 354:e67efb2aab0e | 596 | * |
mbed_official | 354:e67efb2aab0e | 597 | @verbatim |
mbed_official | 354:e67efb2aab0e | 598 | =============================================================================== |
mbed_official | 354:e67efb2aab0e | 599 | ##### RTC Alarm functions ##### |
mbed_official | 354:e67efb2aab0e | 600 | =============================================================================== |
mbed_official | 354:e67efb2aab0e | 601 | |
mbed_official | 354:e67efb2aab0e | 602 | [..] This section provides functions allowing to configure Alarm feature |
mbed_official | 354:e67efb2aab0e | 603 | |
mbed_official | 354:e67efb2aab0e | 604 | @endverbatim |
mbed_official | 354:e67efb2aab0e | 605 | * @{ |
mbed_official | 354:e67efb2aab0e | 606 | */ |
mbed_official | 354:e67efb2aab0e | 607 | |
mbed_official | 354:e67efb2aab0e | 608 | /** |
mbed_official | 354:e67efb2aab0e | 609 | * @brief Deactive the specified RTC Alarm |
mbed_official | 354:e67efb2aab0e | 610 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 611 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 612 | * @param Alarm: Specifies the Alarm. |
mbed_official | 354:e67efb2aab0e | 613 | * This parameter can be one of the following values: |
mbed_official | 354:e67efb2aab0e | 614 | * @arg RTC_ALARM_A: AlarmA |
mbed_official | 354:e67efb2aab0e | 615 | * @arg RTC_ALARM_B: AlarmB |
mbed_official | 354:e67efb2aab0e | 616 | * @retval HAL status |
mbed_official | 354:e67efb2aab0e | 617 | */ |
mbed_official | 354:e67efb2aab0e | 618 | HAL_StatusTypeDef HAL_RTC_DeactivateAlarm(RTC_HandleTypeDef *hrtc, uint32_t Alarm) |
mbed_official | 354:e67efb2aab0e | 619 | { |
mbed_official | 354:e67efb2aab0e | 620 | uint32_t tickstart = 0; |
mbed_official | 354:e67efb2aab0e | 621 | |
mbed_official | 354:e67efb2aab0e | 622 | /* Check the parameters */ |
mbed_official | 354:e67efb2aab0e | 623 | assert_param(IS_ALARM(Alarm)); |
mbed_official | 354:e67efb2aab0e | 624 | |
mbed_official | 354:e67efb2aab0e | 625 | /* Process Locked */ |
mbed_official | 354:e67efb2aab0e | 626 | __HAL_LOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 627 | |
mbed_official | 354:e67efb2aab0e | 628 | hrtc->State = HAL_RTC_STATE_BUSY; |
mbed_official | 354:e67efb2aab0e | 629 | |
mbed_official | 354:e67efb2aab0e | 630 | /* Disable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 631 | __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 632 | |
mbed_official | 354:e67efb2aab0e | 633 | if(Alarm == RTC_ALARM_A) |
mbed_official | 354:e67efb2aab0e | 634 | { |
mbed_official | 354:e67efb2aab0e | 635 | /* AlarmA */ |
mbed_official | 354:e67efb2aab0e | 636 | __HAL_RTC_ALARMA_DISABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 637 | |
mbed_official | 354:e67efb2aab0e | 638 | /* In case of interrupt mode is used, the interrupt source must disabled */ |
mbed_official | 354:e67efb2aab0e | 639 | __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA); |
mbed_official | 354:e67efb2aab0e | 640 | |
mbed_official | 354:e67efb2aab0e | 641 | tickstart = HAL_GetTick(); |
mbed_official | 354:e67efb2aab0e | 642 | |
mbed_official | 354:e67efb2aab0e | 643 | /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */ |
mbed_official | 354:e67efb2aab0e | 644 | while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET) |
mbed_official | 354:e67efb2aab0e | 645 | { |
mbed_official | 354:e67efb2aab0e | 646 | if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE) |
mbed_official | 354:e67efb2aab0e | 647 | { |
mbed_official | 354:e67efb2aab0e | 648 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 649 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 650 | |
mbed_official | 354:e67efb2aab0e | 651 | hrtc->State = HAL_RTC_STATE_TIMEOUT; |
mbed_official | 354:e67efb2aab0e | 652 | |
mbed_official | 354:e67efb2aab0e | 653 | /* Process Unlocked */ |
mbed_official | 354:e67efb2aab0e | 654 | __HAL_UNLOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 655 | |
mbed_official | 354:e67efb2aab0e | 656 | return HAL_TIMEOUT; |
mbed_official | 354:e67efb2aab0e | 657 | } |
mbed_official | 354:e67efb2aab0e | 658 | } |
mbed_official | 354:e67efb2aab0e | 659 | } |
mbed_official | 354:e67efb2aab0e | 660 | else |
mbed_official | 354:e67efb2aab0e | 661 | { |
mbed_official | 354:e67efb2aab0e | 662 | /* AlarmB */ |
mbed_official | 354:e67efb2aab0e | 663 | __HAL_RTC_ALARMB_DISABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 664 | |
mbed_official | 354:e67efb2aab0e | 665 | /* In case of interrupt mode is used, the interrupt source must disabled */ |
mbed_official | 354:e67efb2aab0e | 666 | __HAL_RTC_ALARM_DISABLE_IT(hrtc,RTC_IT_ALRB); |
mbed_official | 354:e67efb2aab0e | 667 | |
mbed_official | 354:e67efb2aab0e | 668 | tickstart = HAL_GetTick(); |
mbed_official | 354:e67efb2aab0e | 669 | |
mbed_official | 354:e67efb2aab0e | 670 | /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */ |
mbed_official | 354:e67efb2aab0e | 671 | while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET) |
mbed_official | 354:e67efb2aab0e | 672 | { |
mbed_official | 354:e67efb2aab0e | 673 | if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE) |
mbed_official | 354:e67efb2aab0e | 674 | { |
mbed_official | 354:e67efb2aab0e | 675 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 676 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 677 | |
mbed_official | 354:e67efb2aab0e | 678 | hrtc->State = HAL_RTC_STATE_TIMEOUT; |
mbed_official | 354:e67efb2aab0e | 679 | |
mbed_official | 354:e67efb2aab0e | 680 | /* Process Unlocked */ |
mbed_official | 354:e67efb2aab0e | 681 | __HAL_UNLOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 682 | |
mbed_official | 354:e67efb2aab0e | 683 | return HAL_TIMEOUT; |
mbed_official | 354:e67efb2aab0e | 684 | } |
mbed_official | 354:e67efb2aab0e | 685 | } |
mbed_official | 354:e67efb2aab0e | 686 | } |
mbed_official | 354:e67efb2aab0e | 687 | /* Enable the write protection for RTC registers */ |
mbed_official | 354:e67efb2aab0e | 688 | __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); |
mbed_official | 354:e67efb2aab0e | 689 | |
mbed_official | 354:e67efb2aab0e | 690 | hrtc->State = HAL_RTC_STATE_READY; |
mbed_official | 354:e67efb2aab0e | 691 | |
mbed_official | 354:e67efb2aab0e | 692 | /* Process Unlocked */ |
mbed_official | 354:e67efb2aab0e | 693 | __HAL_UNLOCK(hrtc); |
mbed_official | 354:e67efb2aab0e | 694 | |
mbed_official | 354:e67efb2aab0e | 695 | return HAL_OK; |
mbed_official | 354:e67efb2aab0e | 696 | } |
mbed_official | 354:e67efb2aab0e | 697 | |
mbed_official | 354:e67efb2aab0e | 698 | /** |
mbed_official | 354:e67efb2aab0e | 699 | * @brief This function handles Alarm interrupt request. |
mbed_official | 354:e67efb2aab0e | 700 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 701 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 702 | * @retval None |
mbed_official | 354:e67efb2aab0e | 703 | */ |
mbed_official | 354:e67efb2aab0e | 704 | void HAL_RTC_AlarmIRQHandler(RTC_HandleTypeDef* hrtc) |
mbed_official | 354:e67efb2aab0e | 705 | { |
mbed_official | 354:e67efb2aab0e | 706 | if(__HAL_RTC_ALARM_GET_IT(hrtc, RTC_IT_ALRA)) |
mbed_official | 354:e67efb2aab0e | 707 | { |
mbed_official | 354:e67efb2aab0e | 708 | /* Get the status of the Interrupt */ |
mbed_official | 354:e67efb2aab0e | 709 | if((uint32_t)(hrtc->Instance->CR & RTC_IT_ALRA) != (uint32_t)RESET) |
mbed_official | 354:e67efb2aab0e | 710 | { |
mbed_official | 354:e67efb2aab0e | 711 | /* AlarmA callback */ |
mbed_official | 354:e67efb2aab0e | 712 | HAL_RTC_AlarmAEventCallback(hrtc); |
mbed_official | 354:e67efb2aab0e | 713 | |
mbed_official | 354:e67efb2aab0e | 714 | /* Clear the Alarm interrupt pending bit */ |
mbed_official | 354:e67efb2aab0e | 715 | __HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRAF); |
mbed_official | 354:e67efb2aab0e | 716 | } |
mbed_official | 354:e67efb2aab0e | 717 | } |
mbed_official | 354:e67efb2aab0e | 718 | |
mbed_official | 354:e67efb2aab0e | 719 | if(__HAL_RTC_ALARM_GET_IT(hrtc, RTC_IT_ALRB)) |
mbed_official | 354:e67efb2aab0e | 720 | { |
mbed_official | 354:e67efb2aab0e | 721 | /* Get the status of the Interrupt */ |
mbed_official | 354:e67efb2aab0e | 722 | if((uint32_t)(hrtc->Instance->CR & RTC_IT_ALRB) != (uint32_t)RESET) |
mbed_official | 354:e67efb2aab0e | 723 | { |
mbed_official | 354:e67efb2aab0e | 724 | /* AlarmB callback */ |
mbed_official | 354:e67efb2aab0e | 725 | HAL_RTCEx_AlarmBEventCallback(hrtc); |
mbed_official | 354:e67efb2aab0e | 726 | |
mbed_official | 354:e67efb2aab0e | 727 | /* Clear the Alarm interrupt pending bit */ |
mbed_official | 354:e67efb2aab0e | 728 | __HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRBF); |
mbed_official | 354:e67efb2aab0e | 729 | } |
mbed_official | 354:e67efb2aab0e | 730 | } |
mbed_official | 354:e67efb2aab0e | 731 | |
mbed_official | 354:e67efb2aab0e | 732 | /* Clear the EXTI's line Flag for RTC Alarm */ |
mbed_official | 354:e67efb2aab0e | 733 | __HAL_RTC_CLEAR_FLAG(RTC_EXTI_LINE_ALARM_EVENT); |
mbed_official | 354:e67efb2aab0e | 734 | |
mbed_official | 354:e67efb2aab0e | 735 | /* Change RTC state */ |
mbed_official | 354:e67efb2aab0e | 736 | hrtc->State = HAL_RTC_STATE_READY; |
mbed_official | 354:e67efb2aab0e | 737 | } |
mbed_official | 354:e67efb2aab0e | 738 | |
mbed_official | 354:e67efb2aab0e | 739 | /** |
mbed_official | 354:e67efb2aab0e | 740 | * @brief Alarm A callback. |
mbed_official | 354:e67efb2aab0e | 741 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 742 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 743 | * @retval None |
mbed_official | 354:e67efb2aab0e | 744 | */ |
mbed_official | 354:e67efb2aab0e | 745 | __weak void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc) |
mbed_official | 354:e67efb2aab0e | 746 | { |
mbed_official | 354:e67efb2aab0e | 747 | /* NOTE : This function Should not be modified, when the callback is needed, |
mbed_official | 354:e67efb2aab0e | 748 | the HAL_RTC_AlarmAEventCallback could be implemented in the user file |
mbed_official | 354:e67efb2aab0e | 749 | */ |
mbed_official | 354:e67efb2aab0e | 750 | } |
mbed_official | 354:e67efb2aab0e | 751 | |
mbed_official | 354:e67efb2aab0e | 752 | /** |
mbed_official | 354:e67efb2aab0e | 753 | * @brief This function handles AlarmA Polling request. |
mbed_official | 354:e67efb2aab0e | 754 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 755 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 756 | * @param Timeout: Timeout duration |
mbed_official | 354:e67efb2aab0e | 757 | * @retval HAL status |
mbed_official | 354:e67efb2aab0e | 758 | */ |
mbed_official | 354:e67efb2aab0e | 759 | HAL_StatusTypeDef HAL_RTC_PollForAlarmAEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout) |
mbed_official | 354:e67efb2aab0e | 760 | { |
mbed_official | 354:e67efb2aab0e | 761 | |
mbed_official | 354:e67efb2aab0e | 762 | uint32_t tickstart = HAL_GetTick(); |
mbed_official | 354:e67efb2aab0e | 763 | |
mbed_official | 354:e67efb2aab0e | 764 | while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) == RESET) |
mbed_official | 354:e67efb2aab0e | 765 | { |
mbed_official | 354:e67efb2aab0e | 766 | if(Timeout != HAL_MAX_DELAY) |
mbed_official | 354:e67efb2aab0e | 767 | { |
mbed_official | 354:e67efb2aab0e | 768 | if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout)) |
mbed_official | 354:e67efb2aab0e | 769 | { |
mbed_official | 354:e67efb2aab0e | 770 | hrtc->State = HAL_RTC_STATE_TIMEOUT; |
mbed_official | 354:e67efb2aab0e | 771 | return HAL_TIMEOUT; |
mbed_official | 354:e67efb2aab0e | 772 | } |
mbed_official | 354:e67efb2aab0e | 773 | } |
mbed_official | 354:e67efb2aab0e | 774 | } |
mbed_official | 354:e67efb2aab0e | 775 | |
mbed_official | 354:e67efb2aab0e | 776 | /* Clear the Alarm interrupt pending bit */ |
mbed_official | 354:e67efb2aab0e | 777 | __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF); |
mbed_official | 354:e67efb2aab0e | 778 | |
mbed_official | 354:e67efb2aab0e | 779 | /* Change RTC state */ |
mbed_official | 354:e67efb2aab0e | 780 | hrtc->State = HAL_RTC_STATE_READY; |
mbed_official | 354:e67efb2aab0e | 781 | |
mbed_official | 354:e67efb2aab0e | 782 | return HAL_OK; |
mbed_official | 354:e67efb2aab0e | 783 | } |
mbed_official | 354:e67efb2aab0e | 784 | |
mbed_official | 354:e67efb2aab0e | 785 | /** |
mbed_official | 354:e67efb2aab0e | 786 | * @} |
mbed_official | 354:e67efb2aab0e | 787 | */ |
mbed_official | 354:e67efb2aab0e | 788 | |
mbed_official | 354:e67efb2aab0e | 789 | /** @defgroup RTC_Exported_Functions_Group5 Peripheral State functions |
mbed_official | 354:e67efb2aab0e | 790 | * @brief Peripheral State functions |
mbed_official | 354:e67efb2aab0e | 791 | * |
mbed_official | 354:e67efb2aab0e | 792 | @verbatim |
mbed_official | 354:e67efb2aab0e | 793 | =============================================================================== |
mbed_official | 354:e67efb2aab0e | 794 | ##### Peripheral State functions ##### |
mbed_official | 354:e67efb2aab0e | 795 | =============================================================================== |
mbed_official | 354:e67efb2aab0e | 796 | [..] |
mbed_official | 354:e67efb2aab0e | 797 | This subsection provides functions allowing to |
mbed_official | 354:e67efb2aab0e | 798 | (+) Get RTC state |
mbed_official | 354:e67efb2aab0e | 799 | |
mbed_official | 354:e67efb2aab0e | 800 | @endverbatim |
mbed_official | 354:e67efb2aab0e | 801 | * @{ |
mbed_official | 354:e67efb2aab0e | 802 | */ |
mbed_official | 354:e67efb2aab0e | 803 | /** |
mbed_official | 354:e67efb2aab0e | 804 | * @brief Returns the RTC state. |
mbed_official | 354:e67efb2aab0e | 805 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 806 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 807 | * @retval HAL state |
mbed_official | 354:e67efb2aab0e | 808 | */ |
mbed_official | 354:e67efb2aab0e | 809 | HAL_RTCStateTypeDef HAL_RTC_GetState(RTC_HandleTypeDef* hrtc) |
mbed_official | 354:e67efb2aab0e | 810 | { |
mbed_official | 354:e67efb2aab0e | 811 | return hrtc->State; |
mbed_official | 354:e67efb2aab0e | 812 | } |
mbed_official | 354:e67efb2aab0e | 813 | |
mbed_official | 354:e67efb2aab0e | 814 | /** |
mbed_official | 354:e67efb2aab0e | 815 | * @} |
mbed_official | 354:e67efb2aab0e | 816 | */ |
mbed_official | 354:e67efb2aab0e | 817 | |
mbed_official | 354:e67efb2aab0e | 818 | /** |
mbed_official | 354:e67efb2aab0e | 819 | * @} |
mbed_official | 354:e67efb2aab0e | 820 | */ |
mbed_official | 354:e67efb2aab0e | 821 | |
mbed_official | 354:e67efb2aab0e | 822 | /** @defgroup RTC_Internal_Functions RTC Internal function |
mbed_official | 354:e67efb2aab0e | 823 | * @{ |
mbed_official | 354:e67efb2aab0e | 824 | */ |
mbed_official | 354:e67efb2aab0e | 825 | |
mbed_official | 354:e67efb2aab0e | 826 | /** |
mbed_official | 354:e67efb2aab0e | 827 | * @brief Enters the RTC Initialization mode. |
mbed_official | 354:e67efb2aab0e | 828 | * @note The RTC Initialization mode is write protected, use the |
mbed_official | 354:e67efb2aab0e | 829 | * __HAL_RTC_WRITEPROTECTION_DISABLE() before calling this function. |
mbed_official | 354:e67efb2aab0e | 830 | * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains |
mbed_official | 354:e67efb2aab0e | 831 | * the configuration information for RTC. |
mbed_official | 354:e67efb2aab0e | 832 | * @retval HAL status |
mbed_official | 354:e67efb2aab0e | 833 | */ |
mbed_official | 354:e67efb2aab0e | 834 | HAL_StatusTypeDef RTC_EnterInitMode(RTC_HandleTypeDef* hrtc) |
mbed_official | 354:e67efb2aab0e | 835 | { |
mbed_official | 354:e67efb2aab0e | 836 | uint32_t tickstart = 0; |
mbed_official | 354:e67efb2aab0e | 837 | |
mbed_official | 354:e67efb2aab0e | 838 | /* Check if the Initialization mode is set */ |
mbed_official | 354:e67efb2aab0e | 839 | if((hrtc->Instance->ISR & RTC_ISR_INITF) == (uint32_t)RESET) |
mbed_official | 354:e67efb2aab0e | 840 | { |
mbed_official | 354:e67efb2aab0e | 841 | /* Set the Initialization mode */ |
mbed_official | 354:e67efb2aab0e | 842 | hrtc->Instance->ISR = (uint32_t)RTC_INIT_MASK; |
mbed_official | 354:e67efb2aab0e | 843 | |
mbed_official | 354:e67efb2aab0e | 844 | tickstart = HAL_GetTick(); |
mbed_official | 354:e67efb2aab0e | 845 | /* Wait till RTC is in INIT state and if Time out is reached exit */ |
mbed_official | 354:e67efb2aab0e | 846 | while((hrtc->Instance->ISR & RTC_ISR_INITF) == (uint32_t)RESET) |
mbed_official | 354:e67efb2aab0e | 847 | { |
mbed_official | 354:e67efb2aab0e | 848 | if((HAL_GetTick() - tickstart) > RTC_TIMEOUT_VALUE) |
mbed_official | 354:e67efb2aab0e | 849 | { |
mbed_official | 354:e67efb2aab0e | 850 | return HAL_TIMEOUT; |
mbed_official | 354:e67efb2aab0e | 851 | } |
mbed_official | 354:e67efb2aab0e | 852 | } |
mbed_official | 354:e67efb2aab0e | 853 | } |
mbed_official | 354:e67efb2aab0e | 854 | |
mbed_official | 354:e67efb2aab0e | 855 | return HAL_OK; |
mbed_official | 354:e67efb2aab0e | 856 | } |
mbed_official | 354:e67efb2aab0e | 857 | |
mbed_official | 354:e67efb2aab0e | 858 | /** |
mbed_official | 354:e67efb2aab0e | 859 | * @brief Converts a 2 digit decimal to BCD format. |
mbed_official | 354:e67efb2aab0e | 860 | * @param Value: Byte to be converted |
mbed_official | 354:e67efb2aab0e | 861 | * @retval Converted byte |
mbed_official | 354:e67efb2aab0e | 862 | */ |
mbed_official | 354:e67efb2aab0e | 863 | uint8_t RTC_ByteToBcd2(uint8_t Value) |
mbed_official | 354:e67efb2aab0e | 864 | { |
mbed_official | 354:e67efb2aab0e | 865 | uint32_t bcdhigh = 0; |
mbed_official | 354:e67efb2aab0e | 866 | |
mbed_official | 354:e67efb2aab0e | 867 | while(Value >= 10) |
mbed_official | 354:e67efb2aab0e | 868 | { |
mbed_official | 354:e67efb2aab0e | 869 | bcdhigh++; |
mbed_official | 354:e67efb2aab0e | 870 | Value -= 10; |
mbed_official | 354:e67efb2aab0e | 871 | } |
mbed_official | 354:e67efb2aab0e | 872 | |
mbed_official | 354:e67efb2aab0e | 873 | return ((uint8_t)(bcdhigh << 4) | Value); |
mbed_official | 354:e67efb2aab0e | 874 | } |
mbed_official | 354:e67efb2aab0e | 875 | |
mbed_official | 354:e67efb2aab0e | 876 | /** |
mbed_official | 354:e67efb2aab0e | 877 | * @brief Converts from 2 digit BCD to Binary. |
mbed_official | 354:e67efb2aab0e | 878 | * @param Value: BCD value to be converted |
mbed_official | 354:e67efb2aab0e | 879 | * @retval Converted word |
mbed_official | 354:e67efb2aab0e | 880 | */ |
mbed_official | 354:e67efb2aab0e | 881 | uint8_t RTC_Bcd2ToByte(uint8_t Value) |
mbed_official | 354:e67efb2aab0e | 882 | { |
mbed_official | 354:e67efb2aab0e | 883 | uint32_t tmp = 0; |
mbed_official | 354:e67efb2aab0e | 884 | tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10; |
mbed_official | 354:e67efb2aab0e | 885 | return (tmp + (Value & (uint8_t)0x0F)); |
mbed_official | 354:e67efb2aab0e | 886 | } |
mbed_official | 354:e67efb2aab0e | 887 | |
mbed_official | 354:e67efb2aab0e | 888 | |
mbed_official | 354:e67efb2aab0e | 889 | /** |
mbed_official | 354:e67efb2aab0e | 890 | * @} |
mbed_official | 354:e67efb2aab0e | 891 | */ |
mbed_official | 354:e67efb2aab0e | 892 | |
mbed_official | 354:e67efb2aab0e | 893 | #endif /* HAL_RTC_MODULE_ENABLED */ |
mbed_official | 354:e67efb2aab0e | 894 | /** |
mbed_official | 354:e67efb2aab0e | 895 | * @} |
mbed_official | 354:e67efb2aab0e | 896 | */ |
mbed_official | 354:e67efb2aab0e | 897 | |
mbed_official | 354:e67efb2aab0e | 898 | /** |
mbed_official | 354:e67efb2aab0e | 899 | * @} |
mbed_official | 354:e67efb2aab0e | 900 | */ |
mbed_official | 354:e67efb2aab0e | 901 | |
mbed_official | 354:e67efb2aab0e | 902 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |