mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_rtc_ex.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
394:83f921546702 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 354:e67efb2aab0e 1 /**
mbed_official 354:e67efb2aab0e 2 ******************************************************************************
mbed_official 354:e67efb2aab0e 3 * @file stm32l1xx_hal_rtc_ex.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 Extended 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) Extension peripheral:
mbed_official 354:e67efb2aab0e 10 * + RTC Time Stamp functions
mbed_official 354:e67efb2aab0e 11 * + RTC Tamper functions
mbed_official 354:e67efb2aab0e 12 * + RTC Wake-up functions
mbed_official 354:e67efb2aab0e 13 * + Extension Control functions
mbed_official 354:e67efb2aab0e 14 * + Extension RTC features functions
mbed_official 354:e67efb2aab0e 15 *
mbed_official 354:e67efb2aab0e 16 @verbatim
mbed_official 354:e67efb2aab0e 17 ==============================================================================
mbed_official 354:e67efb2aab0e 18 ##### How to use this driver #####
mbed_official 354:e67efb2aab0e 19 ==============================================================================
mbed_official 354:e67efb2aab0e 20 [..]
mbed_official 354:e67efb2aab0e 21 (+) Enable the RTC domain access.
mbed_official 354:e67efb2aab0e 22 (+) Configure the RTC Prescaler (Asynchronous and Synchronous) and RTC hour
mbed_official 354:e67efb2aab0e 23 format using the HAL_RTC_Init() function.
mbed_official 354:e67efb2aab0e 24
mbed_official 354:e67efb2aab0e 25 *** RTC Wakeup configuration ***
mbed_official 354:e67efb2aab0e 26 ================================
mbed_official 354:e67efb2aab0e 27 [..]
mbed_official 354:e67efb2aab0e 28 (+) To configure the RTC Wakeup Clock source and Counter use the HAL_RTCEx_SetWakeUpTimer()
mbed_official 354:e67efb2aab0e 29 function. You can also configure the RTC Wakeup timer with interrupt mode
mbed_official 354:e67efb2aab0e 30 using the HAL_RTCEx_SetWakeUpTimer_IT() function.
mbed_official 354:e67efb2aab0e 31 (+) To read the RTC WakeUp Counter register, use the HAL_RTCEx_GetWakeUpTimer()
mbed_official 354:e67efb2aab0e 32 function.
mbed_official 354:e67efb2aab0e 33
mbed_official 354:e67efb2aab0e 34 *** TimeStamp configuration ***
mbed_official 354:e67efb2aab0e 35 ===============================
mbed_official 354:e67efb2aab0e 36 [..]
mbed_official 354:e67efb2aab0e 37 (+) Configure the RTC_AFx trigger and enable the RTC TimeStamp using the
mbed_official 354:e67efb2aab0e 38 HAL_RTCEx_SetTimeStamp() function. You can also configure the RTC TimeStamp with
mbed_official 354:e67efb2aab0e 39 interrupt mode using the HAL_RTCEx_SetTimeStamp_IT() function.
mbed_official 354:e67efb2aab0e 40 (+) To read the RTC TimeStamp Time and Date register, use the HAL_RTCEx_GetTimeStamp()
mbed_official 354:e67efb2aab0e 41 function.
mbed_official 354:e67efb2aab0e 42 (+) The TIMESTAMP alternate function can be mapped to RTC_AF1 (PC13).
mbed_official 354:e67efb2aab0e 43
mbed_official 354:e67efb2aab0e 44 *** Tamper configuration ***
mbed_official 354:e67efb2aab0e 45 ============================
mbed_official 354:e67efb2aab0e 46 [..]
mbed_official 354:e67efb2aab0e 47 (+) Enable the RTC Tamper and configure the Tamper filter count, trigger Edge
mbed_official 354:e67efb2aab0e 48 or Level according to the Tamper filter (if equal to 0 Edge else Level)
mbed_official 354:e67efb2aab0e 49 value, sampling frequency, precharge or discharge and Pull-UP using the
mbed_official 354:e67efb2aab0e 50 HAL_RTCEx_SetTamper() function. You can configure RTC Tamper with interrupt
mbed_official 354:e67efb2aab0e 51 mode using HAL_RTCEx_SetTamper_IT() function.
mbed_official 354:e67efb2aab0e 52 (+) The TAMPER1 alternate function can be mapped to RTC_AF1 (PC13).
mbed_official 354:e67efb2aab0e 53
mbed_official 354:e67efb2aab0e 54 *** Backup Data Registers configuration ***
mbed_official 354:e67efb2aab0e 55 ===========================================
mbed_official 354:e67efb2aab0e 56 [..]
mbed_official 354:e67efb2aab0e 57 (+) To write to the RTC Backup Data registers, use the HAL_RTCEx_BKUPWrite()
mbed_official 354:e67efb2aab0e 58 function.
mbed_official 354:e67efb2aab0e 59 (+) To read the RTC Backup Data registers, use the HAL_RTCEx_BKUPRead()
mbed_official 354:e67efb2aab0e 60 function.
mbed_official 354:e67efb2aab0e 61
mbed_official 354:e67efb2aab0e 62 @endverbatim
mbed_official 354:e67efb2aab0e 63 ******************************************************************************
mbed_official 354:e67efb2aab0e 64 * @attention
mbed_official 354:e67efb2aab0e 65 *
mbed_official 354:e67efb2aab0e 66 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 354:e67efb2aab0e 67 *
mbed_official 354:e67efb2aab0e 68 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 354:e67efb2aab0e 69 * are permitted provided that the following conditions are met:
mbed_official 354:e67efb2aab0e 70 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 354:e67efb2aab0e 71 * this list of conditions and the following disclaimer.
mbed_official 354:e67efb2aab0e 72 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 354:e67efb2aab0e 73 * this list of conditions and the following disclaimer in the documentation
mbed_official 354:e67efb2aab0e 74 * and/or other materials provided with the distribution.
mbed_official 354:e67efb2aab0e 75 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 354:e67efb2aab0e 76 * may be used to endorse or promote products derived from this software
mbed_official 354:e67efb2aab0e 77 * without specific prior written permission.
mbed_official 354:e67efb2aab0e 78 *
mbed_official 354:e67efb2aab0e 79 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 354:e67efb2aab0e 80 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 354:e67efb2aab0e 81 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 354:e67efb2aab0e 82 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 354:e67efb2aab0e 83 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 354:e67efb2aab0e 84 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 354:e67efb2aab0e 85 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 354:e67efb2aab0e 86 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 354:e67efb2aab0e 87 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 354:e67efb2aab0e 88 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 354:e67efb2aab0e 89 *
mbed_official 354:e67efb2aab0e 90 ******************************************************************************
mbed_official 354:e67efb2aab0e 91 */
mbed_official 354:e67efb2aab0e 92
mbed_official 354:e67efb2aab0e 93 /* Includes ------------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 94 #include "stm32l1xx_hal.h"
mbed_official 354:e67efb2aab0e 95
mbed_official 354:e67efb2aab0e 96 /** @addtogroup STM32L1xx_HAL_Driver
mbed_official 354:e67efb2aab0e 97 * @{
mbed_official 354:e67efb2aab0e 98 */
mbed_official 354:e67efb2aab0e 99
mbed_official 354:e67efb2aab0e 100 /** @addtogroup RTC
mbed_official 354:e67efb2aab0e 101 * @{
mbed_official 354:e67efb2aab0e 102 */
mbed_official 354:e67efb2aab0e 103
mbed_official 354:e67efb2aab0e 104 #ifdef HAL_RTC_MODULE_ENABLED
mbed_official 354:e67efb2aab0e 105
mbed_official 354:e67efb2aab0e 106 /* Private typedef -----------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 107 /* Private define ------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 108 /* Private macro -------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 109 /* Private variables ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 110 /* Private function prototypes -----------------------------------------------*/
mbed_official 354:e67efb2aab0e 111 /* Private functions ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 112
mbed_official 354:e67efb2aab0e 113 /** @addtogroup RTC_Exported_Functions
mbed_official 354:e67efb2aab0e 114 * @{
mbed_official 354:e67efb2aab0e 115 */
mbed_official 354:e67efb2aab0e 116
mbed_official 354:e67efb2aab0e 117
mbed_official 354:e67efb2aab0e 118 /** @addtogroup RTC_Exported_Functions_Group1
mbed_official 354:e67efb2aab0e 119 * @{
mbed_official 354:e67efb2aab0e 120 */
mbed_official 354:e67efb2aab0e 121
mbed_official 354:e67efb2aab0e 122 /**
mbed_official 354:e67efb2aab0e 123 * @brief DeInitializes the RTC peripheral
mbed_official 354:e67efb2aab0e 124 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 125 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 126 * @note This function does not reset the RTC Backup Data registers.
mbed_official 354:e67efb2aab0e 127 * @retval HAL status
mbed_official 354:e67efb2aab0e 128 */
mbed_official 354:e67efb2aab0e 129 HAL_StatusTypeDef HAL_RTC_DeInit(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 130 {
mbed_official 354:e67efb2aab0e 131 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 132
mbed_official 354:e67efb2aab0e 133 /* Check the parameters */
mbed_official 354:e67efb2aab0e 134 assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
mbed_official 354:e67efb2aab0e 135
mbed_official 354:e67efb2aab0e 136 /* Set RTC state */
mbed_official 354:e67efb2aab0e 137 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 138
mbed_official 354:e67efb2aab0e 139 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 140 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 141
mbed_official 354:e67efb2aab0e 142 /* Set Initialization mode */
mbed_official 354:e67efb2aab0e 143 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 354:e67efb2aab0e 144 {
mbed_official 354:e67efb2aab0e 145 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 146 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 147
mbed_official 354:e67efb2aab0e 148 /* Set RTC state */
mbed_official 354:e67efb2aab0e 149 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 150
mbed_official 354:e67efb2aab0e 151 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 152 }
mbed_official 354:e67efb2aab0e 153 else
mbed_official 354:e67efb2aab0e 154 {
mbed_official 354:e67efb2aab0e 155 /* Reset TR, DR and CR registers */
mbed_official 354:e67efb2aab0e 156 hrtc->Instance->TR = (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 157 hrtc->Instance->DR = (uint32_t)0x00002101;
mbed_official 354:e67efb2aab0e 158 /* Reset All CR bits except CR[2:0] */
mbed_official 354:e67efb2aab0e 159 hrtc->Instance->CR &= (uint32_t)0x00000007;
mbed_official 354:e67efb2aab0e 160
mbed_official 354:e67efb2aab0e 161 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 162
mbed_official 354:e67efb2aab0e 163 /* Wait till WUTWF flag is set and if Time out is reached exit */
mbed_official 354:e67efb2aab0e 164 while(((hrtc->Instance->ISR) & RTC_ISR_WUTWF) == (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 165 {
mbed_official 354:e67efb2aab0e 166 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 167 {
mbed_official 354:e67efb2aab0e 168 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 169 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 170
mbed_official 354:e67efb2aab0e 171 /* Set RTC state */
mbed_official 354:e67efb2aab0e 172 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 173
mbed_official 354:e67efb2aab0e 174 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 175 }
mbed_official 354:e67efb2aab0e 176 }
mbed_official 354:e67efb2aab0e 177
mbed_official 354:e67efb2aab0e 178 /* Reset all RTC CR register bits */
mbed_official 354:e67efb2aab0e 179 hrtc->Instance->CR &= (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 180 hrtc->Instance->WUTR = (uint32_t)0x0000FFFF;
mbed_official 354:e67efb2aab0e 181 hrtc->Instance->PRER = (uint32_t)0x007F00FF;
mbed_official 354:e67efb2aab0e 182 hrtc->Instance->CALIBR = (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 183 hrtc->Instance->ALRMAR = (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 184 hrtc->Instance->ALRMBR = (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 185 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 186 hrtc->Instance->SHIFTR = (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 187 hrtc->Instance->CALR = (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 188 hrtc->Instance->ALRMASSR = (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 189 hrtc->Instance->ALRMBSSR = (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 190 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 191 /* Reset ISR register and exit initialization mode */
mbed_official 354:e67efb2aab0e 192 hrtc->Instance->ISR = (uint32_t)0x00000000;
mbed_official 354:e67efb2aab0e 193
mbed_official 354:e67efb2aab0e 194 /* Reset Tamper and alternate functions configuration register */
mbed_official 354:e67efb2aab0e 195 hrtc->Instance->TAFCR = 0x00000000;
mbed_official 354:e67efb2aab0e 196
mbed_official 354:e67efb2aab0e 197 /* Wait for synchro */
mbed_official 354:e67efb2aab0e 198 if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
mbed_official 354:e67efb2aab0e 199 {
mbed_official 354:e67efb2aab0e 200 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 201 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 202
mbed_official 354:e67efb2aab0e 203 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 204
mbed_official 354:e67efb2aab0e 205 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 206 }
mbed_official 354:e67efb2aab0e 207 }
mbed_official 354:e67efb2aab0e 208
mbed_official 354:e67efb2aab0e 209 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 210 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 211
mbed_official 354:e67efb2aab0e 212 /* De-Initialize RTC MSP */
mbed_official 354:e67efb2aab0e 213 HAL_RTC_MspDeInit(hrtc);
mbed_official 354:e67efb2aab0e 214
mbed_official 354:e67efb2aab0e 215 hrtc->State = HAL_RTC_STATE_RESET;
mbed_official 354:e67efb2aab0e 216
mbed_official 354:e67efb2aab0e 217 /* Release Lock */
mbed_official 354:e67efb2aab0e 218 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 219
mbed_official 354:e67efb2aab0e 220 return HAL_OK;
mbed_official 354:e67efb2aab0e 221 }
mbed_official 354:e67efb2aab0e 222
mbed_official 354:e67efb2aab0e 223 /**
mbed_official 354:e67efb2aab0e 224 * @}
mbed_official 354:e67efb2aab0e 225 */
mbed_official 354:e67efb2aab0e 226
mbed_official 354:e67efb2aab0e 227 /** @addtogroup RTC_Exported_Functions_Group2
mbed_official 354:e67efb2aab0e 228 * @{
mbed_official 354:e67efb2aab0e 229 */
mbed_official 354:e67efb2aab0e 230
mbed_official 354:e67efb2aab0e 231 /**
mbed_official 354:e67efb2aab0e 232 * @brief Gets RTC current time.
mbed_official 354:e67efb2aab0e 233 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 234 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 235 * @param sTime: Pointer to Time structure
mbed_official 354:e67efb2aab0e 236 * @param Format: Specifies the format of the entered parameters.
mbed_official 354:e67efb2aab0e 237 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 238 * @arg FORMAT_BIN: Binary data format
mbed_official 354:e67efb2aab0e 239 * @arg FORMAT_BCD: BCD data format
mbed_official 354:e67efb2aab0e 240 * @note Call HAL_RTC_GetDate() after HAL_RTC_GetTime() to unlock the values
mbed_official 354:e67efb2aab0e 241 * in the higher-order calendar shadow registers.
mbed_official 354:e67efb2aab0e 242 * @retval HAL status
mbed_official 354:e67efb2aab0e 243 */
mbed_official 354:e67efb2aab0e 244 HAL_StatusTypeDef HAL_RTC_GetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
mbed_official 354:e67efb2aab0e 245 {
mbed_official 354:e67efb2aab0e 246 uint32_t tmpreg = 0;
mbed_official 354:e67efb2aab0e 247
mbed_official 354:e67efb2aab0e 248 /* Check the parameters */
mbed_official 354:e67efb2aab0e 249 assert_param(IS_RTC_FORMAT(Format));
mbed_official 354:e67efb2aab0e 250
mbed_official 354:e67efb2aab0e 251 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 252 /* Get subseconds values from the correspondent registers*/
mbed_official 354:e67efb2aab0e 253 sTime->SubSeconds = (uint32_t)((hrtc->Instance->SSR) & RTC_SSR_SS);
mbed_official 354:e67efb2aab0e 254 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 255
mbed_official 354:e67efb2aab0e 256 /* Get the TR register */
mbed_official 354:e67efb2aab0e 257 tmpreg = (uint32_t)(hrtc->Instance->TR & RTC_TR_RESERVED_MASK);
mbed_official 354:e67efb2aab0e 258
mbed_official 354:e67efb2aab0e 259 /* Fill the structure fields with the read parameters */
mbed_official 354:e67efb2aab0e 260 sTime->Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16);
mbed_official 354:e67efb2aab0e 261 sTime->Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8);
mbed_official 354:e67efb2aab0e 262 sTime->Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU));
mbed_official 354:e67efb2aab0e 263 sTime->TimeFormat = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16);
mbed_official 354:e67efb2aab0e 264
mbed_official 354:e67efb2aab0e 265 /* Check the input parameters format */
mbed_official 354:e67efb2aab0e 266 if(Format == FORMAT_BIN)
mbed_official 354:e67efb2aab0e 267 {
mbed_official 354:e67efb2aab0e 268 /* Convert the time structure parameters to Binary format */
mbed_official 354:e67efb2aab0e 269 sTime->Hours = (uint8_t)RTC_Bcd2ToByte(sTime->Hours);
mbed_official 354:e67efb2aab0e 270 sTime->Minutes = (uint8_t)RTC_Bcd2ToByte(sTime->Minutes);
mbed_official 354:e67efb2aab0e 271 sTime->Seconds = (uint8_t)RTC_Bcd2ToByte(sTime->Seconds);
mbed_official 354:e67efb2aab0e 272 }
mbed_official 354:e67efb2aab0e 273
mbed_official 354:e67efb2aab0e 274 return HAL_OK;
mbed_official 354:e67efb2aab0e 275 }
mbed_official 354:e67efb2aab0e 276
mbed_official 354:e67efb2aab0e 277 /**
mbed_official 354:e67efb2aab0e 278 * @}
mbed_official 354:e67efb2aab0e 279 */
mbed_official 354:e67efb2aab0e 280
mbed_official 354:e67efb2aab0e 281 /** @addtogroup RTC_Exported_Functions_Group3
mbed_official 354:e67efb2aab0e 282 * @{
mbed_official 354:e67efb2aab0e 283 */
mbed_official 354:e67efb2aab0e 284
mbed_official 354:e67efb2aab0e 285 /**
mbed_official 354:e67efb2aab0e 286 * @brief Sets the specified RTC Alarm.
mbed_official 354:e67efb2aab0e 287 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 288 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 289 * @param sAlarm: Pointer to Alarm structure
mbed_official 354:e67efb2aab0e 290 * @param Format: Specifies the format of the entered parameters.
mbed_official 354:e67efb2aab0e 291 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 292 * @arg FORMAT_BIN: Binary data format
mbed_official 354:e67efb2aab0e 293 * @arg FORMAT_BCD: BCD data format
mbed_official 354:e67efb2aab0e 294 * @retval HAL status
mbed_official 354:e67efb2aab0e 295 */
mbed_official 354:e67efb2aab0e 296 HAL_StatusTypeDef HAL_RTC_SetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
mbed_official 354:e67efb2aab0e 297 {
mbed_official 354:e67efb2aab0e 298 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 299 uint32_t tmpreg = 0;
mbed_official 354:e67efb2aab0e 300
mbed_official 354:e67efb2aab0e 301 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 302 uint32_t subsecondtmpreg = 0;
mbed_official 354:e67efb2aab0e 303 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 304
mbed_official 354:e67efb2aab0e 305 /* Check the parameters */
mbed_official 354:e67efb2aab0e 306 assert_param(IS_RTC_FORMAT(Format));
mbed_official 354:e67efb2aab0e 307 assert_param(IS_ALARM(sAlarm->Alarm));
mbed_official 354:e67efb2aab0e 308 assert_param(IS_ALARM_MASK(sAlarm->AlarmMask));
mbed_official 354:e67efb2aab0e 309 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel));
mbed_official 354:e67efb2aab0e 310 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 311 assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds));
mbed_official 354:e67efb2aab0e 312 assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask));
mbed_official 354:e67efb2aab0e 313 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 314
mbed_official 354:e67efb2aab0e 315 /* Process Locked */
mbed_official 354:e67efb2aab0e 316 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 317
mbed_official 354:e67efb2aab0e 318 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 319
mbed_official 354:e67efb2aab0e 320 if(Format == FORMAT_BIN)
mbed_official 354:e67efb2aab0e 321 {
mbed_official 354:e67efb2aab0e 322 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 323 {
mbed_official 354:e67efb2aab0e 324 assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours));
mbed_official 354:e67efb2aab0e 325 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 354:e67efb2aab0e 326 }
mbed_official 354:e67efb2aab0e 327 else
mbed_official 354:e67efb2aab0e 328 {
mbed_official 354:e67efb2aab0e 329 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 354:e67efb2aab0e 330 assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
mbed_official 354:e67efb2aab0e 331 }
mbed_official 354:e67efb2aab0e 332 assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
mbed_official 354:e67efb2aab0e 333 assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
mbed_official 354:e67efb2aab0e 334
mbed_official 354:e67efb2aab0e 335 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 354:e67efb2aab0e 336 {
mbed_official 354:e67efb2aab0e 337 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay));
mbed_official 354:e67efb2aab0e 338 }
mbed_official 354:e67efb2aab0e 339 else
mbed_official 354:e67efb2aab0e 340 {
mbed_official 354:e67efb2aab0e 341 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay));
mbed_official 354:e67efb2aab0e 342 }
mbed_official 354:e67efb2aab0e 343
mbed_official 354:e67efb2aab0e 344 tmpreg = (((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 354:e67efb2aab0e 345 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 354:e67efb2aab0e 346 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds)) | \
mbed_official 354:e67efb2aab0e 347 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 354:e67efb2aab0e 348 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 354:e67efb2aab0e 349 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 354:e67efb2aab0e 350 ((uint32_t)sAlarm->AlarmMask));
mbed_official 354:e67efb2aab0e 351 }
mbed_official 354:e67efb2aab0e 352 else
mbed_official 354:e67efb2aab0e 353 {
mbed_official 354:e67efb2aab0e 354 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 355 {
mbed_official 354:e67efb2aab0e 356 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
mbed_official 354:e67efb2aab0e 357 assert_param(IS_RTC_HOUR12(tmpreg));
mbed_official 354:e67efb2aab0e 358 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 354:e67efb2aab0e 359 }
mbed_official 354:e67efb2aab0e 360 else
mbed_official 354:e67efb2aab0e 361 {
mbed_official 354:e67efb2aab0e 362 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 354:e67efb2aab0e 363 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
mbed_official 354:e67efb2aab0e 364 }
mbed_official 354:e67efb2aab0e 365
mbed_official 354:e67efb2aab0e 366 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
mbed_official 354:e67efb2aab0e 367 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
mbed_official 354:e67efb2aab0e 368
mbed_official 354:e67efb2aab0e 369 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 354:e67efb2aab0e 370 {
mbed_official 354:e67efb2aab0e 371 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 354:e67efb2aab0e 372 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));
mbed_official 354:e67efb2aab0e 373 }
mbed_official 354:e67efb2aab0e 374 else
mbed_official 354:e67efb2aab0e 375 {
mbed_official 354:e67efb2aab0e 376 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 354:e67efb2aab0e 377 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));
mbed_official 354:e67efb2aab0e 378 }
mbed_official 354:e67efb2aab0e 379
mbed_official 354:e67efb2aab0e 380 tmpreg = (((uint32_t)(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 354:e67efb2aab0e 381 ((uint32_t)(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 354:e67efb2aab0e 382 ((uint32_t) sAlarm->AlarmTime.Seconds) | \
mbed_official 354:e67efb2aab0e 383 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 354:e67efb2aab0e 384 ((uint32_t)(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 354:e67efb2aab0e 385 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 354:e67efb2aab0e 386 ((uint32_t)sAlarm->AlarmMask));
mbed_official 354:e67efb2aab0e 387 }
mbed_official 354:e67efb2aab0e 388
mbed_official 354:e67efb2aab0e 389 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 390 /* Configure the Alarm A or Alarm B Sub Second registers */
mbed_official 354:e67efb2aab0e 391 subsecondtmpreg = (uint32_t)((uint32_t)(sAlarm->AlarmTime.SubSeconds) | (uint32_t)(sAlarm->AlarmSubSecondMask));
mbed_official 354:e67efb2aab0e 392 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 393
mbed_official 354:e67efb2aab0e 394 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 395 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 396
mbed_official 354:e67efb2aab0e 397 /* Configure the Alarm register */
mbed_official 354:e67efb2aab0e 398 if(sAlarm->Alarm == RTC_ALARM_A)
mbed_official 354:e67efb2aab0e 399 {
mbed_official 354:e67efb2aab0e 400 /* Disable the Alarm A interrupt */
mbed_official 354:e67efb2aab0e 401 __HAL_RTC_ALARMA_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 402
mbed_official 354:e67efb2aab0e 403 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 354:e67efb2aab0e 404 __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
mbed_official 354:e67efb2aab0e 405
mbed_official 354:e67efb2aab0e 406 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 407 /* Wait till RTC ALRAWF flag is set and if Time out is reached exit */
mbed_official 354:e67efb2aab0e 408 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
mbed_official 354:e67efb2aab0e 409 {
mbed_official 354:e67efb2aab0e 410 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 411 {
mbed_official 354:e67efb2aab0e 412 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 413 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 414
mbed_official 354:e67efb2aab0e 415 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 416
mbed_official 354:e67efb2aab0e 417 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 418 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 419
mbed_official 354:e67efb2aab0e 420 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 421 }
mbed_official 354:e67efb2aab0e 422 }
mbed_official 354:e67efb2aab0e 423
mbed_official 354:e67efb2aab0e 424 hrtc->Instance->ALRMAR = (uint32_t)tmpreg;
mbed_official 354:e67efb2aab0e 425 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 426 /* Configure the Alarm A Sub Second register */
mbed_official 354:e67efb2aab0e 427 hrtc->Instance->ALRMASSR = subsecondtmpreg;
mbed_official 354:e67efb2aab0e 428 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 429 /* Configure the Alarm state: Enable Alarm */
mbed_official 354:e67efb2aab0e 430 __HAL_RTC_ALARMA_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 431 }
mbed_official 354:e67efb2aab0e 432 else
mbed_official 354:e67efb2aab0e 433 {
mbed_official 354:e67efb2aab0e 434 /* Disable the Alarm B interrupt */
mbed_official 354:e67efb2aab0e 435 __HAL_RTC_ALARMB_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 436
mbed_official 354:e67efb2aab0e 437 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 354:e67efb2aab0e 438 __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRB);
mbed_official 354:e67efb2aab0e 439
mbed_official 354:e67efb2aab0e 440 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 441 /* Wait till RTC ALRBWF flag is set and if Time out is reached exit */
mbed_official 354:e67efb2aab0e 442 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
mbed_official 354:e67efb2aab0e 443 {
mbed_official 354:e67efb2aab0e 444 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 445 {
mbed_official 354:e67efb2aab0e 446 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 447 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 448
mbed_official 354:e67efb2aab0e 449 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 450
mbed_official 354:e67efb2aab0e 451 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 452 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 453
mbed_official 354:e67efb2aab0e 454 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 455 }
mbed_official 354:e67efb2aab0e 456 }
mbed_official 354:e67efb2aab0e 457
mbed_official 354:e67efb2aab0e 458 hrtc->Instance->ALRMBR = (uint32_t)tmpreg;
mbed_official 354:e67efb2aab0e 459 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 460 /* Configure the Alarm B Sub Second register */
mbed_official 354:e67efb2aab0e 461 hrtc->Instance->ALRMBSSR = subsecondtmpreg;
mbed_official 354:e67efb2aab0e 462 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 463 /* Configure the Alarm state: Enable Alarm */
mbed_official 354:e67efb2aab0e 464 __HAL_RTC_ALARMB_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 465 }
mbed_official 354:e67efb2aab0e 466
mbed_official 354:e67efb2aab0e 467 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 468 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 469
mbed_official 354:e67efb2aab0e 470 /* Change RTC state */
mbed_official 354:e67efb2aab0e 471 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 472
mbed_official 354:e67efb2aab0e 473 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 474 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 475
mbed_official 354:e67efb2aab0e 476 return HAL_OK;
mbed_official 354:e67efb2aab0e 477 }
mbed_official 354:e67efb2aab0e 478
mbed_official 354:e67efb2aab0e 479 /**
mbed_official 354:e67efb2aab0e 480 * @brief Sets the specified RTC Alarm with Interrupt
mbed_official 354:e67efb2aab0e 481 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 482 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 483 * @param sAlarm: Pointer to Alarm structure
mbed_official 354:e67efb2aab0e 484 * @param Format: Specifies the format of the entered parameters.
mbed_official 354:e67efb2aab0e 485 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 486 * @arg FORMAT_BIN: Binary data format
mbed_official 354:e67efb2aab0e 487 * @arg FORMAT_BCD: BCD data format
mbed_official 354:e67efb2aab0e 488 * @note The Alarm register can only be written when the corresponding Alarm
mbed_official 354:e67efb2aab0e 489 * is disabled (Use the HAL_RTC_DeactivateAlarm()).
mbed_official 354:e67efb2aab0e 490 * @note The HAL_RTC_SetTime() must be called before enabling the Alarm feature.
mbed_official 354:e67efb2aab0e 491 * @retval HAL status
mbed_official 354:e67efb2aab0e 492 */
mbed_official 354:e67efb2aab0e 493 HAL_StatusTypeDef HAL_RTC_SetAlarm_IT(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
mbed_official 354:e67efb2aab0e 494 {
mbed_official 354:e67efb2aab0e 495 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 496 uint32_t tmpreg = 0;
mbed_official 354:e67efb2aab0e 497 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 498 uint32_t subsecondtmpreg = 0;
mbed_official 354:e67efb2aab0e 499 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 500
mbed_official 354:e67efb2aab0e 501 /* Check the parameters */
mbed_official 354:e67efb2aab0e 502 assert_param(IS_RTC_FORMAT(Format));
mbed_official 354:e67efb2aab0e 503 assert_param(IS_ALARM(sAlarm->Alarm));
mbed_official 354:e67efb2aab0e 504 assert_param(IS_ALARM_MASK(sAlarm->AlarmMask));
mbed_official 354:e67efb2aab0e 505 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel));
mbed_official 354:e67efb2aab0e 506 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 507 assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds));
mbed_official 354:e67efb2aab0e 508 assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask));
mbed_official 354:e67efb2aab0e 509 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 510
mbed_official 354:e67efb2aab0e 511 /* Process Locked */
mbed_official 354:e67efb2aab0e 512 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 513
mbed_official 354:e67efb2aab0e 514 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 515
mbed_official 354:e67efb2aab0e 516 if(Format == FORMAT_BIN)
mbed_official 354:e67efb2aab0e 517 {
mbed_official 354:e67efb2aab0e 518 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 519 {
mbed_official 354:e67efb2aab0e 520 assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours));
mbed_official 354:e67efb2aab0e 521 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 354:e67efb2aab0e 522 }
mbed_official 354:e67efb2aab0e 523 else
mbed_official 354:e67efb2aab0e 524 {
mbed_official 354:e67efb2aab0e 525 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 354:e67efb2aab0e 526 assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
mbed_official 354:e67efb2aab0e 527 }
mbed_official 354:e67efb2aab0e 528 assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
mbed_official 354:e67efb2aab0e 529 assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
mbed_official 354:e67efb2aab0e 530
mbed_official 354:e67efb2aab0e 531 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 354:e67efb2aab0e 532 {
mbed_official 354:e67efb2aab0e 533 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay));
mbed_official 354:e67efb2aab0e 534 }
mbed_official 354:e67efb2aab0e 535 else
mbed_official 354:e67efb2aab0e 536 {
mbed_official 354:e67efb2aab0e 537 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay));
mbed_official 354:e67efb2aab0e 538 }
mbed_official 354:e67efb2aab0e 539 tmpreg = (((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 354:e67efb2aab0e 540 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 354:e67efb2aab0e 541 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds)) | \
mbed_official 354:e67efb2aab0e 542 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 354:e67efb2aab0e 543 ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 354:e67efb2aab0e 544 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 354:e67efb2aab0e 545 ((uint32_t)sAlarm->AlarmMask));
mbed_official 354:e67efb2aab0e 546 }
mbed_official 354:e67efb2aab0e 547 else
mbed_official 354:e67efb2aab0e 548 {
mbed_official 354:e67efb2aab0e 549 if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 550 {
mbed_official 354:e67efb2aab0e 551 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
mbed_official 354:e67efb2aab0e 552 assert_param(IS_RTC_HOUR12(tmpreg));
mbed_official 354:e67efb2aab0e 553 assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
mbed_official 354:e67efb2aab0e 554 }
mbed_official 354:e67efb2aab0e 555 else
mbed_official 354:e67efb2aab0e 556 {
mbed_official 354:e67efb2aab0e 557 sAlarm->AlarmTime.TimeFormat = 0x00;
mbed_official 354:e67efb2aab0e 558 assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
mbed_official 354:e67efb2aab0e 559 }
mbed_official 354:e67efb2aab0e 560
mbed_official 354:e67efb2aab0e 561 assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
mbed_official 354:e67efb2aab0e 562 assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
mbed_official 354:e67efb2aab0e 563
mbed_official 354:e67efb2aab0e 564 if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
mbed_official 354:e67efb2aab0e 565 {
mbed_official 354:e67efb2aab0e 566 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 354:e67efb2aab0e 567 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));
mbed_official 354:e67efb2aab0e 568 }
mbed_official 354:e67efb2aab0e 569 else
mbed_official 354:e67efb2aab0e 570 {
mbed_official 354:e67efb2aab0e 571 tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 354:e67efb2aab0e 572 assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));
mbed_official 354:e67efb2aab0e 573 }
mbed_official 354:e67efb2aab0e 574 tmpreg = (((uint32_t)(sAlarm->AlarmTime.Hours) << 16) | \
mbed_official 354:e67efb2aab0e 575 ((uint32_t)(sAlarm->AlarmTime.Minutes) << 8) | \
mbed_official 354:e67efb2aab0e 576 ((uint32_t) sAlarm->AlarmTime.Seconds) | \
mbed_official 354:e67efb2aab0e 577 ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
mbed_official 354:e67efb2aab0e 578 ((uint32_t)(sAlarm->AlarmDateWeekDay) << 24) | \
mbed_official 354:e67efb2aab0e 579 ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
mbed_official 354:e67efb2aab0e 580 ((uint32_t)sAlarm->AlarmMask));
mbed_official 354:e67efb2aab0e 581 }
mbed_official 354:e67efb2aab0e 582 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 583 /* Configure the Alarm A or Alarm B Sub Second registers */
mbed_official 354:e67efb2aab0e 584 subsecondtmpreg = (uint32_t)((uint32_t)(sAlarm->AlarmTime.SubSeconds) | (uint32_t)(sAlarm->AlarmSubSecondMask));
mbed_official 354:e67efb2aab0e 585 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 586
mbed_official 354:e67efb2aab0e 587 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 588 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 589
mbed_official 354:e67efb2aab0e 590 /* Configure the Alarm register */
mbed_official 354:e67efb2aab0e 591 if(sAlarm->Alarm == RTC_ALARM_A)
mbed_official 354:e67efb2aab0e 592 {
mbed_official 354:e67efb2aab0e 593 /* Disable the Alarm A interrupt */
mbed_official 354:e67efb2aab0e 594 __HAL_RTC_ALARMA_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 595
mbed_official 354:e67efb2aab0e 596 /* Clear flag alarm A */
mbed_official 354:e67efb2aab0e 597 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
mbed_official 354:e67efb2aab0e 598
mbed_official 354:e67efb2aab0e 599 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 600 /* Wait till RTC ALRAWF flag is set and if Time out is reached exit */
mbed_official 354:e67efb2aab0e 601 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
mbed_official 354:e67efb2aab0e 602 {
mbed_official 354:e67efb2aab0e 603 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 604 {
mbed_official 354:e67efb2aab0e 605 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 606 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 607
mbed_official 354:e67efb2aab0e 608 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 609
mbed_official 354:e67efb2aab0e 610 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 611 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 612
mbed_official 354:e67efb2aab0e 613 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 614 }
mbed_official 354:e67efb2aab0e 615 }
mbed_official 354:e67efb2aab0e 616
mbed_official 354:e67efb2aab0e 617 hrtc->Instance->ALRMAR = (uint32_t)tmpreg;
mbed_official 354:e67efb2aab0e 618 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 619 /* Configure the Alarm A Sub Second register */
mbed_official 354:e67efb2aab0e 620 hrtc->Instance->ALRMASSR = subsecondtmpreg;
mbed_official 354:e67efb2aab0e 621 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 622 /* Configure the Alarm state: Enable Alarm */
mbed_official 354:e67efb2aab0e 623 __HAL_RTC_ALARMA_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 624 /* Configure the Alarm interrupt */
mbed_official 354:e67efb2aab0e 625 __HAL_RTC_ALARM_ENABLE_IT(hrtc,RTC_IT_ALRA);
mbed_official 354:e67efb2aab0e 626 }
mbed_official 354:e67efb2aab0e 627 else
mbed_official 354:e67efb2aab0e 628 {
mbed_official 354:e67efb2aab0e 629 /* Disable the Alarm B interrupt */
mbed_official 354:e67efb2aab0e 630 __HAL_RTC_ALARMB_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 631
mbed_official 354:e67efb2aab0e 632 /* Clear flag alarm B */
mbed_official 354:e67efb2aab0e 633 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRBF);
mbed_official 354:e67efb2aab0e 634
mbed_official 354:e67efb2aab0e 635 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 636 /* Wait till RTC ALRBWF flag is set and if Time out is reached exit */
mbed_official 354:e67efb2aab0e 637 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
mbed_official 354:e67efb2aab0e 638 {
mbed_official 354:e67efb2aab0e 639 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 640 {
mbed_official 354:e67efb2aab0e 641 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 642 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 643
mbed_official 354:e67efb2aab0e 644 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 645
mbed_official 354:e67efb2aab0e 646 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 647 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 648
mbed_official 354:e67efb2aab0e 649 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 650 }
mbed_official 354:e67efb2aab0e 651 }
mbed_official 354:e67efb2aab0e 652
mbed_official 354:e67efb2aab0e 653 hrtc->Instance->ALRMBR = (uint32_t)tmpreg;
mbed_official 354:e67efb2aab0e 654 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 655 /* Configure the Alarm B Sub Second register */
mbed_official 354:e67efb2aab0e 656 hrtc->Instance->ALRMBSSR = subsecondtmpreg;
mbed_official 354:e67efb2aab0e 657 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 658 /* Configure the Alarm state: Enable Alarm */
mbed_official 354:e67efb2aab0e 659 __HAL_RTC_ALARMB_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 660 /* Configure the Alarm interrupt */
mbed_official 354:e67efb2aab0e 661 __HAL_RTC_ALARM_ENABLE_IT(hrtc, RTC_IT_ALRB);
mbed_official 354:e67efb2aab0e 662 }
mbed_official 354:e67efb2aab0e 663
mbed_official 354:e67efb2aab0e 664 /* RTC Alarm Interrupt Configuration: EXTI configuration */
mbed_official 354:e67efb2aab0e 665 __HAL_RTC_ENABLE_IT(RTC_EXTI_LINE_ALARM_EVENT);
mbed_official 354:e67efb2aab0e 666
mbed_official 354:e67efb2aab0e 667 EXTI->RTSR |= RTC_EXTI_LINE_ALARM_EVENT;
mbed_official 354:e67efb2aab0e 668
mbed_official 354:e67efb2aab0e 669 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 670 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 671
mbed_official 354:e67efb2aab0e 672 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 673
mbed_official 354:e67efb2aab0e 674 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 675 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 676
mbed_official 354:e67efb2aab0e 677 return HAL_OK;
mbed_official 354:e67efb2aab0e 678 }
mbed_official 354:e67efb2aab0e 679
mbed_official 354:e67efb2aab0e 680 /**
mbed_official 354:e67efb2aab0e 681 * @brief Gets the RTC Alarm value and masks.
mbed_official 354:e67efb2aab0e 682 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 683 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 684 * @param sAlarm: Pointer to Date structure
mbed_official 354:e67efb2aab0e 685 * @param Alarm: Specifies the Alarm.
mbed_official 354:e67efb2aab0e 686 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 687 * @arg RTC_ALARM_A: AlarmA
mbed_official 354:e67efb2aab0e 688 * @arg RTC_ALARM_B: AlarmB
mbed_official 354:e67efb2aab0e 689 * @param Format: Specifies the format of the entered parameters.
mbed_official 354:e67efb2aab0e 690 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 691 * @arg FORMAT_BIN: Binary data format
mbed_official 354:e67efb2aab0e 692 * @arg FORMAT_BCD: BCD data format
mbed_official 354:e67efb2aab0e 693 * @retval HAL status
mbed_official 354:e67efb2aab0e 694 */
mbed_official 354:e67efb2aab0e 695 HAL_StatusTypeDef HAL_RTC_GetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Alarm, uint32_t Format)
mbed_official 354:e67efb2aab0e 696 {
mbed_official 354:e67efb2aab0e 697 uint32_t tmpreg = 0;
mbed_official 354:e67efb2aab0e 698 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 699 uint32_t subsecondtmpreg = 0;
mbed_official 354:e67efb2aab0e 700 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 701
mbed_official 354:e67efb2aab0e 702 /* Check the parameters */
mbed_official 354:e67efb2aab0e 703 assert_param(IS_RTC_FORMAT(Format));
mbed_official 354:e67efb2aab0e 704 assert_param(IS_ALARM(Alarm));
mbed_official 354:e67efb2aab0e 705
mbed_official 354:e67efb2aab0e 706 if(Alarm == RTC_ALARM_A)
mbed_official 354:e67efb2aab0e 707 {
mbed_official 354:e67efb2aab0e 708 /* AlarmA */
mbed_official 354:e67efb2aab0e 709 sAlarm->Alarm = RTC_ALARM_A;
mbed_official 354:e67efb2aab0e 710
mbed_official 354:e67efb2aab0e 711 tmpreg = (uint32_t)(hrtc->Instance->ALRMAR);
mbed_official 354:e67efb2aab0e 712 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 713 subsecondtmpreg = (uint32_t)((hrtc->Instance->ALRMASSR) & RTC_ALRMASSR_SS);
mbed_official 354:e67efb2aab0e 714 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 715 }
mbed_official 354:e67efb2aab0e 716 else
mbed_official 354:e67efb2aab0e 717 {
mbed_official 354:e67efb2aab0e 718 sAlarm->Alarm = RTC_ALARM_B;
mbed_official 354:e67efb2aab0e 719
mbed_official 354:e67efb2aab0e 720 tmpreg = (uint32_t)(hrtc->Instance->ALRMBR);
mbed_official 354:e67efb2aab0e 721 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 722 subsecondtmpreg = (uint32_t)((hrtc->Instance->ALRMBSSR) & RTC_ALRMBSSR_SS);
mbed_official 354:e67efb2aab0e 723 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 724 }
mbed_official 354:e67efb2aab0e 725
mbed_official 354:e67efb2aab0e 726 /* Fill the structure with the read parameters */
mbed_official 354:e67efb2aab0e 727 sAlarm->AlarmTime.Hours = (uint32_t)((tmpreg & (RTC_ALRMAR_HT | RTC_ALRMAR_HU)) >> 16);
mbed_official 354:e67efb2aab0e 728 sAlarm->AlarmTime.Minutes = (uint32_t)((tmpreg & (RTC_ALRMAR_MNT | RTC_ALRMAR_MNU)) >> 8);
mbed_official 354:e67efb2aab0e 729 sAlarm->AlarmTime.Seconds = (uint32_t)(tmpreg & (RTC_ALRMAR_ST | RTC_ALRMAR_SU));
mbed_official 354:e67efb2aab0e 730 sAlarm->AlarmTime.TimeFormat = (uint32_t)((tmpreg & RTC_ALRMAR_PM) >> 16);
mbed_official 354:e67efb2aab0e 731 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 732 sAlarm->AlarmTime.SubSeconds = (uint32_t) subsecondtmpreg;
mbed_official 354:e67efb2aab0e 733 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 734 sAlarm->AlarmDateWeekDay = (uint32_t)((tmpreg & (RTC_ALRMAR_DT | RTC_ALRMAR_DU)) >> 24);
mbed_official 354:e67efb2aab0e 735 sAlarm->AlarmDateWeekDaySel = (uint32_t)(tmpreg & RTC_ALRMAR_WDSEL);
mbed_official 354:e67efb2aab0e 736 sAlarm->AlarmMask = (uint32_t)(tmpreg & RTC_ALARMMASK_ALL);
mbed_official 354:e67efb2aab0e 737
mbed_official 354:e67efb2aab0e 738 if(Format == FORMAT_BIN)
mbed_official 354:e67efb2aab0e 739 {
mbed_official 354:e67efb2aab0e 740 sAlarm->AlarmTime.Hours = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
mbed_official 354:e67efb2aab0e 741 sAlarm->AlarmTime.Minutes = RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes);
mbed_official 354:e67efb2aab0e 742 sAlarm->AlarmTime.Seconds = RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds);
mbed_official 354:e67efb2aab0e 743 sAlarm->AlarmDateWeekDay = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
mbed_official 354:e67efb2aab0e 744 }
mbed_official 354:e67efb2aab0e 745
mbed_official 354:e67efb2aab0e 746 return HAL_OK;
mbed_official 354:e67efb2aab0e 747 }
mbed_official 354:e67efb2aab0e 748
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
mbed_official 354:e67efb2aab0e 754 /** @defgroup RTC_Exported_Functions_Group6 Peripheral Control functions
mbed_official 354:e67efb2aab0e 755 * @brief Peripheral Control functions
mbed_official 354:e67efb2aab0e 756 *
mbed_official 354:e67efb2aab0e 757 @verbatim
mbed_official 354:e67efb2aab0e 758 ===============================================================================
mbed_official 354:e67efb2aab0e 759 ##### Peripheral Control functions #####
mbed_official 354:e67efb2aab0e 760 ===============================================================================
mbed_official 354:e67efb2aab0e 761 [..]
mbed_official 354:e67efb2aab0e 762 This subsection provides functions allowing to
mbed_official 354:e67efb2aab0e 763 (+) Wait for RTC Time and Date Synchronization
mbed_official 354:e67efb2aab0e 764
mbed_official 354:e67efb2aab0e 765 @endverbatim
mbed_official 354:e67efb2aab0e 766 * @{
mbed_official 354:e67efb2aab0e 767 */
mbed_official 354:e67efb2aab0e 768
mbed_official 354:e67efb2aab0e 769 /**
mbed_official 354:e67efb2aab0e 770 * @brief Waits until the RTC Time and Date registers (RTC_TR and RTC_DR) are
mbed_official 354:e67efb2aab0e 771 * synchronized with RTC APB clock.
mbed_official 354:e67efb2aab0e 772 * @note The RTC Resynchronization mode is write protected, use the
mbed_official 354:e67efb2aab0e 773 * __HAL_RTC_WRITEPROTECTION_DISABLE() before calling this function.
mbed_official 354:e67efb2aab0e 774 * @note To read the calendar through the shadow registers after Calendar
mbed_official 354:e67efb2aab0e 775 * initialization, calendar update or after wakeup from low power modes
mbed_official 354:e67efb2aab0e 776 * the software must first clear the RSF flag.
mbed_official 354:e67efb2aab0e 777 * The software must then wait until it is set again before reading
mbed_official 354:e67efb2aab0e 778 * the calendar, which means that the calendar registers have been
mbed_official 354:e67efb2aab0e 779 * correctly copied into the RTC_TR and RTC_DR shadow registers.
mbed_official 354:e67efb2aab0e 780 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 781 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 782 * @retval HAL status
mbed_official 354:e67efb2aab0e 783 */
mbed_official 354:e67efb2aab0e 784 HAL_StatusTypeDef HAL_RTC_WaitForSynchro(RTC_HandleTypeDef* hrtc)
mbed_official 354:e67efb2aab0e 785 {
mbed_official 354:e67efb2aab0e 786 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 787
mbed_official 354:e67efb2aab0e 788 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 789 /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
mbed_official 354:e67efb2aab0e 790 if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
mbed_official 354:e67efb2aab0e 791 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 792 {
mbed_official 354:e67efb2aab0e 793 /* Clear RSF flag */
mbed_official 354:e67efb2aab0e 794 hrtc->Instance->ISR &= (uint32_t)RTC_RSF_MASK;
mbed_official 354:e67efb2aab0e 795
mbed_official 354:e67efb2aab0e 796 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 797
mbed_official 354:e67efb2aab0e 798 /* Wait the registers to be synchronised */
mbed_official 354:e67efb2aab0e 799 while((hrtc->Instance->ISR & RTC_ISR_RSF) == (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 800 {
mbed_official 354:e67efb2aab0e 801 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 802 {
mbed_official 354:e67efb2aab0e 803 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 804 }
mbed_official 354:e67efb2aab0e 805 }
mbed_official 354:e67efb2aab0e 806 }
mbed_official 354:e67efb2aab0e 807
mbed_official 354:e67efb2aab0e 808 return HAL_OK;
mbed_official 354:e67efb2aab0e 809 }
mbed_official 354:e67efb2aab0e 810
mbed_official 354:e67efb2aab0e 811 /**
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
mbed_official 354:e67efb2aab0e 823 /** @defgroup RTCEx RTCEx
mbed_official 354:e67efb2aab0e 824 * @brief RTC Extended HAL module driver
mbed_official 354:e67efb2aab0e 825 * @{
mbed_official 354:e67efb2aab0e 826 */
mbed_official 354:e67efb2aab0e 827
mbed_official 354:e67efb2aab0e 828 /** @defgroup RTCEx_Exported_Functions RTCEx Exported Functions
mbed_official 354:e67efb2aab0e 829 * @{
mbed_official 354:e67efb2aab0e 830 */
mbed_official 354:e67efb2aab0e 831
mbed_official 354:e67efb2aab0e 832 /** @defgroup RTCEx_Exported_Functions_Group4 RTC TimeStamp and Tamper functions
mbed_official 354:e67efb2aab0e 833 * @brief RTC TimeStamp and Tamper functions
mbed_official 354:e67efb2aab0e 834 *
mbed_official 354:e67efb2aab0e 835 @verbatim
mbed_official 354:e67efb2aab0e 836 ===============================================================================
mbed_official 354:e67efb2aab0e 837 ##### RTC TimeStamp and Tamper functions #####
mbed_official 354:e67efb2aab0e 838 ===============================================================================
mbed_official 354:e67efb2aab0e 839
mbed_official 354:e67efb2aab0e 840 [..] This section provides functions allowing to configure TimeStamp feature
mbed_official 354:e67efb2aab0e 841
mbed_official 354:e67efb2aab0e 842 @endverbatim
mbed_official 354:e67efb2aab0e 843 * @{
mbed_official 354:e67efb2aab0e 844 */
mbed_official 354:e67efb2aab0e 845
mbed_official 354:e67efb2aab0e 846 /**
mbed_official 354:e67efb2aab0e 847 * @brief Sets TimeStamp.
mbed_official 354:e67efb2aab0e 848 * @note This API must be called before enabling the TimeStamp feature.
mbed_official 354:e67efb2aab0e 849 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 850 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 851 * @param TimeStampEdge: Specifies the pin edge on which the TimeStamp is
mbed_official 354:e67efb2aab0e 852 * activated.
mbed_official 354:e67efb2aab0e 853 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 854 * @arg RTC_TIMESTAMPEDGE_RISING: the Time stamp event occurs on the
mbed_official 354:e67efb2aab0e 855 * rising edge of the related pin.
mbed_official 354:e67efb2aab0e 856 * @arg RTC_TIMESTAMPEDGE_FALLING: the Time stamp event occurs on the
mbed_official 354:e67efb2aab0e 857 * falling edge of the related pin.
mbed_official 354:e67efb2aab0e 858 * @retval HAL status
mbed_official 354:e67efb2aab0e 859 */
mbed_official 354:e67efb2aab0e 860 HAL_StatusTypeDef HAL_RTCEx_SetTimeStamp(RTC_HandleTypeDef *hrtc, uint32_t TimeStampEdge)
mbed_official 354:e67efb2aab0e 861 {
mbed_official 354:e67efb2aab0e 862 uint32_t tmpreg = 0;
mbed_official 354:e67efb2aab0e 863
mbed_official 354:e67efb2aab0e 864 /* Check the parameters */
mbed_official 354:e67efb2aab0e 865 assert_param(IS_TIMESTAMP_EDGE(TimeStampEdge));
mbed_official 354:e67efb2aab0e 866
mbed_official 354:e67efb2aab0e 867 /* Process Locked */
mbed_official 354:e67efb2aab0e 868 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 869
mbed_official 354:e67efb2aab0e 870 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 871
mbed_official 354:e67efb2aab0e 872 /* Get the RTC_CR register and clear the bits to be configured */
mbed_official 354:e67efb2aab0e 873 tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));
mbed_official 354:e67efb2aab0e 874
mbed_official 354:e67efb2aab0e 875 tmpreg|= TimeStampEdge;
mbed_official 354:e67efb2aab0e 876
mbed_official 354:e67efb2aab0e 877 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 878 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 879
mbed_official 354:e67efb2aab0e 880 /* Configure the Time Stamp TSEDGE and Enable bits */
mbed_official 354:e67efb2aab0e 881 hrtc->Instance->CR = (uint32_t)tmpreg;
mbed_official 354:e67efb2aab0e 882
mbed_official 354:e67efb2aab0e 883 __HAL_RTC_TIMESTAMP_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 884
mbed_official 354:e67efb2aab0e 885 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 886 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 887
mbed_official 354:e67efb2aab0e 888 /* Change RTC state */
mbed_official 354:e67efb2aab0e 889 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 890
mbed_official 354:e67efb2aab0e 891 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 892 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 893
mbed_official 354:e67efb2aab0e 894 return HAL_OK;
mbed_official 354:e67efb2aab0e 895 }
mbed_official 354:e67efb2aab0e 896
mbed_official 354:e67efb2aab0e 897 /**
mbed_official 354:e67efb2aab0e 898 * @brief Sets TimeStamp with Interrupt.
mbed_official 354:e67efb2aab0e 899 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 900 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 901 * @note This API must be called before enabling the TimeStamp feature.
mbed_official 354:e67efb2aab0e 902 * @param TimeStampEdge: Specifies the pin edge on which the TimeStamp is
mbed_official 354:e67efb2aab0e 903 * activated.
mbed_official 354:e67efb2aab0e 904 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 905 * @arg RTC_TIMESTAMPEDGE_RISING: the Time stamp event occurs on the
mbed_official 354:e67efb2aab0e 906 * rising edge of the related pin.
mbed_official 354:e67efb2aab0e 907 * @arg RTC_TIMESTAMPEDGE_FALLING: the Time stamp event occurs on the
mbed_official 354:e67efb2aab0e 908 * falling edge of the related pin.
mbed_official 354:e67efb2aab0e 909 * @retval HAL status
mbed_official 354:e67efb2aab0e 910 */
mbed_official 354:e67efb2aab0e 911 HAL_StatusTypeDef HAL_RTCEx_SetTimeStamp_IT(RTC_HandleTypeDef *hrtc, uint32_t TimeStampEdge)
mbed_official 354:e67efb2aab0e 912 {
mbed_official 354:e67efb2aab0e 913 uint32_t tmpreg = 0;
mbed_official 354:e67efb2aab0e 914
mbed_official 354:e67efb2aab0e 915 /* Check the parameters */
mbed_official 354:e67efb2aab0e 916 assert_param(IS_TIMESTAMP_EDGE(TimeStampEdge));
mbed_official 354:e67efb2aab0e 917
mbed_official 354:e67efb2aab0e 918 /* Process Locked */
mbed_official 354:e67efb2aab0e 919 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 920
mbed_official 354:e67efb2aab0e 921 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 922
mbed_official 354:e67efb2aab0e 923 /* Get the RTC_CR register and clear the bits to be configured */
mbed_official 354:e67efb2aab0e 924 tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));
mbed_official 354:e67efb2aab0e 925
mbed_official 354:e67efb2aab0e 926 tmpreg |= TimeStampEdge;
mbed_official 354:e67efb2aab0e 927
mbed_official 354:e67efb2aab0e 928 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 929 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 930
mbed_official 354:e67efb2aab0e 931 /* Configure the Time Stamp TSEDGE and Enable bits */
mbed_official 354:e67efb2aab0e 932 hrtc->Instance->CR = (uint32_t)tmpreg;
mbed_official 354:e67efb2aab0e 933
mbed_official 354:e67efb2aab0e 934 __HAL_RTC_TIMESTAMP_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 935
mbed_official 354:e67efb2aab0e 936 /* Enable IT timestamp */
mbed_official 354:e67efb2aab0e 937 __HAL_RTC_TIMESTAMP_ENABLE_IT(hrtc,RTC_IT_TS);
mbed_official 354:e67efb2aab0e 938
mbed_official 354:e67efb2aab0e 939 /* RTC timestamp Interrupt Configuration: EXTI configuration */
mbed_official 354:e67efb2aab0e 940 __HAL_RTC_ENABLE_IT(RTC_EXTI_LINE_TAMPER_TIMESTAMP_EVENT);
mbed_official 354:e67efb2aab0e 941
mbed_official 354:e67efb2aab0e 942 EXTI->RTSR |= RTC_EXTI_LINE_TAMPER_TIMESTAMP_EVENT;
mbed_official 354:e67efb2aab0e 943
mbed_official 354:e67efb2aab0e 944 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 945 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 946
mbed_official 354:e67efb2aab0e 947 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 948
mbed_official 354:e67efb2aab0e 949 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 950 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 951
mbed_official 354:e67efb2aab0e 952 return HAL_OK;
mbed_official 354:e67efb2aab0e 953 }
mbed_official 354:e67efb2aab0e 954
mbed_official 354:e67efb2aab0e 955 /**
mbed_official 354:e67efb2aab0e 956 * @brief Deactivates TimeStamp.
mbed_official 354:e67efb2aab0e 957 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 958 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 959 * @retval HAL status
mbed_official 354:e67efb2aab0e 960 */
mbed_official 354:e67efb2aab0e 961 HAL_StatusTypeDef HAL_RTCEx_DeactivateTimeStamp(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 962 {
mbed_official 354:e67efb2aab0e 963 uint32_t tmpreg = 0;
mbed_official 354:e67efb2aab0e 964
mbed_official 354:e67efb2aab0e 965 /* Process Locked */
mbed_official 354:e67efb2aab0e 966 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 967
mbed_official 354:e67efb2aab0e 968 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 969
mbed_official 354:e67efb2aab0e 970 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 971 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 972
mbed_official 354:e67efb2aab0e 973 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 354:e67efb2aab0e 974 __HAL_RTC_TIMESTAMP_DISABLE_IT(hrtc, RTC_IT_TS);
mbed_official 354:e67efb2aab0e 975
mbed_official 354:e67efb2aab0e 976 /* Get the RTC_CR register and clear the bits to be configured */
mbed_official 354:e67efb2aab0e 977 tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));
mbed_official 354:e67efb2aab0e 978
mbed_official 354:e67efb2aab0e 979 /* Configure the Time Stamp TSEDGE and Enable bits */
mbed_official 354:e67efb2aab0e 980 hrtc->Instance->CR = (uint32_t)tmpreg;
mbed_official 354:e67efb2aab0e 981
mbed_official 354:e67efb2aab0e 982 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 983 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 984
mbed_official 354:e67efb2aab0e 985 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 986
mbed_official 354:e67efb2aab0e 987 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 988 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 989
mbed_official 354:e67efb2aab0e 990 return HAL_OK;
mbed_official 354:e67efb2aab0e 991 }
mbed_official 354:e67efb2aab0e 992
mbed_official 354:e67efb2aab0e 993 /**
mbed_official 354:e67efb2aab0e 994 * @brief Gets the RTC TimeStamp value.
mbed_official 354:e67efb2aab0e 995 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 996 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 997 * @param sTimeStamp: Pointer to Time structure
mbed_official 354:e67efb2aab0e 998 * @param sTimeStampDate: Pointer to Date structure
mbed_official 354:e67efb2aab0e 999 * @param Format: specifies the format of the entered parameters.
mbed_official 354:e67efb2aab0e 1000 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 1001 * FORMAT_BIN: Binary data format
mbed_official 354:e67efb2aab0e 1002 * FORMAT_BCD: BCD data format
mbed_official 354:e67efb2aab0e 1003 * @retval HAL status
mbed_official 354:e67efb2aab0e 1004 */
mbed_official 354:e67efb2aab0e 1005 HAL_StatusTypeDef HAL_RTCEx_GetTimeStamp(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef* sTimeStamp, RTC_DateTypeDef* sTimeStampDate, uint32_t Format)
mbed_official 354:e67efb2aab0e 1006 {
mbed_official 354:e67efb2aab0e 1007 uint32_t tmptime = 0, tmpdate = 0;
mbed_official 354:e67efb2aab0e 1008
mbed_official 354:e67efb2aab0e 1009 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1010 assert_param(IS_RTC_FORMAT(Format));
mbed_official 354:e67efb2aab0e 1011
mbed_official 354:e67efb2aab0e 1012 /* Get the TimeStamp time and date registers values */
mbed_official 354:e67efb2aab0e 1013 tmptime = (uint32_t)(hrtc->Instance->TSTR & RTC_TR_RESERVED_MASK);
mbed_official 354:e67efb2aab0e 1014 tmpdate = (uint32_t)(hrtc->Instance->TSDR & RTC_DR_RESERVED_MASK);
mbed_official 354:e67efb2aab0e 1015
mbed_official 354:e67efb2aab0e 1016 /* Fill the Time structure fields with the read parameters */
mbed_official 354:e67efb2aab0e 1017 sTimeStamp->Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16);
mbed_official 354:e67efb2aab0e 1018 sTimeStamp->Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8);
mbed_official 354:e67efb2aab0e 1019 sTimeStamp->Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU));
mbed_official 354:e67efb2aab0e 1020 sTimeStamp->TimeFormat = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16);
mbed_official 354:e67efb2aab0e 1021 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1022 sTimeStamp->SubSeconds = (uint32_t)((hrtc->Instance->TSSSR) & RTC_TSSSR_SS);
mbed_official 354:e67efb2aab0e 1023 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1024
mbed_official 354:e67efb2aab0e 1025 /* Fill the Date structure fields with the read parameters */
mbed_official 354:e67efb2aab0e 1026 sTimeStampDate->Year = 0;
mbed_official 354:e67efb2aab0e 1027 sTimeStampDate->Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8);
mbed_official 354:e67efb2aab0e 1028 sTimeStampDate->Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU));
mbed_official 354:e67efb2aab0e 1029 sTimeStampDate->WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13);
mbed_official 354:e67efb2aab0e 1030
mbed_official 354:e67efb2aab0e 1031 /* Check the input parameters format */
mbed_official 354:e67efb2aab0e 1032 if(Format == FORMAT_BIN)
mbed_official 354:e67efb2aab0e 1033 {
mbed_official 354:e67efb2aab0e 1034 /* Convert the TimeStamp structure parameters to Binary format */
mbed_official 354:e67efb2aab0e 1035 sTimeStamp->Hours = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Hours);
mbed_official 354:e67efb2aab0e 1036 sTimeStamp->Minutes = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Minutes);
mbed_official 354:e67efb2aab0e 1037 sTimeStamp->Seconds = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Seconds);
mbed_official 354:e67efb2aab0e 1038
mbed_official 354:e67efb2aab0e 1039 /* Convert the DateTimeStamp structure parameters to Binary format */
mbed_official 354:e67efb2aab0e 1040 sTimeStampDate->Month = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->Month);
mbed_official 354:e67efb2aab0e 1041 sTimeStampDate->Date = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->Date);
mbed_official 354:e67efb2aab0e 1042 sTimeStampDate->WeekDay = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->WeekDay);
mbed_official 354:e67efb2aab0e 1043 }
mbed_official 354:e67efb2aab0e 1044
mbed_official 354:e67efb2aab0e 1045 /* Clear the TIMESTAMP Flag */
mbed_official 354:e67efb2aab0e 1046 __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc, RTC_FLAG_TSF);
mbed_official 354:e67efb2aab0e 1047
mbed_official 354:e67efb2aab0e 1048 return HAL_OK;
mbed_official 354:e67efb2aab0e 1049 }
mbed_official 354:e67efb2aab0e 1050
mbed_official 354:e67efb2aab0e 1051 /**
mbed_official 354:e67efb2aab0e 1052 * @brief Sets Tamper
mbed_official 354:e67efb2aab0e 1053 * @note By calling this API we disable the tamper interrupt for all tampers.
mbed_official 354:e67efb2aab0e 1054 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1055 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1056 * @param sTamper: Pointer to Tamper Structure.
mbed_official 354:e67efb2aab0e 1057 * @retval HAL status
mbed_official 354:e67efb2aab0e 1058 */
mbed_official 354:e67efb2aab0e 1059 HAL_StatusTypeDef HAL_RTCEx_SetTamper(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)
mbed_official 354:e67efb2aab0e 1060 {
mbed_official 354:e67efb2aab0e 1061 uint32_t tmpreg = 0;
mbed_official 354:e67efb2aab0e 1062
mbed_official 354:e67efb2aab0e 1063 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1064 assert_param(IS_TAMPER(sTamper->Tamper));
mbed_official 354:e67efb2aab0e 1065 assert_param(IS_TAMPER_TRIGGER(sTamper->Trigger));
mbed_official 354:e67efb2aab0e 1066 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1067 assert_param(IS_TAMPER_FILTER(sTamper->Filter));
mbed_official 354:e67efb2aab0e 1068 assert_param(IS_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency));
mbed_official 354:e67efb2aab0e 1069 assert_param(IS_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration));
mbed_official 354:e67efb2aab0e 1070 assert_param(IS_TAMPER_PULLUP_STATE(sTamper->TamperPullUp));
mbed_official 354:e67efb2aab0e 1071 assert_param(IS_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection));
mbed_official 354:e67efb2aab0e 1072 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1073
mbed_official 354:e67efb2aab0e 1074 /* Process Locked */
mbed_official 354:e67efb2aab0e 1075 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 1076
mbed_official 354:e67efb2aab0e 1077 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 1078
mbed_official 354:e67efb2aab0e 1079 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1080 if((sTamper->Trigger == RTC_TAMPERTRIGGER_RISINGEDGE))
mbed_official 354:e67efb2aab0e 1081 {
mbed_official 354:e67efb2aab0e 1082 /* Configure the RTC_TAFCR register */
mbed_official 354:e67efb2aab0e 1083 sTamper->Trigger = RTC_TAMPERTRIGGER_RISINGEDGE;
mbed_official 354:e67efb2aab0e 1084 }
mbed_official 354:e67efb2aab0e 1085 else
mbed_official 354:e67efb2aab0e 1086 {
mbed_official 354:e67efb2aab0e 1087 sTamper->Trigger = (uint32_t)(sTamper->Tamper << 1);
mbed_official 354:e67efb2aab0e 1088 }
mbed_official 354:e67efb2aab0e 1089
mbed_official 354:e67efb2aab0e 1090 tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)sTamper->Trigger | (uint32_t)sTamper->Filter |\
mbed_official 354:e67efb2aab0e 1091 (uint32_t)sTamper->SamplingFrequency | (uint32_t)sTamper->PrechargeDuration |\
mbed_official 354:e67efb2aab0e 1092 (uint32_t)sTamper->TamperPullUp | sTamper->TimeStampOnTamperDetection);
mbed_official 354:e67efb2aab0e 1093
mbed_official 354:e67efb2aab0e 1094 hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1) | (uint32_t)RTC_TAFCR_TAMPTS |\
mbed_official 354:e67efb2aab0e 1095 (uint32_t)RTC_TAFCR_TAMPFREQ | (uint32_t)RTC_TAFCR_TAMPFLT | (uint32_t)RTC_TAFCR_TAMPPRCH |\
mbed_official 354:e67efb2aab0e 1096 (uint32_t)RTC_TAFCR_TAMPPUDIS | (uint32_t)RTC_TAFCR_TAMPIE);
mbed_official 354:e67efb2aab0e 1097 #else
mbed_official 354:e67efb2aab0e 1098 tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Trigger));
mbed_official 354:e67efb2aab0e 1099
mbed_official 354:e67efb2aab0e 1100 hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)RTC_TAFCR_TAMP1E | (uint32_t)RTC_TAFCR_TAMP1TRG);
mbed_official 354:e67efb2aab0e 1101
mbed_official 354:e67efb2aab0e 1102 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1103 hrtc->Instance->TAFCR |= tmpreg;
mbed_official 354:e67efb2aab0e 1104
mbed_official 354:e67efb2aab0e 1105 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1106
mbed_official 354:e67efb2aab0e 1107 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1108 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1109
mbed_official 354:e67efb2aab0e 1110 return HAL_OK;
mbed_official 354:e67efb2aab0e 1111 }
mbed_official 354:e67efb2aab0e 1112
mbed_official 354:e67efb2aab0e 1113 /**
mbed_official 354:e67efb2aab0e 1114 * @brief Sets Tamper with interrupt.
mbed_official 354:e67efb2aab0e 1115 * @note By calling this API we force the tamper interrupt for all tampers.
mbed_official 354:e67efb2aab0e 1116 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1117 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1118 * @param sTamper: Pointer to RTC Tamper.
mbed_official 354:e67efb2aab0e 1119 * @retval HAL status
mbed_official 354:e67efb2aab0e 1120 */
mbed_official 354:e67efb2aab0e 1121 HAL_StatusTypeDef HAL_RTCEx_SetTamper_IT(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)
mbed_official 354:e67efb2aab0e 1122 {
mbed_official 354:e67efb2aab0e 1123 uint32_t tmpreg = 0;
mbed_official 354:e67efb2aab0e 1124
mbed_official 354:e67efb2aab0e 1125 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1126 assert_param(IS_TAMPER(sTamper->Tamper));
mbed_official 354:e67efb2aab0e 1127 assert_param(IS_TAMPER_TRIGGER(sTamper->Trigger));
mbed_official 354:e67efb2aab0e 1128 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1129 assert_param(IS_TAMPER_FILTER(sTamper->Filter));
mbed_official 354:e67efb2aab0e 1130 assert_param(IS_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency));
mbed_official 354:e67efb2aab0e 1131 assert_param(IS_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration));
mbed_official 354:e67efb2aab0e 1132 assert_param(IS_TAMPER_PULLUP_STATE(sTamper->TamperPullUp));
mbed_official 354:e67efb2aab0e 1133 assert_param(IS_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection));
mbed_official 354:e67efb2aab0e 1134 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1135
mbed_official 354:e67efb2aab0e 1136 /* Process Locked */
mbed_official 354:e67efb2aab0e 1137 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 1138
mbed_official 354:e67efb2aab0e 1139 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 1140
mbed_official 354:e67efb2aab0e 1141 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1142 /* Configure the tamper trigger */
mbed_official 354:e67efb2aab0e 1143 if((sTamper->Trigger == RTC_TAMPERTRIGGER_RISINGEDGE))
mbed_official 354:e67efb2aab0e 1144 {
mbed_official 354:e67efb2aab0e 1145 sTamper->Trigger = RTC_TAMPERTRIGGER_RISINGEDGE;
mbed_official 354:e67efb2aab0e 1146 }
mbed_official 354:e67efb2aab0e 1147 else
mbed_official 354:e67efb2aab0e 1148 {
mbed_official 354:e67efb2aab0e 1149 sTamper->Trigger = (uint32_t) (sTamper->Tamper<<1);
mbed_official 354:e67efb2aab0e 1150 }
mbed_official 354:e67efb2aab0e 1151
mbed_official 354:e67efb2aab0e 1152 tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)sTamper->Trigger | (uint32_t)sTamper->Filter |\
mbed_official 354:e67efb2aab0e 1153 (uint32_t)sTamper->SamplingFrequency | (uint32_t)sTamper->PrechargeDuration |\
mbed_official 354:e67efb2aab0e 1154 (uint32_t)sTamper->TamperPullUp | sTamper->TimeStampOnTamperDetection);
mbed_official 354:e67efb2aab0e 1155
mbed_official 354:e67efb2aab0e 1156 hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1) | (uint32_t)RTC_TAFCR_TAMPTS |\
mbed_official 354:e67efb2aab0e 1157 (uint32_t)RTC_TAFCR_TAMPFREQ | (uint32_t)RTC_TAFCR_TAMPFLT | (uint32_t)RTC_TAFCR_TAMPPRCH |\
mbed_official 354:e67efb2aab0e 1158 (uint32_t)RTC_TAFCR_TAMPPUDIS);
mbed_official 354:e67efb2aab0e 1159 #else
mbed_official 354:e67efb2aab0e 1160 tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)sTamper->Trigger);
mbed_official 354:e67efb2aab0e 1161
mbed_official 354:e67efb2aab0e 1162 hrtc->Instance->TAFCR &= (uint32_t)~((uint32_t)RTC_TAFCR_TAMP1E | (uint32_t)RTC_TAFCR_TAMP1TRG | (uint32_t)RTC_TAFCR_TAMPIE);
mbed_official 354:e67efb2aab0e 1163 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1164 hrtc->Instance->TAFCR |= tmpreg;
mbed_official 354:e67efb2aab0e 1165
mbed_official 354:e67efb2aab0e 1166 /* Configure the Tamper Interrupt in the RTC_TAFCR */
mbed_official 354:e67efb2aab0e 1167 hrtc->Instance->TAFCR |= (uint32_t)RTC_TAFCR_TAMPIE;
mbed_official 354:e67efb2aab0e 1168
mbed_official 354:e67efb2aab0e 1169 /* RTC Tamper Interrupt Configuration: EXTI configuration */
mbed_official 354:e67efb2aab0e 1170 __HAL_RTC_ENABLE_IT(RTC_EXTI_LINE_TAMPER_TIMESTAMP_EVENT);
mbed_official 354:e67efb2aab0e 1171
mbed_official 354:e67efb2aab0e 1172 EXTI->RTSR |= RTC_EXTI_LINE_TAMPER_TIMESTAMP_EVENT;
mbed_official 354:e67efb2aab0e 1173
mbed_official 354:e67efb2aab0e 1174 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1175
mbed_official 354:e67efb2aab0e 1176 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1177 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1178
mbed_official 354:e67efb2aab0e 1179 return HAL_OK;
mbed_official 354:e67efb2aab0e 1180 }
mbed_official 354:e67efb2aab0e 1181
mbed_official 354:e67efb2aab0e 1182 /**
mbed_official 354:e67efb2aab0e 1183 * @brief Deactivates Tamper.
mbed_official 354:e67efb2aab0e 1184 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1185 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1186 * @param Tamper: Selected tamper pin.
mbed_official 354:e67efb2aab0e 1187 * This parameter can be a value of @ref RTCEx_Tamper_Pins_Definitions
mbed_official 354:e67efb2aab0e 1188 * @retval HAL status
mbed_official 354:e67efb2aab0e 1189 */
mbed_official 354:e67efb2aab0e 1190 HAL_StatusTypeDef HAL_RTCEx_DeactivateTamper(RTC_HandleTypeDef *hrtc, uint32_t Tamper)
mbed_official 354:e67efb2aab0e 1191 {
mbed_official 354:e67efb2aab0e 1192 assert_param(IS_TAMPER(Tamper));
mbed_official 354:e67efb2aab0e 1193
mbed_official 354:e67efb2aab0e 1194 /* Process Locked */
mbed_official 354:e67efb2aab0e 1195 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 1196
mbed_official 354:e67efb2aab0e 1197 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 1198
mbed_official 354:e67efb2aab0e 1199 /* Disable the selected Tamper pin */
mbed_official 354:e67efb2aab0e 1200 hrtc->Instance->TAFCR &= (uint32_t)~Tamper;
mbed_official 354:e67efb2aab0e 1201
mbed_official 354:e67efb2aab0e 1202 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1203
mbed_official 354:e67efb2aab0e 1204 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1205 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1206
mbed_official 354:e67efb2aab0e 1207 return HAL_OK;
mbed_official 354:e67efb2aab0e 1208 }
mbed_official 354:e67efb2aab0e 1209
mbed_official 354:e67efb2aab0e 1210 /**
mbed_official 354:e67efb2aab0e 1211 * @brief This function handles TimeStamp interrupt request.
mbed_official 354:e67efb2aab0e 1212 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1213 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1214 * @retval None
mbed_official 354:e67efb2aab0e 1215 */
mbed_official 354:e67efb2aab0e 1216 void HAL_RTCEx_TamperTimeStampIRQHandler(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 1217 {
mbed_official 354:e67efb2aab0e 1218 if(__HAL_RTC_TIMESTAMP_GET_IT(hrtc, RTC_IT_TS))
mbed_official 354:e67efb2aab0e 1219 {
mbed_official 354:e67efb2aab0e 1220 /* Get the status of the Interrupt */
mbed_official 354:e67efb2aab0e 1221 if((uint32_t)(hrtc->Instance->CR & RTC_IT_TS) != (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 1222 {
mbed_official 354:e67efb2aab0e 1223 /* TIMESTAMP callback */
mbed_official 354:e67efb2aab0e 1224 HAL_RTCEx_TimeStampEventCallback(hrtc);
mbed_official 354:e67efb2aab0e 1225
mbed_official 354:e67efb2aab0e 1226 /* Clear the TIMESTAMP interrupt pending bit */
mbed_official 354:e67efb2aab0e 1227 __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc,RTC_FLAG_TSF);
mbed_official 354:e67efb2aab0e 1228 }
mbed_official 354:e67efb2aab0e 1229 }
mbed_official 354:e67efb2aab0e 1230
mbed_official 354:e67efb2aab0e 1231 /* Get the status of the Interrupt */
mbed_official 354:e67efb2aab0e 1232 if(__HAL_RTC_TAMPER_GET_IT(hrtc,RTC_IT_TAMP1))
mbed_official 354:e67efb2aab0e 1233 {
mbed_official 354:e67efb2aab0e 1234 /* Get the TAMPER Interrupt enable bit and pending bit */
mbed_official 354:e67efb2aab0e 1235 if(((hrtc->Instance->TAFCR & (RTC_TAFCR_TAMPIE))) != (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 1236 {
mbed_official 354:e67efb2aab0e 1237 /* Tamper callback */
mbed_official 354:e67efb2aab0e 1238 HAL_RTCEx_Tamper1EventCallback(hrtc);
mbed_official 354:e67efb2aab0e 1239
mbed_official 354:e67efb2aab0e 1240 /* Clear the Tamper interrupt pending bit */
mbed_official 354:e67efb2aab0e 1241 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);
mbed_official 354:e67efb2aab0e 1242 }
mbed_official 354:e67efb2aab0e 1243 }
mbed_official 354:e67efb2aab0e 1244
mbed_official 354:e67efb2aab0e 1245 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1246 /* Get the status of the Interrupt */
mbed_official 354:e67efb2aab0e 1247 if(__HAL_RTC_TAMPER_GET_IT(hrtc, RTC_IT_TAMP2))
mbed_official 354:e67efb2aab0e 1248 {
mbed_official 354:e67efb2aab0e 1249 /* Get the TAMPER Interrupt enable bit and pending bit */
mbed_official 354:e67efb2aab0e 1250 if(((hrtc->Instance->TAFCR & RTC_TAFCR_TAMPIE)) != (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 1251 {
mbed_official 354:e67efb2aab0e 1252 /* Tamper callback */
mbed_official 354:e67efb2aab0e 1253 HAL_RTCEx_Tamper2EventCallback(hrtc);
mbed_official 354:e67efb2aab0e 1254
mbed_official 354:e67efb2aab0e 1255 /* Clear the Tamper interrupt pending bit */
mbed_official 354:e67efb2aab0e 1256 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP2F);
mbed_official 354:e67efb2aab0e 1257 }
mbed_official 354:e67efb2aab0e 1258 }
mbed_official 354:e67efb2aab0e 1259
mbed_official 354:e67efb2aab0e 1260 /* Get the status of the Interrupt */
mbed_official 354:e67efb2aab0e 1261 if(__HAL_RTC_TAMPER_GET_IT(hrtc, RTC_IT_TAMP3))
mbed_official 354:e67efb2aab0e 1262 {
mbed_official 354:e67efb2aab0e 1263 /* Get the TAMPER Interrupt enable bit and pending bit */
mbed_official 354:e67efb2aab0e 1264 if(((hrtc->Instance->TAFCR & RTC_TAFCR_TAMPIE)) != (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 1265 {
mbed_official 354:e67efb2aab0e 1266 /* Tamper callback */
mbed_official 354:e67efb2aab0e 1267 HAL_RTCEx_Tamper3EventCallback(hrtc);
mbed_official 354:e67efb2aab0e 1268
mbed_official 354:e67efb2aab0e 1269 /* Clear the Tamper interrupt pending bit */
mbed_official 354:e67efb2aab0e 1270 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP3F);
mbed_official 354:e67efb2aab0e 1271 }
mbed_official 354:e67efb2aab0e 1272 }
mbed_official 354:e67efb2aab0e 1273 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1274
mbed_official 354:e67efb2aab0e 1275 /* Clear the EXTI s Flag for RTC TimeStamp and Tamper */
mbed_official 354:e67efb2aab0e 1276 __HAL_RTC_CLEAR_FLAG(RTC_EXTI_LINE_TAMPER_TIMESTAMP_EVENT);
mbed_official 354:e67efb2aab0e 1277
mbed_official 354:e67efb2aab0e 1278 /* Change RTC state */
mbed_official 354:e67efb2aab0e 1279 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1280 }
mbed_official 354:e67efb2aab0e 1281
mbed_official 354:e67efb2aab0e 1282 /**
mbed_official 354:e67efb2aab0e 1283 * @brief TimeStamp callback.
mbed_official 354:e67efb2aab0e 1284 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1285 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1286 * @retval None
mbed_official 354:e67efb2aab0e 1287 */
mbed_official 354:e67efb2aab0e 1288 __weak void HAL_RTCEx_TimeStampEventCallback(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 1289 {
mbed_official 354:e67efb2aab0e 1290 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 1291 the HAL_RTCEx_TimeStampEventCallback could be implemented in the user file
mbed_official 354:e67efb2aab0e 1292 */
mbed_official 354:e67efb2aab0e 1293 }
mbed_official 354:e67efb2aab0e 1294
mbed_official 354:e67efb2aab0e 1295 /**
mbed_official 354:e67efb2aab0e 1296 * @brief Tamper 1 callback.
mbed_official 354:e67efb2aab0e 1297 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1298 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1299 * @retval None
mbed_official 354:e67efb2aab0e 1300 */
mbed_official 354:e67efb2aab0e 1301 __weak void HAL_RTCEx_Tamper1EventCallback(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 1302 {
mbed_official 354:e67efb2aab0e 1303 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 1304 the HAL_RTCEx_Tamper1EventCallback could be implemented in the user file
mbed_official 354:e67efb2aab0e 1305 */
mbed_official 354:e67efb2aab0e 1306 }
mbed_official 354:e67efb2aab0e 1307
mbed_official 354:e67efb2aab0e 1308 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1309 /**
mbed_official 354:e67efb2aab0e 1310 * @brief Tamper 2 callback.
mbed_official 354:e67efb2aab0e 1311 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1312 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1313 * @retval None
mbed_official 354:e67efb2aab0e 1314 */
mbed_official 354:e67efb2aab0e 1315 __weak void HAL_RTCEx_Tamper2EventCallback(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 1316 {
mbed_official 354:e67efb2aab0e 1317 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 1318 the HAL_RTCEx_Tamper2EventCallback could be implemented in the user file
mbed_official 354:e67efb2aab0e 1319 */
mbed_official 354:e67efb2aab0e 1320 }
mbed_official 354:e67efb2aab0e 1321
mbed_official 354:e67efb2aab0e 1322 /**
mbed_official 354:e67efb2aab0e 1323 * @brief Tamper 3 callback.
mbed_official 354:e67efb2aab0e 1324 * @param hrtc: RTC handle
mbed_official 354:e67efb2aab0e 1325 * @retval None
mbed_official 354:e67efb2aab0e 1326 */
mbed_official 354:e67efb2aab0e 1327 __weak void HAL_RTCEx_Tamper3EventCallback(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 1328 {
mbed_official 354:e67efb2aab0e 1329 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 1330 the HAL_RTCEx_Tamper3EventCallback could be implemented in the user file
mbed_official 354:e67efb2aab0e 1331 */
mbed_official 354:e67efb2aab0e 1332 }
mbed_official 354:e67efb2aab0e 1333 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1334
mbed_official 354:e67efb2aab0e 1335 /**
mbed_official 354:e67efb2aab0e 1336 * @brief This function handles TimeStamp polling request.
mbed_official 354:e67efb2aab0e 1337 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1338 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1339 * @param Timeout: Timeout duration
mbed_official 354:e67efb2aab0e 1340 * @retval HAL status
mbed_official 354:e67efb2aab0e 1341 */
mbed_official 354:e67efb2aab0e 1342 HAL_StatusTypeDef HAL_RTCEx_PollForTimeStampEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 1343 {
mbed_official 354:e67efb2aab0e 1344 uint32_t tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1345
mbed_official 354:e67efb2aab0e 1346 while(__HAL_RTC_TIMESTAMP_GET_FLAG(hrtc, RTC_FLAG_TSF) == RESET)
mbed_official 354:e67efb2aab0e 1347 {
mbed_official 354:e67efb2aab0e 1348 if(__HAL_RTC_TIMESTAMP_GET_FLAG(hrtc, RTC_FLAG_TSOVF) != RESET)
mbed_official 354:e67efb2aab0e 1349 {
mbed_official 354:e67efb2aab0e 1350 /* Clear the TIMESTAMP OverRun Flag */
mbed_official 354:e67efb2aab0e 1351 __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc, RTC_FLAG_TSOVF);
mbed_official 354:e67efb2aab0e 1352
mbed_official 354:e67efb2aab0e 1353 /* Change TIMESTAMP state */
mbed_official 354:e67efb2aab0e 1354 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 1355
mbed_official 354:e67efb2aab0e 1356 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 1357 }
mbed_official 354:e67efb2aab0e 1358
mbed_official 354:e67efb2aab0e 1359 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 1360 {
mbed_official 354:e67efb2aab0e 1361 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 1362 {
mbed_official 354:e67efb2aab0e 1363 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 1364 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 1365 }
mbed_official 354:e67efb2aab0e 1366 }
mbed_official 354:e67efb2aab0e 1367 }
mbed_official 354:e67efb2aab0e 1368
mbed_official 354:e67efb2aab0e 1369 /* Change RTC state */
mbed_official 354:e67efb2aab0e 1370 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1371
mbed_official 354:e67efb2aab0e 1372 return HAL_OK;
mbed_official 354:e67efb2aab0e 1373 }
mbed_official 354:e67efb2aab0e 1374
mbed_official 354:e67efb2aab0e 1375 /**
mbed_official 354:e67efb2aab0e 1376 * @brief This function handles Tamper1 Polling.
mbed_official 354:e67efb2aab0e 1377 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1378 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1379 * @param Timeout: Timeout duration
mbed_official 354:e67efb2aab0e 1380 * @retval HAL status
mbed_official 354:e67efb2aab0e 1381 */
mbed_official 354:e67efb2aab0e 1382 HAL_StatusTypeDef HAL_RTCEx_PollForTamper1Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 1383 {
mbed_official 354:e67efb2aab0e 1384 uint32_t tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1385
mbed_official 354:e67efb2aab0e 1386 /* Get the status of the Interrupt */
mbed_official 354:e67efb2aab0e 1387 while(__HAL_RTC_TAMPER_GET_FLAG(hrtc,RTC_FLAG_TAMP1F)== RESET)
mbed_official 354:e67efb2aab0e 1388 {
mbed_official 354:e67efb2aab0e 1389 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 1390 {
mbed_official 354:e67efb2aab0e 1391 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 1392 {
mbed_official 354:e67efb2aab0e 1393 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 1394 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 1395 }
mbed_official 354:e67efb2aab0e 1396 }
mbed_official 354:e67efb2aab0e 1397 }
mbed_official 354:e67efb2aab0e 1398
mbed_official 354:e67efb2aab0e 1399 /* Clear the Tamper Flag */
mbed_official 354:e67efb2aab0e 1400 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);
mbed_official 354:e67efb2aab0e 1401
mbed_official 354:e67efb2aab0e 1402 /* Change RTC state */
mbed_official 354:e67efb2aab0e 1403 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1404
mbed_official 354:e67efb2aab0e 1405 return HAL_OK;
mbed_official 354:e67efb2aab0e 1406 }
mbed_official 354:e67efb2aab0e 1407
mbed_official 354:e67efb2aab0e 1408 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1409 /**
mbed_official 354:e67efb2aab0e 1410 * @brief This function handles Tamper2 Polling.
mbed_official 354:e67efb2aab0e 1411 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1412 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1413 * @param Timeout: Timeout duration
mbed_official 354:e67efb2aab0e 1414 * @retval HAL status
mbed_official 354:e67efb2aab0e 1415 */
mbed_official 354:e67efb2aab0e 1416 HAL_StatusTypeDef HAL_RTCEx_PollForTamper2Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 1417 {
mbed_official 354:e67efb2aab0e 1418 uint32_t tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1419
mbed_official 354:e67efb2aab0e 1420 /* Get the status of the Interrupt */
mbed_official 354:e67efb2aab0e 1421 while(__HAL_RTC_TAMPER_GET_FLAG(hrtc,RTC_FLAG_TAMP2F) == RESET)
mbed_official 354:e67efb2aab0e 1422 {
mbed_official 354:e67efb2aab0e 1423 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 1424 {
mbed_official 354:e67efb2aab0e 1425 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 1426 {
mbed_official 354:e67efb2aab0e 1427 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 1428 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 1429 }
mbed_official 354:e67efb2aab0e 1430 }
mbed_official 354:e67efb2aab0e 1431 }
mbed_official 354:e67efb2aab0e 1432
mbed_official 354:e67efb2aab0e 1433 /* Clear the Tamper Flag */
mbed_official 354:e67efb2aab0e 1434 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP2F);
mbed_official 354:e67efb2aab0e 1435
mbed_official 354:e67efb2aab0e 1436 /* Change RTC state */
mbed_official 354:e67efb2aab0e 1437 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1438
mbed_official 354:e67efb2aab0e 1439 return HAL_OK;
mbed_official 354:e67efb2aab0e 1440 }
mbed_official 354:e67efb2aab0e 1441
mbed_official 354:e67efb2aab0e 1442 /**
mbed_official 354:e67efb2aab0e 1443 * @brief This function handles Tamper3 Polling.
mbed_official 354:e67efb2aab0e 1444 * @param hrtc: RTC handle
mbed_official 354:e67efb2aab0e 1445 * @param Timeout: Timeout duration
mbed_official 354:e67efb2aab0e 1446 * @retval HAL status
mbed_official 354:e67efb2aab0e 1447 */
mbed_official 354:e67efb2aab0e 1448 HAL_StatusTypeDef HAL_RTCEx_PollForTamper3Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 1449 {
mbed_official 354:e67efb2aab0e 1450 uint32_t tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1451
mbed_official 354:e67efb2aab0e 1452 /* Get the status of the Interrupt */
mbed_official 354:e67efb2aab0e 1453 while(__HAL_RTC_TAMPER_GET_FLAG(hrtc,RTC_FLAG_TAMP3F) == RESET)
mbed_official 354:e67efb2aab0e 1454 {
mbed_official 354:e67efb2aab0e 1455 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 1456 {
mbed_official 354:e67efb2aab0e 1457 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 1458 {
mbed_official 354:e67efb2aab0e 1459 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 1460 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 1461 }
mbed_official 354:e67efb2aab0e 1462 }
mbed_official 354:e67efb2aab0e 1463 }
mbed_official 354:e67efb2aab0e 1464
mbed_official 354:e67efb2aab0e 1465 /* Clear the Tamper Flag */
mbed_official 354:e67efb2aab0e 1466 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP3F);
mbed_official 354:e67efb2aab0e 1467
mbed_official 354:e67efb2aab0e 1468 /* Change RTC state */
mbed_official 354:e67efb2aab0e 1469 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1470
mbed_official 354:e67efb2aab0e 1471 return HAL_OK;
mbed_official 354:e67efb2aab0e 1472 }
mbed_official 354:e67efb2aab0e 1473 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 1474
mbed_official 354:e67efb2aab0e 1475 /**
mbed_official 354:e67efb2aab0e 1476 * @}
mbed_official 354:e67efb2aab0e 1477 */
mbed_official 354:e67efb2aab0e 1478
mbed_official 354:e67efb2aab0e 1479 /** @defgroup RTCEx_Exported_Functions_Group5 RTC Wake-up functions
mbed_official 354:e67efb2aab0e 1480 * @brief RTC Wake-up functions
mbed_official 354:e67efb2aab0e 1481 *
mbed_official 354:e67efb2aab0e 1482 @verbatim
mbed_official 354:e67efb2aab0e 1483 ===============================================================================
mbed_official 354:e67efb2aab0e 1484 ##### RTC Wake-up functions #####
mbed_official 354:e67efb2aab0e 1485 ===============================================================================
mbed_official 354:e67efb2aab0e 1486
mbed_official 354:e67efb2aab0e 1487 [..] This section provides functions allowing to configure Wake-up feature
mbed_official 354:e67efb2aab0e 1488
mbed_official 354:e67efb2aab0e 1489 @endverbatim
mbed_official 354:e67efb2aab0e 1490 * @{
mbed_official 354:e67efb2aab0e 1491 */
mbed_official 354:e67efb2aab0e 1492
mbed_official 354:e67efb2aab0e 1493 /**
mbed_official 354:e67efb2aab0e 1494 * @brief Sets wake up timer.
mbed_official 354:e67efb2aab0e 1495 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1496 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1497 * @param WakeUpCounter: Wake up counter
mbed_official 354:e67efb2aab0e 1498 * @param WakeUpClock: Wake up clock
mbed_official 354:e67efb2aab0e 1499 * @retval HAL status
mbed_official 354:e67efb2aab0e 1500 */
mbed_official 354:e67efb2aab0e 1501 HAL_StatusTypeDef HAL_RTCEx_SetWakeUpTimer(RTC_HandleTypeDef *hrtc, uint32_t WakeUpCounter, uint32_t WakeUpClock)
mbed_official 354:e67efb2aab0e 1502 {
mbed_official 354:e67efb2aab0e 1503 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 1504
mbed_official 354:e67efb2aab0e 1505 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1506 assert_param(IS_WAKEUP_CLOCK(WakeUpClock));
mbed_official 354:e67efb2aab0e 1507 assert_param(IS_WAKEUP_COUNTER(WakeUpCounter));
mbed_official 354:e67efb2aab0e 1508
mbed_official 354:e67efb2aab0e 1509 /* Process Locked */
mbed_official 354:e67efb2aab0e 1510 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 1511
mbed_official 354:e67efb2aab0e 1512 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 1513
mbed_official 354:e67efb2aab0e 1514 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1515 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 1516
mbed_official 354:e67efb2aab0e 1517 __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 1518
mbed_official 354:e67efb2aab0e 1519 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1520
mbed_official 354:e67efb2aab0e 1521 /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
mbed_official 354:e67efb2aab0e 1522 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)
mbed_official 354:e67efb2aab0e 1523 {
mbed_official 354:e67efb2aab0e 1524 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 1525 {
mbed_official 354:e67efb2aab0e 1526 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1527 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1528
mbed_official 354:e67efb2aab0e 1529 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 1530
mbed_official 354:e67efb2aab0e 1531 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1532 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1533
mbed_official 354:e67efb2aab0e 1534 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 1535 }
mbed_official 354:e67efb2aab0e 1536 }
mbed_official 354:e67efb2aab0e 1537
mbed_official 354:e67efb2aab0e 1538 /* Clear the Wakeup Timer clock source bits in CR register */
mbed_official 354:e67efb2aab0e 1539 hrtc->Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL;
mbed_official 354:e67efb2aab0e 1540
mbed_official 354:e67efb2aab0e 1541 /* Configure the clock source */
mbed_official 354:e67efb2aab0e 1542 hrtc->Instance->CR |= (uint32_t)WakeUpClock;
mbed_official 354:e67efb2aab0e 1543
mbed_official 354:e67efb2aab0e 1544 /* Configure the Wakeup Timer counter */
mbed_official 354:e67efb2aab0e 1545 hrtc->Instance->WUTR = (uint32_t)WakeUpCounter;
mbed_official 354:e67efb2aab0e 1546
mbed_official 354:e67efb2aab0e 1547 /* Enable the Wakeup Timer */
mbed_official 354:e67efb2aab0e 1548 __HAL_RTC_WAKEUPTIMER_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1549
mbed_official 354:e67efb2aab0e 1550 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1551 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1552
mbed_official 354:e67efb2aab0e 1553 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1554
mbed_official 354:e67efb2aab0e 1555 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1556 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1557
mbed_official 354:e67efb2aab0e 1558 return HAL_OK;
mbed_official 354:e67efb2aab0e 1559 }
mbed_official 354:e67efb2aab0e 1560
mbed_official 354:e67efb2aab0e 1561 /**
mbed_official 354:e67efb2aab0e 1562 * @brief Sets wake up timer with interrupt
mbed_official 354:e67efb2aab0e 1563 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1564 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1565 * @param WakeUpCounter: Wake up counter
mbed_official 354:e67efb2aab0e 1566 * @param WakeUpClock: Wake up clock
mbed_official 354:e67efb2aab0e 1567 * @retval HAL status
mbed_official 354:e67efb2aab0e 1568 */
mbed_official 354:e67efb2aab0e 1569 HAL_StatusTypeDef HAL_RTCEx_SetWakeUpTimer_IT(RTC_HandleTypeDef *hrtc, uint32_t WakeUpCounter, uint32_t WakeUpClock)
mbed_official 354:e67efb2aab0e 1570 {
mbed_official 354:e67efb2aab0e 1571 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 1572
mbed_official 354:e67efb2aab0e 1573 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1574 assert_param(IS_WAKEUP_CLOCK(WakeUpClock));
mbed_official 354:e67efb2aab0e 1575 assert_param(IS_WAKEUP_COUNTER(WakeUpCounter));
mbed_official 354:e67efb2aab0e 1576
mbed_official 354:e67efb2aab0e 1577 /* Process Locked */
mbed_official 354:e67efb2aab0e 1578 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 1579
mbed_official 354:e67efb2aab0e 1580 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 1581
mbed_official 354:e67efb2aab0e 1582 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1583 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 1584
mbed_official 354:e67efb2aab0e 1585 __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 1586
mbed_official 354:e67efb2aab0e 1587 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1588
mbed_official 354:e67efb2aab0e 1589 /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
mbed_official 354:e67efb2aab0e 1590 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)
mbed_official 354:e67efb2aab0e 1591 {
mbed_official 354:e67efb2aab0e 1592 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 1593 {
mbed_official 354:e67efb2aab0e 1594 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1595 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1596
mbed_official 354:e67efb2aab0e 1597 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 1598
mbed_official 354:e67efb2aab0e 1599 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1600 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1601
mbed_official 354:e67efb2aab0e 1602 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 1603 }
mbed_official 354:e67efb2aab0e 1604 }
mbed_official 354:e67efb2aab0e 1605
mbed_official 354:e67efb2aab0e 1606 /* Configure the Wakeup Timer counter */
mbed_official 354:e67efb2aab0e 1607 hrtc->Instance->WUTR = (uint32_t)WakeUpCounter;
mbed_official 354:e67efb2aab0e 1608
mbed_official 354:e67efb2aab0e 1609 /* Clear the Wakeup Timer clock source bits in CR register */
mbed_official 354:e67efb2aab0e 1610 hrtc->Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL;
mbed_official 354:e67efb2aab0e 1611
mbed_official 354:e67efb2aab0e 1612 /* Configure the clock source */
mbed_official 354:e67efb2aab0e 1613 hrtc->Instance->CR |= (uint32_t)WakeUpClock;
mbed_official 354:e67efb2aab0e 1614
mbed_official 354:e67efb2aab0e 1615 /* RTC WakeUpTimer Interrupt Configuration: EXTI configuration */
mbed_official 354:e67efb2aab0e 1616 __HAL_RTC_ENABLE_IT(RTC_EXTI_LINE_WAKEUPTIMER_EVENT);
mbed_official 354:e67efb2aab0e 1617
mbed_official 354:e67efb2aab0e 1618 EXTI->RTSR |= RTC_EXTI_LINE_WAKEUPTIMER_EVENT;
mbed_official 354:e67efb2aab0e 1619
mbed_official 354:e67efb2aab0e 1620 /* Configure the Interrupt in the RTC_CR register */
mbed_official 354:e67efb2aab0e 1621 __HAL_RTC_WAKEUPTIMER_ENABLE_IT(hrtc,RTC_IT_WUT);
mbed_official 354:e67efb2aab0e 1622
mbed_official 354:e67efb2aab0e 1623 /* Enable the Wakeup Timer */
mbed_official 354:e67efb2aab0e 1624 __HAL_RTC_WAKEUPTIMER_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1625
mbed_official 354:e67efb2aab0e 1626 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1627 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1628
mbed_official 354:e67efb2aab0e 1629 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1630
mbed_official 354:e67efb2aab0e 1631 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1632 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1633
mbed_official 354:e67efb2aab0e 1634 return HAL_OK;
mbed_official 354:e67efb2aab0e 1635 }
mbed_official 354:e67efb2aab0e 1636
mbed_official 354:e67efb2aab0e 1637 /**
mbed_official 354:e67efb2aab0e 1638 * @brief Deactivates wake up timer counter.
mbed_official 354:e67efb2aab0e 1639 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1640 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1641 * @retval HAL status
mbed_official 354:e67efb2aab0e 1642 */
mbed_official 354:e67efb2aab0e 1643 uint32_t HAL_RTCEx_DeactivateWakeUpTimer(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 1644 {
mbed_official 354:e67efb2aab0e 1645 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 1646
mbed_official 354:e67efb2aab0e 1647 /* Process Locked */
mbed_official 354:e67efb2aab0e 1648 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 1649
mbed_official 354:e67efb2aab0e 1650 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 1651
mbed_official 354:e67efb2aab0e 1652 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1653 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 1654
mbed_official 354:e67efb2aab0e 1655 /* Disable the Wakeup Timer */
mbed_official 354:e67efb2aab0e 1656 __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 1657
mbed_official 354:e67efb2aab0e 1658 /* In case of interrupt mode is used, the interrupt source must disabled */
mbed_official 354:e67efb2aab0e 1659 __HAL_RTC_WAKEUPTIMER_DISABLE_IT(hrtc,RTC_IT_WUT);
mbed_official 354:e67efb2aab0e 1660
mbed_official 354:e67efb2aab0e 1661 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1662 /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
mbed_official 354:e67efb2aab0e 1663 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)
mbed_official 354:e67efb2aab0e 1664 {
mbed_official 354:e67efb2aab0e 1665 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 1666 {
mbed_official 354:e67efb2aab0e 1667 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1668 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1669
mbed_official 354:e67efb2aab0e 1670 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 1671
mbed_official 354:e67efb2aab0e 1672 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1673 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1674
mbed_official 354:e67efb2aab0e 1675 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 1676 }
mbed_official 354:e67efb2aab0e 1677 }
mbed_official 354:e67efb2aab0e 1678
mbed_official 354:e67efb2aab0e 1679 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1680 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1681
mbed_official 354:e67efb2aab0e 1682 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1683
mbed_official 354:e67efb2aab0e 1684 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1685 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1686
mbed_official 354:e67efb2aab0e 1687 return HAL_OK;
mbed_official 354:e67efb2aab0e 1688 }
mbed_official 354:e67efb2aab0e 1689
mbed_official 354:e67efb2aab0e 1690 /**
mbed_official 354:e67efb2aab0e 1691 * @brief Gets wake up timer counter.
mbed_official 354:e67efb2aab0e 1692 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1693 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1694 * @retval Counter value
mbed_official 354:e67efb2aab0e 1695 */
mbed_official 354:e67efb2aab0e 1696 uint32_t HAL_RTCEx_GetWakeUpTimer(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 1697 {
mbed_official 354:e67efb2aab0e 1698 /* Get the counter value */
mbed_official 354:e67efb2aab0e 1699 return ((uint32_t)(hrtc->Instance->WUTR & RTC_WUTR_WUT));
mbed_official 354:e67efb2aab0e 1700 }
mbed_official 354:e67efb2aab0e 1701
mbed_official 354:e67efb2aab0e 1702 /**
mbed_official 354:e67efb2aab0e 1703 * @brief This function handles Wake Up Timer interrupt request.
mbed_official 354:e67efb2aab0e 1704 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1705 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1706 * @retval None
mbed_official 354:e67efb2aab0e 1707 */
mbed_official 354:e67efb2aab0e 1708 void HAL_RTCEx_WakeUpTimerIRQHandler(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 1709 {
mbed_official 354:e67efb2aab0e 1710 if(__HAL_RTC_WAKEUPTIMER_GET_IT(hrtc, RTC_IT_WUT))
mbed_official 354:e67efb2aab0e 1711 {
mbed_official 354:e67efb2aab0e 1712 /* Get the status of the Interrupt */
mbed_official 354:e67efb2aab0e 1713 if((uint32_t)(hrtc->Instance->CR & RTC_IT_WUT) != (uint32_t)RESET)
mbed_official 354:e67efb2aab0e 1714 {
mbed_official 354:e67efb2aab0e 1715 /* WAKEUPTIMER callback */
mbed_official 354:e67efb2aab0e 1716 HAL_RTCEx_WakeUpTimerEventCallback(hrtc);
mbed_official 354:e67efb2aab0e 1717
mbed_official 354:e67efb2aab0e 1718 /* Clear the WAKEUPTIMER interrupt pending bit */
mbed_official 354:e67efb2aab0e 1719 __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);
mbed_official 354:e67efb2aab0e 1720 }
mbed_official 354:e67efb2aab0e 1721 }
mbed_official 354:e67efb2aab0e 1722
mbed_official 354:e67efb2aab0e 1723 /* Clear the EXTI s line Flag for RTC WakeUpTimer */
mbed_official 354:e67efb2aab0e 1724 __HAL_RTC_CLEAR_FLAG(RTC_EXTI_LINE_WAKEUPTIMER_EVENT);
mbed_official 354:e67efb2aab0e 1725
mbed_official 354:e67efb2aab0e 1726 /* Change RTC state */
mbed_official 354:e67efb2aab0e 1727 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1728 }
mbed_official 354:e67efb2aab0e 1729
mbed_official 354:e67efb2aab0e 1730 /**
mbed_official 354:e67efb2aab0e 1731 * @brief Wake Up Timer callback.
mbed_official 354:e67efb2aab0e 1732 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1733 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1734 * @retval None
mbed_official 354:e67efb2aab0e 1735 */
mbed_official 354:e67efb2aab0e 1736 __weak void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 1737 {
mbed_official 354:e67efb2aab0e 1738 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 1739 the HAL_RTCEx_WakeUpTimerEventCallback could be implemented in the user file
mbed_official 354:e67efb2aab0e 1740 */
mbed_official 354:e67efb2aab0e 1741 }
mbed_official 354:e67efb2aab0e 1742
mbed_official 354:e67efb2aab0e 1743 /**
mbed_official 354:e67efb2aab0e 1744 * @brief This function handles Wake Up Timer Polling.
mbed_official 354:e67efb2aab0e 1745 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1746 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1747 * @param Timeout: Timeout duration
mbed_official 354:e67efb2aab0e 1748 * @retval HAL status
mbed_official 354:e67efb2aab0e 1749 */
mbed_official 354:e67efb2aab0e 1750 HAL_StatusTypeDef HAL_RTCEx_PollForWakeUpTimerEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 1751 {
mbed_official 354:e67efb2aab0e 1752 uint32_t tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 1753
mbed_official 354:e67efb2aab0e 1754 while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTF) == RESET)
mbed_official 354:e67efb2aab0e 1755 {
mbed_official 354:e67efb2aab0e 1756 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 1757 {
mbed_official 354:e67efb2aab0e 1758 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 1759 {
mbed_official 354:e67efb2aab0e 1760 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 1761
mbed_official 354:e67efb2aab0e 1762 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 1763 }
mbed_official 354:e67efb2aab0e 1764 }
mbed_official 354:e67efb2aab0e 1765 }
mbed_official 354:e67efb2aab0e 1766
mbed_official 354:e67efb2aab0e 1767 /* Clear the WAKEUPTIMER Flag */
mbed_official 354:e67efb2aab0e 1768 __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);
mbed_official 354:e67efb2aab0e 1769
mbed_official 354:e67efb2aab0e 1770 /* Change RTC state */
mbed_official 354:e67efb2aab0e 1771 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1772
mbed_official 354:e67efb2aab0e 1773 return HAL_OK;
mbed_official 354:e67efb2aab0e 1774 }
mbed_official 354:e67efb2aab0e 1775
mbed_official 354:e67efb2aab0e 1776 /**
mbed_official 354:e67efb2aab0e 1777 * @}
mbed_official 354:e67efb2aab0e 1778 */
mbed_official 354:e67efb2aab0e 1779
mbed_official 354:e67efb2aab0e 1780 /** @defgroup RTCEx_Exported_Functions_Group7 Extended Peripheral Control functions
mbed_official 354:e67efb2aab0e 1781 * @brief Extended Peripheral Control functions
mbed_official 354:e67efb2aab0e 1782 *
mbed_official 354:e67efb2aab0e 1783 @verbatim
mbed_official 354:e67efb2aab0e 1784 ===============================================================================
mbed_official 354:e67efb2aab0e 1785 ##### Extension Peripheral Control functions #####
mbed_official 354:e67efb2aab0e 1786 ===============================================================================
mbed_official 354:e67efb2aab0e 1787 [..]
mbed_official 354:e67efb2aab0e 1788 This subsection provides functions allowing to
mbed_official 354:e67efb2aab0e 1789 (+) Writes a data in a specified RTC Backup data register
mbed_official 354:e67efb2aab0e 1790 (+) Read a data in a specified RTC Backup data register
mbed_official 354:e67efb2aab0e 1791 (+) Sets the Coarse calibration parameters.
mbed_official 354:e67efb2aab0e 1792 (+) Deactivates the Coarse calibration parameters
mbed_official 354:e67efb2aab0e 1793 (+) Sets the Smooth calibration parameters.
mbed_official 354:e67efb2aab0e 1794 (+) Configures the Synchronization Shift Control Settings.
mbed_official 354:e67efb2aab0e 1795 (+) Configures the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
mbed_official 354:e67efb2aab0e 1796 (+) Deactivates the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
mbed_official 354:e67efb2aab0e 1797 (+) Enables the RTC reference clock detection.
mbed_official 354:e67efb2aab0e 1798 (+) Disable the RTC reference clock detection.
mbed_official 354:e67efb2aab0e 1799 (+) Enables the Bypass Shadow feature.
mbed_official 354:e67efb2aab0e 1800 (+) Disables the Bypass Shadow feature.
mbed_official 354:e67efb2aab0e 1801
mbed_official 354:e67efb2aab0e 1802 @endverbatim
mbed_official 354:e67efb2aab0e 1803 * @{
mbed_official 354:e67efb2aab0e 1804 */
mbed_official 354:e67efb2aab0e 1805
mbed_official 354:e67efb2aab0e 1806 /**
mbed_official 354:e67efb2aab0e 1807 * @brief Writes a data in a specified RTC Backup data register.
mbed_official 354:e67efb2aab0e 1808 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1809 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1810 * @param BackupRegister: RTC Backup data Register number.
mbed_official 354:e67efb2aab0e 1811 * This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to
mbed_official 354:e67efb2aab0e 1812 * specify the register.
mbed_official 354:e67efb2aab0e 1813 * @param Data: Data to be written in the specified RTC Backup data register.
mbed_official 354:e67efb2aab0e 1814 * @retval None
mbed_official 354:e67efb2aab0e 1815 */
mbed_official 354:e67efb2aab0e 1816 void HAL_RTCEx_BKUPWrite(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister, uint32_t Data)
mbed_official 354:e67efb2aab0e 1817 {
mbed_official 354:e67efb2aab0e 1818 uint32_t tmp = 0;
mbed_official 354:e67efb2aab0e 1819
mbed_official 354:e67efb2aab0e 1820 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1821 assert_param(IS_RTC_BKP(BackupRegister));
mbed_official 354:e67efb2aab0e 1822
mbed_official 354:e67efb2aab0e 1823 tmp = (uint32_t)&(hrtc->Instance->BKP0R);
mbed_official 354:e67efb2aab0e 1824 tmp += (BackupRegister * 4);
mbed_official 354:e67efb2aab0e 1825
mbed_official 354:e67efb2aab0e 1826 /* Write the specified register */
mbed_official 354:e67efb2aab0e 1827 *(__IO uint32_t *)tmp = (uint32_t)Data;
mbed_official 354:e67efb2aab0e 1828 }
mbed_official 354:e67efb2aab0e 1829
mbed_official 354:e67efb2aab0e 1830 /**
mbed_official 354:e67efb2aab0e 1831 * @brief Reads data from the specified RTC Backup data Register.
mbed_official 354:e67efb2aab0e 1832 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1833 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1834 * @param BackupRegister: RTC Backup data Register number.
mbed_official 354:e67efb2aab0e 1835 * This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to
mbed_official 354:e67efb2aab0e 1836 * specify the register.
mbed_official 354:e67efb2aab0e 1837 * @retval Read value
mbed_official 354:e67efb2aab0e 1838 */
mbed_official 354:e67efb2aab0e 1839 uint32_t HAL_RTCEx_BKUPRead(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister)
mbed_official 354:e67efb2aab0e 1840 {
mbed_official 354:e67efb2aab0e 1841 uint32_t tmp = 0;
mbed_official 354:e67efb2aab0e 1842
mbed_official 354:e67efb2aab0e 1843 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1844 assert_param(IS_RTC_BKP(BackupRegister));
mbed_official 354:e67efb2aab0e 1845
mbed_official 354:e67efb2aab0e 1846 tmp = (uint32_t)&(hrtc->Instance->BKP0R);
mbed_official 354:e67efb2aab0e 1847 tmp += (BackupRegister * 4);
mbed_official 354:e67efb2aab0e 1848
mbed_official 354:e67efb2aab0e 1849 /* Read the specified register */
mbed_official 354:e67efb2aab0e 1850 return (*(__IO uint32_t *)tmp);
mbed_official 354:e67efb2aab0e 1851 }
mbed_official 354:e67efb2aab0e 1852
mbed_official 354:e67efb2aab0e 1853 /**
mbed_official 354:e67efb2aab0e 1854 * @brief Sets the Coarse calibration parameters.
mbed_official 354:e67efb2aab0e 1855 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1856 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1857 * @param CalibSign: Specifies the sign of the coarse calibration value.
mbed_official 354:e67efb2aab0e 1858 * This parameter can be one of the following values :
mbed_official 354:e67efb2aab0e 1859 * @arg RTC_CALIBSIGN_POSITIVE: The value sign is positive
mbed_official 354:e67efb2aab0e 1860 * @arg RTC_CALIBSIGN_NEGATIVE: The value sign is negative
mbed_official 354:e67efb2aab0e 1861 * @param Value: value of coarse calibration expressed in ppm (coded on 5 bits).
mbed_official 354:e67efb2aab0e 1862 *
mbed_official 354:e67efb2aab0e 1863 * @note This Calibration value should be between 0 and 63 when using negative
mbed_official 354:e67efb2aab0e 1864 * sign with a 2-ppm step.
mbed_official 354:e67efb2aab0e 1865 *
mbed_official 354:e67efb2aab0e 1866 * @note This Calibration value should be between 0 and 126 when using positive
mbed_official 354:e67efb2aab0e 1867 * sign with a 4-ppm step.
mbed_official 354:e67efb2aab0e 1868 * @retval HAL status
mbed_official 354:e67efb2aab0e 1869 */
mbed_official 354:e67efb2aab0e 1870 HAL_StatusTypeDef HAL_RTCEx_SetCoarseCalib(RTC_HandleTypeDef* hrtc, uint32_t CalibSign, uint32_t Value)
mbed_official 354:e67efb2aab0e 1871 {
mbed_official 354:e67efb2aab0e 1872 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1873 assert_param(IS_RTC_CALIB_SIGN(CalibSign));
mbed_official 354:e67efb2aab0e 1874 assert_param(IS_RTC_CALIB_VALUE(Value));
mbed_official 354:e67efb2aab0e 1875
mbed_official 354:e67efb2aab0e 1876 /* Process Locked */
mbed_official 354:e67efb2aab0e 1877 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 1878
mbed_official 354:e67efb2aab0e 1879 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 1880
mbed_official 354:e67efb2aab0e 1881 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1882 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 1883
mbed_official 354:e67efb2aab0e 1884 /* Set Initialization mode */
mbed_official 354:e67efb2aab0e 1885 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 354:e67efb2aab0e 1886 {
mbed_official 354:e67efb2aab0e 1887 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1888 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1889
mbed_official 354:e67efb2aab0e 1890 /* Set RTC state*/
mbed_official 354:e67efb2aab0e 1891 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 1892
mbed_official 354:e67efb2aab0e 1893 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1894 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1895
mbed_official 354:e67efb2aab0e 1896 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 1897 }
mbed_official 354:e67efb2aab0e 1898 else
mbed_official 354:e67efb2aab0e 1899 {
mbed_official 354:e67efb2aab0e 1900 /* Enable the Coarse Calibration */
mbed_official 354:e67efb2aab0e 1901 __HAL_RTC_COARSE_CALIB_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1902
mbed_official 354:e67efb2aab0e 1903 /* Set the coarse calibration value */
mbed_official 354:e67efb2aab0e 1904 hrtc->Instance->CALIBR = (uint32_t)(CalibSign|Value);
mbed_official 354:e67efb2aab0e 1905
mbed_official 354:e67efb2aab0e 1906 /* Exit Initialization mode */
mbed_official 354:e67efb2aab0e 1907 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
mbed_official 354:e67efb2aab0e 1908 }
mbed_official 354:e67efb2aab0e 1909
mbed_official 354:e67efb2aab0e 1910 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1911 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1912
mbed_official 354:e67efb2aab0e 1913 /* Change state */
mbed_official 354:e67efb2aab0e 1914 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1915
mbed_official 354:e67efb2aab0e 1916 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1917 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1918
mbed_official 354:e67efb2aab0e 1919 return HAL_OK;
mbed_official 354:e67efb2aab0e 1920 }
mbed_official 354:e67efb2aab0e 1921
mbed_official 354:e67efb2aab0e 1922 /**
mbed_official 354:e67efb2aab0e 1923 * @brief Deactivates the Coarse calibration parameters.
mbed_official 354:e67efb2aab0e 1924 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1925 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1926 * @retval HAL status
mbed_official 354:e67efb2aab0e 1927 */
mbed_official 354:e67efb2aab0e 1928 HAL_StatusTypeDef HAL_RTCEx_DeactivateCoarseCalib(RTC_HandleTypeDef* hrtc)
mbed_official 354:e67efb2aab0e 1929 {
mbed_official 354:e67efb2aab0e 1930 /* Process Locked */
mbed_official 354:e67efb2aab0e 1931 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 1932
mbed_official 354:e67efb2aab0e 1933 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 1934
mbed_official 354:e67efb2aab0e 1935 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1936 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 1937
mbed_official 354:e67efb2aab0e 1938 /* Set Initialization mode */
mbed_official 354:e67efb2aab0e 1939 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 354:e67efb2aab0e 1940 {
mbed_official 354:e67efb2aab0e 1941 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1942 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1943
mbed_official 354:e67efb2aab0e 1944 /* Set RTC state*/
mbed_official 354:e67efb2aab0e 1945 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 1946
mbed_official 354:e67efb2aab0e 1947 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1948 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1949
mbed_official 354:e67efb2aab0e 1950 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 1951 }
mbed_official 354:e67efb2aab0e 1952 else
mbed_official 354:e67efb2aab0e 1953 {
mbed_official 354:e67efb2aab0e 1954 /* Enable the Coarse Calibration */
mbed_official 354:e67efb2aab0e 1955 __HAL_RTC_COARSE_CALIB_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 1956
mbed_official 354:e67efb2aab0e 1957 /* Exit Initialization mode */
mbed_official 354:e67efb2aab0e 1958 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
mbed_official 354:e67efb2aab0e 1959 }
mbed_official 354:e67efb2aab0e 1960
mbed_official 354:e67efb2aab0e 1961 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 1962 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 1963
mbed_official 354:e67efb2aab0e 1964 /* Change state */
mbed_official 354:e67efb2aab0e 1965 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 1966
mbed_official 354:e67efb2aab0e 1967 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 1968 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 1969
mbed_official 354:e67efb2aab0e 1970 return HAL_OK;
mbed_official 354:e67efb2aab0e 1971 }
mbed_official 354:e67efb2aab0e 1972
mbed_official 354:e67efb2aab0e 1973 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 1974 /**
mbed_official 354:e67efb2aab0e 1975 * @brief Sets the Smooth calibration parameters.
mbed_official 354:e67efb2aab0e 1976 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 1977 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 1978 * @param SmoothCalibPeriod: Select the Smooth Calibration Period.
mbed_official 354:e67efb2aab0e 1979 * This parameter can be can be one of the following values :
mbed_official 354:e67efb2aab0e 1980 * @arg RTC_SMOOTHCALIB_PERIOD_32SEC: The smooth calibration periode is 32s.
mbed_official 354:e67efb2aab0e 1981 * @arg RTC_SMOOTHCALIB_PERIOD_16SEC: The smooth calibration periode is 16s.
mbed_official 354:e67efb2aab0e 1982 * @arg RTC_SMOOTHCALIB_PERIOD_8SEC: The smooth calibartion periode is 8s.
mbed_official 354:e67efb2aab0e 1983 * @param SmoothCalibPlusPulses: Select to Set or reset the CALP bit.
mbed_official 354:e67efb2aab0e 1984 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 1985 * @arg RTC_SMOOTHCALIB_PLUSPULSES_SET: Add one RTCCLK puls every 2*11 pulses.
mbed_official 354:e67efb2aab0e 1986 * @arg RTC_SMOOTHCALIB_PLUSPULSES_RESET: No RTCCLK pulses are added.
mbed_official 354:e67efb2aab0e 1987 * @param SmouthCalibMinusPulsesValue: Select the value of CALM[8:0] bits.
mbed_official 354:e67efb2aab0e 1988 * This parameter can be one any value from 0 to 0x000001FF.
mbed_official 354:e67efb2aab0e 1989 * @note To deactivate the smooth calibration, the field SmoothCalibPlusPulses
mbed_official 354:e67efb2aab0e 1990 * must be equal to SMOOTHCALIB_PLUSPULSES_RESET and the field
mbed_official 354:e67efb2aab0e 1991 * SmouthCalibMinusPulsesValue must be equal to 0.
mbed_official 354:e67efb2aab0e 1992 * @retval HAL status
mbed_official 354:e67efb2aab0e 1993 */
mbed_official 354:e67efb2aab0e 1994 HAL_StatusTypeDef HAL_RTCEx_SetSmoothCalib(RTC_HandleTypeDef* hrtc, uint32_t SmoothCalibPeriod, uint32_t SmoothCalibPlusPulses, uint32_t SmouthCalibMinusPulsesValue)
mbed_official 354:e67efb2aab0e 1995 {
mbed_official 354:e67efb2aab0e 1996 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 1997
mbed_official 354:e67efb2aab0e 1998 /* Check the parameters */
mbed_official 354:e67efb2aab0e 1999 assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(SmoothCalibPeriod));
mbed_official 354:e67efb2aab0e 2000 assert_param(IS_RTC_SMOOTH_CALIB_PLUS(SmoothCalibPlusPulses));
mbed_official 354:e67efb2aab0e 2001 assert_param(IS_RTC_SMOOTH_CALIB_MINUS(SmouthCalibMinusPulsesValue));
mbed_official 354:e67efb2aab0e 2002
mbed_official 354:e67efb2aab0e 2003 /* Process Locked */
mbed_official 354:e67efb2aab0e 2004 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 2005
mbed_official 354:e67efb2aab0e 2006 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 2007
mbed_official 354:e67efb2aab0e 2008 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2009 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2010
mbed_official 354:e67efb2aab0e 2011 /* check if a calibration is pending*/
mbed_official 354:e67efb2aab0e 2012 if((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET)
mbed_official 354:e67efb2aab0e 2013 {
mbed_official 354:e67efb2aab0e 2014 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 2015
mbed_official 354:e67efb2aab0e 2016 /* check if a calibration is pending*/
mbed_official 354:e67efb2aab0e 2017 while((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET)
mbed_official 354:e67efb2aab0e 2018 {
mbed_official 354:e67efb2aab0e 2019 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 2020 {
mbed_official 354:e67efb2aab0e 2021 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2022 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2023
mbed_official 354:e67efb2aab0e 2024 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2025 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 2026
mbed_official 354:e67efb2aab0e 2027 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2028 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2029
mbed_official 354:e67efb2aab0e 2030 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 2031 }
mbed_official 354:e67efb2aab0e 2032 }
mbed_official 354:e67efb2aab0e 2033 }
mbed_official 354:e67efb2aab0e 2034
mbed_official 354:e67efb2aab0e 2035 /* Configure the Smooth calibration settings */
mbed_official 354:e67efb2aab0e 2036 hrtc->Instance->CALR = (uint32_t)((uint32_t)SmoothCalibPeriod | (uint32_t)SmoothCalibPlusPulses | (uint32_t)SmouthCalibMinusPulsesValue);
mbed_official 354:e67efb2aab0e 2037
mbed_official 354:e67efb2aab0e 2038 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2039 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2040
mbed_official 354:e67efb2aab0e 2041 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2042 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 2043
mbed_official 354:e67efb2aab0e 2044 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2045 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2046
mbed_official 354:e67efb2aab0e 2047 return HAL_OK;
mbed_official 354:e67efb2aab0e 2048 }
mbed_official 354:e67efb2aab0e 2049
mbed_official 354:e67efb2aab0e 2050 /**
mbed_official 354:e67efb2aab0e 2051 * @brief Configures the Synchronization Shift Control Settings.
mbed_official 354:e67efb2aab0e 2052 * @note When REFCKON is set, firmware must not write to Shift control register.
mbed_official 354:e67efb2aab0e 2053 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 2054 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 2055 * @param ShiftAdd1S: Select to add or not 1 second to the time calendar.
mbed_official 354:e67efb2aab0e 2056 * This parameter can be one of the following values :
mbed_official 354:e67efb2aab0e 2057 * @arg RTC_SHIFTADD1S_SET: Add one second to the clock calendar.
mbed_official 354:e67efb2aab0e 2058 * @arg RTC_SHIFTADD1S_RESET: No effect.
mbed_official 354:e67efb2aab0e 2059 * @param ShiftSubFS: Select the number of Second Fractions to substitute.
mbed_official 354:e67efb2aab0e 2060 * This parameter can be one any value from 0 to 0x7FFF.
mbed_official 354:e67efb2aab0e 2061 * @retval HAL status
mbed_official 354:e67efb2aab0e 2062 */
mbed_official 354:e67efb2aab0e 2063 HAL_StatusTypeDef HAL_RTCEx_SetSynchroShift(RTC_HandleTypeDef* hrtc, uint32_t ShiftAdd1S, uint32_t ShiftSubFS)
mbed_official 354:e67efb2aab0e 2064 {
mbed_official 354:e67efb2aab0e 2065 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 2066
mbed_official 354:e67efb2aab0e 2067 /* Check the parameters */
mbed_official 354:e67efb2aab0e 2068 assert_param(IS_RTC_SHIFT_ADD1S(ShiftAdd1S));
mbed_official 354:e67efb2aab0e 2069 assert_param(IS_RTC_SHIFT_SUBFS(ShiftSubFS));
mbed_official 354:e67efb2aab0e 2070
mbed_official 354:e67efb2aab0e 2071 /* Process Locked */
mbed_official 354:e67efb2aab0e 2072 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 2073
mbed_official 354:e67efb2aab0e 2074 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 2075
mbed_official 354:e67efb2aab0e 2076 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2077 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2078
mbed_official 354:e67efb2aab0e 2079 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 2080
mbed_official 354:e67efb2aab0e 2081 /* Wait until the shift is completed*/
mbed_official 354:e67efb2aab0e 2082 while((hrtc->Instance->ISR & RTC_ISR_SHPF) != RESET)
mbed_official 354:e67efb2aab0e 2083 {
mbed_official 354:e67efb2aab0e 2084 if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)
mbed_official 354:e67efb2aab0e 2085 {
mbed_official 354:e67efb2aab0e 2086 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2087 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2088
mbed_official 354:e67efb2aab0e 2089 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 2090
mbed_official 354:e67efb2aab0e 2091 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2092 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2093
mbed_official 354:e67efb2aab0e 2094 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 2095 }
mbed_official 354:e67efb2aab0e 2096 }
mbed_official 354:e67efb2aab0e 2097
mbed_official 354:e67efb2aab0e 2098 /* Check if the reference clock detection is disabled */
mbed_official 354:e67efb2aab0e 2099 if((hrtc->Instance->CR & RTC_CR_REFCKON) == RESET)
mbed_official 354:e67efb2aab0e 2100 {
mbed_official 354:e67efb2aab0e 2101 /* Configure the Shift settings */
mbed_official 354:e67efb2aab0e 2102 hrtc->Instance->SHIFTR = (uint32_t)(uint32_t)(ShiftSubFS) | (uint32_t)(ShiftAdd1S);
mbed_official 354:e67efb2aab0e 2103
mbed_official 354:e67efb2aab0e 2104 /* Wait for synchro */
mbed_official 354:e67efb2aab0e 2105 if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
mbed_official 354:e67efb2aab0e 2106 {
mbed_official 354:e67efb2aab0e 2107 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2108 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2109
mbed_official 354:e67efb2aab0e 2110 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 2111
mbed_official 354:e67efb2aab0e 2112 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2113 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2114
mbed_official 354:e67efb2aab0e 2115 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 2116 }
mbed_official 354:e67efb2aab0e 2117 }
mbed_official 354:e67efb2aab0e 2118 else
mbed_official 354:e67efb2aab0e 2119 {
mbed_official 354:e67efb2aab0e 2120 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2121 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2122
mbed_official 354:e67efb2aab0e 2123 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2124 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 2125
mbed_official 354:e67efb2aab0e 2126 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2127 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2128
mbed_official 354:e67efb2aab0e 2129 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 2130 }
mbed_official 354:e67efb2aab0e 2131
mbed_official 354:e67efb2aab0e 2132 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2133 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2134
mbed_official 354:e67efb2aab0e 2135 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2136 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 2137
mbed_official 354:e67efb2aab0e 2138 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2139 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2140
mbed_official 354:e67efb2aab0e 2141 return HAL_OK;
mbed_official 354:e67efb2aab0e 2142 }
mbed_official 354:e67efb2aab0e 2143 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 2144
mbed_official 354:e67efb2aab0e 2145
mbed_official 354:e67efb2aab0e 2146 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 2147 /**
mbed_official 354:e67efb2aab0e 2148 * @brief Configures the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
mbed_official 354:e67efb2aab0e 2149 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 2150 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 2151 * @param CalibOutput : Select the Calibration output Selection .
mbed_official 354:e67efb2aab0e 2152 * This parameter can be one of the following values:
mbed_official 354:e67efb2aab0e 2153 * @arg RTC_CALIBOUTPUT_512HZ: A signal has a regular waveform at 512Hz.
mbed_official 354:e67efb2aab0e 2154 * @arg RTC_CALIBOUTPUT_1HZ: A signal has a regular waveform at 1Hz.
mbed_official 354:e67efb2aab0e 2155 * @retval HAL status
mbed_official 354:e67efb2aab0e 2156 */
mbed_official 354:e67efb2aab0e 2157 HAL_StatusTypeDef HAL_RTCEx_SetCalibrationOutPut(RTC_HandleTypeDef* hrtc, uint32_t CalibOutput)
mbed_official 354:e67efb2aab0e 2158 #else
mbed_official 354:e67efb2aab0e 2159 /**
mbed_official 354:e67efb2aab0e 2160 * @brief Configure the Calibration Pinout (RTC_CALIB).
mbed_official 354:e67efb2aab0e 2161 * @param hrtc : RTC handle
mbed_official 354:e67efb2aab0e 2162 * @retval HAL status
mbed_official 354:e67efb2aab0e 2163 */
mbed_official 354:e67efb2aab0e 2164 HAL_StatusTypeDef HAL_RTCEx_SetCalibrationOutPut(RTC_HandleTypeDef* hrtc)
mbed_official 354:e67efb2aab0e 2165 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 2166 {
mbed_official 354:e67efb2aab0e 2167 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 2168 /* Check the parameters */
mbed_official 354:e67efb2aab0e 2169 assert_param(IS_RTC_CALIB_OUTPUT(CalibOutput));
mbed_official 354:e67efb2aab0e 2170 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 2171
mbed_official 354:e67efb2aab0e 2172 /* Process Locked */
mbed_official 354:e67efb2aab0e 2173 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 2174
mbed_official 354:e67efb2aab0e 2175 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 2176
mbed_official 354:e67efb2aab0e 2177 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2178 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2179
mbed_official 354:e67efb2aab0e 2180 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 2181 /* Clear flags before config */
mbed_official 354:e67efb2aab0e 2182 hrtc->Instance->CR &= (uint32_t)~RTC_CR_COSEL;
mbed_official 354:e67efb2aab0e 2183
mbed_official 354:e67efb2aab0e 2184 /* Configure the RTC_CR register */
mbed_official 354:e67efb2aab0e 2185 hrtc->Instance->CR |= (uint32_t)CalibOutput;
mbed_official 354:e67efb2aab0e 2186 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 2187
mbed_official 354:e67efb2aab0e 2188 __HAL_RTC_CALIBRATION_OUTPUT_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2189
mbed_official 354:e67efb2aab0e 2190 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2191 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2192
mbed_official 354:e67efb2aab0e 2193 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2194 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 2195
mbed_official 354:e67efb2aab0e 2196 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2197 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2198
mbed_official 354:e67efb2aab0e 2199 return HAL_OK;
mbed_official 354:e67efb2aab0e 2200 }
mbed_official 354:e67efb2aab0e 2201
mbed_official 354:e67efb2aab0e 2202 /**
mbed_official 354:e67efb2aab0e 2203 * @brief Deactivates the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).
mbed_official 354:e67efb2aab0e 2204 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 2205 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 2206 * @retval HAL status
mbed_official 354:e67efb2aab0e 2207 */
mbed_official 354:e67efb2aab0e 2208 HAL_StatusTypeDef HAL_RTCEx_DeactivateCalibrationOutPut(RTC_HandleTypeDef* hrtc)
mbed_official 354:e67efb2aab0e 2209 {
mbed_official 354:e67efb2aab0e 2210 /* Process Locked */
mbed_official 354:e67efb2aab0e 2211 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 2212
mbed_official 354:e67efb2aab0e 2213 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 2214
mbed_official 354:e67efb2aab0e 2215 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2216 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2217
mbed_official 354:e67efb2aab0e 2218 __HAL_RTC_CALIBRATION_OUTPUT_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2219
mbed_official 354:e67efb2aab0e 2220 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2221 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2222
mbed_official 354:e67efb2aab0e 2223 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2224 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 2225
mbed_official 354:e67efb2aab0e 2226 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2227 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2228
mbed_official 354:e67efb2aab0e 2229 return HAL_OK;
mbed_official 354:e67efb2aab0e 2230 }
mbed_official 354:e67efb2aab0e 2231
mbed_official 354:e67efb2aab0e 2232 /**
mbed_official 354:e67efb2aab0e 2233 * @brief Enables the RTC reference clock detection.
mbed_official 354:e67efb2aab0e 2234 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 2235 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 2236 * @retval HAL status
mbed_official 354:e67efb2aab0e 2237 */
mbed_official 354:e67efb2aab0e 2238 HAL_StatusTypeDef HAL_RTCEx_SetRefClock(RTC_HandleTypeDef* hrtc)
mbed_official 354:e67efb2aab0e 2239 {
mbed_official 354:e67efb2aab0e 2240 /* Process Locked */
mbed_official 354:e67efb2aab0e 2241 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 2242
mbed_official 354:e67efb2aab0e 2243 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 2244
mbed_official 354:e67efb2aab0e 2245 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2246 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2247
mbed_official 354:e67efb2aab0e 2248 /* Set Initialization mode */
mbed_official 354:e67efb2aab0e 2249 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 354:e67efb2aab0e 2250 {
mbed_official 354:e67efb2aab0e 2251 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2252 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2253
mbed_official 354:e67efb2aab0e 2254 /* Set RTC state*/
mbed_official 354:e67efb2aab0e 2255 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 2256
mbed_official 354:e67efb2aab0e 2257 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2258 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2259
mbed_official 354:e67efb2aab0e 2260 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 2261 }
mbed_official 354:e67efb2aab0e 2262 else
mbed_official 354:e67efb2aab0e 2263 {
mbed_official 354:e67efb2aab0e 2264 __HAL_RTC_CLOCKREF_DETECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2265
mbed_official 354:e67efb2aab0e 2266 /* Exit Initialization mode */
mbed_official 354:e67efb2aab0e 2267 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
mbed_official 354:e67efb2aab0e 2268 }
mbed_official 354:e67efb2aab0e 2269
mbed_official 354:e67efb2aab0e 2270 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2271 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2272
mbed_official 354:e67efb2aab0e 2273 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2274 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 2275
mbed_official 354:e67efb2aab0e 2276 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2277 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2278
mbed_official 354:e67efb2aab0e 2279 return HAL_OK;
mbed_official 354:e67efb2aab0e 2280 }
mbed_official 354:e67efb2aab0e 2281
mbed_official 354:e67efb2aab0e 2282 /**
mbed_official 354:e67efb2aab0e 2283 * @brief Disable the RTC reference clock detection.
mbed_official 354:e67efb2aab0e 2284 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 2285 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 2286 * @retval HAL status
mbed_official 354:e67efb2aab0e 2287 */
mbed_official 354:e67efb2aab0e 2288 HAL_StatusTypeDef HAL_RTCEx_DeactivateRefClock(RTC_HandleTypeDef* hrtc)
mbed_official 354:e67efb2aab0e 2289 {
mbed_official 354:e67efb2aab0e 2290 /* Process Locked */
mbed_official 354:e67efb2aab0e 2291 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 2292
mbed_official 354:e67efb2aab0e 2293 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 2294
mbed_official 354:e67efb2aab0e 2295 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2296 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2297
mbed_official 354:e67efb2aab0e 2298 /* Set Initialization mode */
mbed_official 354:e67efb2aab0e 2299 if(RTC_EnterInitMode(hrtc) != HAL_OK)
mbed_official 354:e67efb2aab0e 2300 {
mbed_official 354:e67efb2aab0e 2301 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2302 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2303
mbed_official 354:e67efb2aab0e 2304 /* Set RTC state*/
mbed_official 354:e67efb2aab0e 2305 hrtc->State = HAL_RTC_STATE_ERROR;
mbed_official 354:e67efb2aab0e 2306
mbed_official 354:e67efb2aab0e 2307 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2308 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2309
mbed_official 354:e67efb2aab0e 2310 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 2311 }
mbed_official 354:e67efb2aab0e 2312 else
mbed_official 354:e67efb2aab0e 2313 {
mbed_official 354:e67efb2aab0e 2314 __HAL_RTC_CLOCKREF_DETECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2315
mbed_official 354:e67efb2aab0e 2316 /* Exit Initialization mode */
mbed_official 354:e67efb2aab0e 2317 hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
mbed_official 354:e67efb2aab0e 2318 }
mbed_official 354:e67efb2aab0e 2319
mbed_official 354:e67efb2aab0e 2320 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2321 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2322
mbed_official 354:e67efb2aab0e 2323 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2324 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 2325
mbed_official 354:e67efb2aab0e 2326 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2327 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2328
mbed_official 354:e67efb2aab0e 2329 return HAL_OK;
mbed_official 354:e67efb2aab0e 2330 }
mbed_official 354:e67efb2aab0e 2331
mbed_official 354:e67efb2aab0e 2332 #if defined(STM32L100xBA) || defined (STM32L151xBA) || defined (STM32L152xBA) || defined(STM32L100xC) || defined (STM32L151xC) || defined (STM32L152xC) || defined (STM32L162xC) || defined(STM32L151xCA) || defined (STM32L151xD) || defined (STM32L152xCA) || defined (STM32L152xD) || defined (STM32L162xCA) || defined (STM32L162xD) || defined(STM32L151xE) || defined (STM32L152xE) || defined (STM32L162xE)
mbed_official 354:e67efb2aab0e 2333 /**
mbed_official 354:e67efb2aab0e 2334 * @brief Enables the Bypass Shadow feature.
mbed_official 354:e67efb2aab0e 2335 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 2336 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 2337 * @note When the Bypass Shadow is enabled the calendar value are taken
mbed_official 354:e67efb2aab0e 2338 * directly from the Calendar counter.
mbed_official 354:e67efb2aab0e 2339 * @retval HAL status
mbed_official 354:e67efb2aab0e 2340 */
mbed_official 354:e67efb2aab0e 2341 HAL_StatusTypeDef HAL_RTCEx_EnableBypassShadow(RTC_HandleTypeDef* hrtc)
mbed_official 354:e67efb2aab0e 2342 {
mbed_official 354:e67efb2aab0e 2343 /* Process Locked */
mbed_official 354:e67efb2aab0e 2344 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 2345
mbed_official 354:e67efb2aab0e 2346 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 2347
mbed_official 354:e67efb2aab0e 2348 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2349 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2350
mbed_official 354:e67efb2aab0e 2351 /* Set the BYPSHAD bit */
mbed_official 354:e67efb2aab0e 2352 hrtc->Instance->CR |= (uint8_t)RTC_CR_BYPSHAD;
mbed_official 354:e67efb2aab0e 2353
mbed_official 354:e67efb2aab0e 2354 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2355 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2356
mbed_official 354:e67efb2aab0e 2357 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2358 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 2359
mbed_official 354:e67efb2aab0e 2360 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2361 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2362
mbed_official 354:e67efb2aab0e 2363 return HAL_OK;
mbed_official 354:e67efb2aab0e 2364 }
mbed_official 354:e67efb2aab0e 2365
mbed_official 354:e67efb2aab0e 2366 /**
mbed_official 354:e67efb2aab0e 2367 * @brief Disables the Bypass Shadow feature.
mbed_official 354:e67efb2aab0e 2368 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 2369 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 2370 * @note When the Bypass Shadow is enabled the calendar value are taken
mbed_official 354:e67efb2aab0e 2371 * directly from the Calendar counter.
mbed_official 354:e67efb2aab0e 2372 * @retval HAL status
mbed_official 354:e67efb2aab0e 2373 */
mbed_official 354:e67efb2aab0e 2374 HAL_StatusTypeDef HAL_RTCEx_DisableBypassShadow(RTC_HandleTypeDef* hrtc)
mbed_official 354:e67efb2aab0e 2375 {
mbed_official 354:e67efb2aab0e 2376 /* Process Locked */
mbed_official 354:e67efb2aab0e 2377 __HAL_LOCK(hrtc);
mbed_official 354:e67efb2aab0e 2378
mbed_official 354:e67efb2aab0e 2379 hrtc->State = HAL_RTC_STATE_BUSY;
mbed_official 354:e67efb2aab0e 2380
mbed_official 354:e67efb2aab0e 2381 /* Disable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2382 __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
mbed_official 354:e67efb2aab0e 2383
mbed_official 354:e67efb2aab0e 2384 /* Reset the BYPSHAD bit */
mbed_official 354:e67efb2aab0e 2385 hrtc->Instance->CR &= (uint8_t)~RTC_CR_BYPSHAD;
mbed_official 354:e67efb2aab0e 2386
mbed_official 354:e67efb2aab0e 2387 /* Enable the write protection for RTC registers */
mbed_official 354:e67efb2aab0e 2388 __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
mbed_official 354:e67efb2aab0e 2389
mbed_official 354:e67efb2aab0e 2390 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2391 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 2392
mbed_official 354:e67efb2aab0e 2393 /* Process Unlocked */
mbed_official 354:e67efb2aab0e 2394 __HAL_UNLOCK(hrtc);
mbed_official 354:e67efb2aab0e 2395
mbed_official 354:e67efb2aab0e 2396 return HAL_OK;
mbed_official 354:e67efb2aab0e 2397 }
mbed_official 354:e67efb2aab0e 2398 #endif /* STM32L100xBA || STM32L151xBA || STM32L152xBA || STM32L100xC || STM32L151xC || STM32L152xC || STM32L162xC || STM32L151xCA || STM32L151xD || STM32L152xCA || STM32L152xD || STM32L162xCA || STM32L162xD || STM32L151xE || STM32L152xE || STM32L162xE */
mbed_official 354:e67efb2aab0e 2399
mbed_official 354:e67efb2aab0e 2400 /**
mbed_official 354:e67efb2aab0e 2401 * @}
mbed_official 354:e67efb2aab0e 2402 */
mbed_official 354:e67efb2aab0e 2403
mbed_official 354:e67efb2aab0e 2404 /** @defgroup RTCEx_Exported_Functions_Group8 Extended features functions
mbed_official 354:e67efb2aab0e 2405 * @brief Extended features functions
mbed_official 354:e67efb2aab0e 2406 *
mbed_official 354:e67efb2aab0e 2407 @verbatim
mbed_official 354:e67efb2aab0e 2408 ===============================================================================
mbed_official 354:e67efb2aab0e 2409 ##### Extended features functions #####
mbed_official 354:e67efb2aab0e 2410 ===============================================================================
mbed_official 354:e67efb2aab0e 2411 [..] This section provides functions allowing to:
mbed_official 354:e67efb2aab0e 2412 (+) RTC Alram B callback
mbed_official 354:e67efb2aab0e 2413 (+) RTC Poll for Alarm B request
mbed_official 354:e67efb2aab0e 2414
mbed_official 354:e67efb2aab0e 2415 @endverbatim
mbed_official 354:e67efb2aab0e 2416 * @{
mbed_official 354:e67efb2aab0e 2417 */
mbed_official 354:e67efb2aab0e 2418
mbed_official 354:e67efb2aab0e 2419 /**
mbed_official 354:e67efb2aab0e 2420 * @brief Alarm B callback.
mbed_official 354:e67efb2aab0e 2421 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 2422 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 2423 * @retval None
mbed_official 354:e67efb2aab0e 2424 */
mbed_official 354:e67efb2aab0e 2425 __weak void HAL_RTCEx_AlarmBEventCallback(RTC_HandleTypeDef *hrtc)
mbed_official 354:e67efb2aab0e 2426 {
mbed_official 354:e67efb2aab0e 2427 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 2428 the HAL_RTCEx_AlarmBEventCallback could be implemented in the user file
mbed_official 354:e67efb2aab0e 2429 */
mbed_official 354:e67efb2aab0e 2430 }
mbed_official 354:e67efb2aab0e 2431
mbed_official 354:e67efb2aab0e 2432 /**
mbed_official 354:e67efb2aab0e 2433 * @brief This function handles AlarmB Polling request.
mbed_official 354:e67efb2aab0e 2434 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 2435 * the configuration information for RTC.
mbed_official 354:e67efb2aab0e 2436 * @param Timeout: Timeout duration
mbed_official 354:e67efb2aab0e 2437 * @retval HAL status
mbed_official 354:e67efb2aab0e 2438 */
mbed_official 354:e67efb2aab0e 2439 HAL_StatusTypeDef HAL_RTCEx_PollForAlarmBEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 2440 {
mbed_official 354:e67efb2aab0e 2441 uint32_t tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 2442
mbed_official 354:e67efb2aab0e 2443 while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBF) == RESET)
mbed_official 354:e67efb2aab0e 2444 {
mbed_official 354:e67efb2aab0e 2445 if(Timeout != HAL_MAX_DELAY)
mbed_official 354:e67efb2aab0e 2446 {
mbed_official 354:e67efb2aab0e 2447 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 2448 {
mbed_official 354:e67efb2aab0e 2449 hrtc->State = HAL_RTC_STATE_TIMEOUT;
mbed_official 354:e67efb2aab0e 2450 return HAL_TIMEOUT;
mbed_official 354:e67efb2aab0e 2451 }
mbed_official 354:e67efb2aab0e 2452 }
mbed_official 354:e67efb2aab0e 2453 }
mbed_official 354:e67efb2aab0e 2454
mbed_official 354:e67efb2aab0e 2455 /* Clear the Alarm Flag */
mbed_official 354:e67efb2aab0e 2456 __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRBF);
mbed_official 354:e67efb2aab0e 2457
mbed_official 354:e67efb2aab0e 2458 /* Change RTC state */
mbed_official 354:e67efb2aab0e 2459 hrtc->State = HAL_RTC_STATE_READY;
mbed_official 354:e67efb2aab0e 2460
mbed_official 354:e67efb2aab0e 2461 return HAL_OK;
mbed_official 354:e67efb2aab0e 2462 }
mbed_official 354:e67efb2aab0e 2463
mbed_official 354:e67efb2aab0e 2464 /**
mbed_official 354:e67efb2aab0e 2465 * @}
mbed_official 354:e67efb2aab0e 2466 */
mbed_official 354:e67efb2aab0e 2467
mbed_official 354:e67efb2aab0e 2468 /**
mbed_official 354:e67efb2aab0e 2469 * @}
mbed_official 354:e67efb2aab0e 2470 */
mbed_official 354:e67efb2aab0e 2471
mbed_official 354:e67efb2aab0e 2472 /**
mbed_official 354:e67efb2aab0e 2473 * @}
mbed_official 354:e67efb2aab0e 2474 */
mbed_official 354:e67efb2aab0e 2475
mbed_official 354:e67efb2aab0e 2476 #endif /* HAL_RTC_MODULE_ENABLED */
mbed_official 354:e67efb2aab0e 2477
mbed_official 354:e67efb2aab0e 2478 /**
mbed_official 354:e67efb2aab0e 2479 * @}
mbed_official 354:e67efb2aab0e 2480 */
mbed_official 354:e67efb2aab0e 2481
mbed_official 354:e67efb2aab0e 2482 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/