Subversion Repositories DashDisplay

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f1xx_hal_rtc_ex.c
  4.   * @author  MCD Application Team
  5.   * @version V1.0.1
  6.   * @date    31-July-2015
  7.   * @brief   Extended RTC HAL module driver.
  8.   *          This file provides firmware functions to manage the following
  9.   *          functionalities of the Real Time Clock (RTC) Extension peripheral:
  10.   *           + RTC Tamper functions
  11.   *           + Extension Control functions
  12.   *           + Extension RTC features functions    
  13.   *        
  14.   ******************************************************************************
  15.   * @attention
  16.   *
  17.   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
  18.   *
  19.   * Redistribution and use in source and binary forms, with or without modification,
  20.   * are permitted provided that the following conditions are met:
  21.   *   1. Redistributions of source code must retain the above copyright notice,
  22.   *      this list of conditions and the following disclaimer.
  23.   *   2. Redistributions in binary form must reproduce the above copyright notice,
  24.   *      this list of conditions and the following disclaimer in the documentation
  25.   *      and/or other materials provided with the distribution.
  26.   *   3. Neither the name of STMicroelectronics nor the names of its contributors
  27.   *      may be used to endorse or promote products derived from this software
  28.   *      without specific prior written permission.
  29.   *
  30.   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  31.   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32.   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  33.   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  34.   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35.   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  36.   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  37.   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  38.   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  39.   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40.   *
  41.   ******************************************************************************  
  42.   */
  43.  
  44. /* Includes ------------------------------------------------------------------*/
  45. #include "stm32f1xx_hal.h"
  46.  
  47. /** @addtogroup STM32F1xx_HAL_Driver
  48.   * @{
  49.   */
  50.  
  51. #ifdef HAL_RTC_MODULE_ENABLED
  52.  
  53. /** @defgroup RTCEx RTCEx
  54.   * @brief RTC Extended HAL module driver
  55.   * @{
  56.   */
  57.  
  58. /* Private typedef -----------------------------------------------------------*/
  59. /* Private define ------------------------------------------------------------*/
  60. /* Private macro -------------------------------------------------------------*/
  61. /** @defgroup RTCEx_Private_Macros RTCEx Private Macros
  62.   * @{
  63.   */
  64. /**
  65.   * @}
  66.   */
  67.  
  68. /* Private variables ---------------------------------------------------------*/
  69. /* Private function prototypes -----------------------------------------------*/
  70. /* Private functions ---------------------------------------------------------*/
  71.  
  72. /** @defgroup RTCEx_Exported_Functions RTCEx Exported Functions
  73.   * @{
  74.   */
  75.  
  76. /** @defgroup RTCEx_Exported_Functions_Group1 RTC Tamper functions
  77.   * @brief    RTC Tamper functions
  78.   *
  79. @verbatim  
  80.  ===============================================================================
  81.                  ##### RTC Tamper functions #####
  82.  ===============================================================================  
  83.  
  84.  [..] This section provides functions allowing to configure Tamper feature
  85.  
  86. @endverbatim
  87.   * @{
  88.   */
  89.  
  90. /**
  91.   * @brief  Sets Tamper
  92.   * @note   By calling this API we disable the tamper interrupt for all tampers.
  93.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  94.   *                the configuration information for RTC.
  95.   * @param  sTamper: Pointer to Tamper Structure.
  96.   * @note   Tamper can be enabled only if ASOE and CCO bit are reset
  97.   * @retval HAL status
  98.   */
  99. HAL_StatusTypeDef HAL_RTCEx_SetTamper(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)
  100. {
  101.   /* Check input parameters */
  102.   if((hrtc == NULL) || (sTamper == NULL))
  103.   {
  104.      return HAL_ERROR;
  105.   }
  106.  
  107.   /* Check the parameters */
  108.   assert_param(IS_RTC_TAMPER(sTamper->Tamper));
  109.   assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));
  110.  
  111.   /* Process Locked */
  112.   __HAL_LOCK(hrtc);
  113.  
  114.   hrtc->State = HAL_RTC_STATE_BUSY;
  115.  
  116.   if (HAL_IS_BIT_SET(BKP->RTCCR,(BKP_RTCCR_CCO | BKP_RTCCR_ASOE)))
  117.   {
  118.     hrtc->State = HAL_RTC_STATE_ERROR;
  119.    
  120.     /* Process Unlocked */
  121.     __HAL_UNLOCK(hrtc);
  122.    
  123.     return HAL_ERROR;
  124.   }
  125.  
  126.   MODIFY_REG(BKP->CR, (BKP_CR_TPE | BKP_CR_TPAL), (sTamper->Tamper | (sTamper->Trigger)));
  127.  
  128.   hrtc->State = HAL_RTC_STATE_READY;
  129.  
  130.   /* Process Unlocked */
  131.   __HAL_UNLOCK(hrtc);
  132.  
  133.   return HAL_OK;
  134. }
  135.  
  136. /**
  137.   * @brief  Sets Tamper with interrupt.
  138.   * @note   By calling this API we force the tamper interrupt for all tampers.
  139.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  140.   *                the configuration information for RTC.
  141.   * @param  sTamper: Pointer to RTC Tamper.
  142.   * @note   Tamper can be enabled only if ASOE and CCO bit are reset
  143.   * @retval HAL status
  144.   */
  145. HAL_StatusTypeDef HAL_RTCEx_SetTamper_IT(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)
  146. {
  147.   /* Check input parameters */
  148.   if((hrtc == NULL) || (sTamper == NULL))
  149.   {
  150.      return HAL_ERROR;
  151.   }
  152.  
  153.   /* Check the parameters */
  154.   assert_param(IS_RTC_TAMPER(sTamper->Tamper));
  155.   assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));
  156.  
  157.   /* Process Locked */
  158.   __HAL_LOCK(hrtc);
  159.  
  160.   hrtc->State = HAL_RTC_STATE_BUSY;
  161.  
  162.   if (HAL_IS_BIT_SET(BKP->RTCCR,(BKP_RTCCR_CCO | BKP_RTCCR_ASOE)))
  163.   {
  164.     hrtc->State = HAL_RTC_STATE_ERROR;
  165.    
  166.     /* Process Unlocked */
  167.     __HAL_UNLOCK(hrtc);
  168.    
  169.     return HAL_ERROR;
  170.   }
  171.  
  172.   MODIFY_REG(BKP->CR, (BKP_CR_TPE | BKP_CR_TPAL), (sTamper->Tamper | (sTamper->Trigger)));
  173.  
  174.   /* Configure the Tamper Interrupt in the BKP->CSR */
  175.   __HAL_RTC_TAMPER_ENABLE_IT(hrtc, RTC_IT_TAMP1);
  176.  
  177.   hrtc->State = HAL_RTC_STATE_READY;
  178.  
  179.   /* Process Unlocked */
  180.   __HAL_UNLOCK(hrtc);
  181.  
  182.   return HAL_OK;
  183. }
  184.  
  185. /**
  186.   * @brief  Deactivates Tamper.
  187.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  188.   *                the configuration information for RTC.
  189.   * @param  Tamper: Selected tamper pin.
  190.   *          This parameter can be a value of @ref RTCEx_Tamper_Pins_Definitions
  191.   * @retval HAL status
  192.   */
  193. HAL_StatusTypeDef HAL_RTCEx_DeactivateTamper(RTC_HandleTypeDef *hrtc, uint32_t Tamper)
  194. {
  195.   /* Check input parameters */
  196.   if(hrtc == NULL)
  197.   {
  198.      return HAL_ERROR;
  199.   }
  200.  
  201.   assert_param(IS_RTC_TAMPER(Tamper));
  202.  
  203.   /* Process Locked */
  204.   __HAL_LOCK(hrtc);
  205.  
  206.   hrtc->State = HAL_RTC_STATE_BUSY;
  207.  
  208.   /* Disable the selected Tamper pin */
  209.   CLEAR_BIT(BKP->CR, BKP_CR_TPE);
  210.  
  211.   /* Disable the Tamper Interrupt in the BKP->CSR */
  212.   /* Configure the Tamper Interrupt in the BKP->CSR */
  213.   __HAL_RTC_TAMPER_DISABLE_IT(hrtc, RTC_IT_TAMP1);
  214.  
  215.   /* Clear the Tamper interrupt pending bit */
  216.   __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP1F);
  217.   SET_BIT(BKP->CSR, BKP_CSR_CTE);
  218.  
  219.   hrtc->State = HAL_RTC_STATE_READY;
  220.  
  221.   /* Process Unlocked */
  222.   __HAL_UNLOCK(hrtc);
  223.  
  224.   return HAL_OK;
  225. }
  226.  
  227. /**
  228.   * @brief  This function handles Tamper interrupt request.
  229.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  230.   *                the configuration information for RTC.
  231.   * @retval None
  232.   */
  233. void HAL_RTCEx_TamperIRQHandler(RTC_HandleTypeDef *hrtc)
  234. {  
  235.   /* Get the status of the Interrupt */
  236.   if(__HAL_RTC_TAMPER_GET_IT_SOURCE(hrtc, RTC_IT_TAMP1))
  237.   {
  238.     /* Get the TAMPER Interrupt enable bit and pending bit */
  239.     if(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP1F) != (uint32_t)RESET)
  240.     {
  241.       /* Tamper callback */
  242.       HAL_RTCEx_Tamper1EventCallback(hrtc);
  243.  
  244.       /* Clear the Tamper interrupt pending bit */
  245.       __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);
  246.     }
  247.   }
  248.  
  249.   /* Change RTC state */
  250.   hrtc->State = HAL_RTC_STATE_READY;
  251. }
  252.  
  253. /**
  254.   * @brief  Tamper 1 callback.
  255.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  256.   *                the configuration information for RTC.
  257.   * @retval None
  258.   */
  259. __weak void HAL_RTCEx_Tamper1EventCallback(RTC_HandleTypeDef *hrtc)
  260. {
  261.   /* NOTE : This function Should not be modified, when the callback is needed,
  262.             the HAL_RTCEx_Tamper1EventCallback could be implemented in the user file
  263.    */
  264. }
  265.  
  266. /**
  267.   * @brief  This function handles Tamper1 Polling.
  268.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  269.   *                the configuration information for RTC.
  270.   * @param  Timeout: Timeout duration
  271.   * @retval HAL status
  272.   */
  273. HAL_StatusTypeDef HAL_RTCEx_PollForTamper1Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
  274. {  
  275.   uint32_t tickstart = HAL_GetTick();
  276.  
  277.   /* Check input parameters */
  278.   if(hrtc == NULL)
  279.   {
  280.      return HAL_ERROR;
  281.   }
  282.  
  283.   /* Get the status of the Interrupt */
  284.   while(__HAL_RTC_TAMPER_GET_FLAG(hrtc,RTC_FLAG_TAMP1F)== RESET)
  285.   {
  286.     if(Timeout != HAL_MAX_DELAY)
  287.     {
  288.       if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
  289.       {
  290.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  291.         return HAL_TIMEOUT;
  292.       }
  293.     }
  294.   }
  295.  
  296.   /* Clear the Tamper Flag */
  297.   __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);
  298.  
  299.   /* Change RTC state */
  300.   hrtc->State = HAL_RTC_STATE_READY;
  301.  
  302.   return HAL_OK;
  303. }
  304.  
  305. /**
  306.   * @}
  307.   */
  308.  
  309. /** @defgroup RTCEx_Exported_Functions_Group2 RTC Second functions
  310.   * @brief    RTC Second functions
  311.   *
  312. @verbatim  
  313.  ===============================================================================
  314.                  ##### RTC Second functions #####
  315.  ===============================================================================  
  316.  
  317.  [..] This section provides functions implementing second interupt handlers
  318.  
  319. @endverbatim
  320.   * @{
  321.   */
  322.  
  323. /**
  324.   * @brief  Sets Interrupt for second
  325.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  326.   *                the configuration information for RTC.
  327.   * @retval HAL status
  328.   */
  329. HAL_StatusTypeDef HAL_RTCEx_SetSecond_IT(RTC_HandleTypeDef *hrtc)
  330. {
  331.   /* Check input parameters */
  332.   if(hrtc == NULL)
  333.   {
  334.      return HAL_ERROR;
  335.   }
  336.  
  337.   /* Process Locked */
  338.   __HAL_LOCK(hrtc);
  339.  
  340.   hrtc->State = HAL_RTC_STATE_BUSY;
  341.  
  342.   /* Enable Second interuption */
  343.   __HAL_RTC_SECOND_ENABLE_IT(hrtc, RTC_IT_SEC);
  344.  
  345.   hrtc->State = HAL_RTC_STATE_READY;
  346.  
  347.   /* Process Unlocked */
  348.   __HAL_UNLOCK(hrtc);
  349.  
  350.   return HAL_OK;
  351. }
  352.  
  353. /**
  354.   * @brief  Deactivates Second.
  355.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  356.   *                the configuration information for RTC.
  357.   * @retval HAL status
  358.   */
  359. HAL_StatusTypeDef HAL_RTCEx_DeactivateSecond(RTC_HandleTypeDef *hrtc)
  360. {
  361.   /* Check input parameters */
  362.   if(hrtc == NULL)
  363.   {
  364.      return HAL_ERROR;
  365.   }
  366.  
  367.   /* Process Locked */
  368.   __HAL_LOCK(hrtc);
  369.  
  370.   hrtc->State = HAL_RTC_STATE_BUSY;
  371.  
  372.   /* Deactivate Second interuption*/
  373.   __HAL_RTC_SECOND_DISABLE_IT(hrtc, RTC_IT_SEC);
  374.  
  375.   hrtc->State = HAL_RTC_STATE_READY;
  376.  
  377.   /* Process Unlocked */
  378.   __HAL_UNLOCK(hrtc);
  379.  
  380.   return HAL_OK;
  381. }
  382.  
  383. /**
  384.   * @brief  This function handles second interrupt request.
  385.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  386.   *                the configuration information for RTC.
  387.   * @retval None
  388.   */
  389. void HAL_RTCEx_RTCIRQHandler(RTC_HandleTypeDef* hrtc)
  390. {
  391.   if(__HAL_RTC_SECOND_GET_IT_SOURCE(hrtc, RTC_IT_SEC))
  392.   {
  393.     /* Get the status of the Interrupt */
  394.     if(__HAL_RTC_SECOND_GET_FLAG(hrtc, RTC_FLAG_SEC))
  395.     {
  396.       /* Check if Overrun occurred */
  397.       if (__HAL_RTC_SECOND_GET_FLAG(hrtc, RTC_FLAG_OW))
  398.       {
  399.         /* Second error callback */
  400.         HAL_RTCEx_RTCEventErrorCallback(hrtc);
  401.        
  402.         /* Clear flag Second */
  403.         __HAL_RTC_OVERFLOW_CLEAR_FLAG(hrtc, RTC_FLAG_OW);
  404.        
  405.         /* Change RTC state */
  406.         hrtc->State = HAL_RTC_STATE_ERROR;
  407.       }
  408.       else
  409.       {
  410.         /* Second callback */
  411.         HAL_RTCEx_RTCEventCallback(hrtc);
  412.        
  413.         /* Change RTC state */
  414.         hrtc->State = HAL_RTC_STATE_READY;
  415.       }
  416.      
  417.       /* Clear flag Second */
  418.       __HAL_RTC_SECOND_CLEAR_FLAG(hrtc, RTC_FLAG_SEC);
  419.     }
  420.   }
  421. }
  422.  
  423. /**
  424.   * @brief  Second event callback.
  425.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  426.   *                the configuration information for RTC.
  427.   * @retval None
  428.   */
  429. __weak void HAL_RTCEx_RTCEventCallback(RTC_HandleTypeDef *hrtc)
  430. {
  431.   /* NOTE : This function Should not be modified, when the callback is needed,
  432.             the HAL_RTCEx_RTCEventCallback could be implemented in the user file
  433.    */
  434. }
  435.  
  436. /**
  437.   * @brief  Second event error callback.
  438.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  439.   *                the configuration information for RTC.
  440.   * @retval None
  441.   */
  442. __weak void HAL_RTCEx_RTCEventErrorCallback(RTC_HandleTypeDef *hrtc)
  443. {
  444.   /* NOTE : This function Should not be modified, when the callback is needed,
  445.             the HAL_RTCEx_RTCEventErrorCallback could be implemented in the user file
  446.    */
  447. }
  448.  
  449. /**
  450.   * @}
  451.   */
  452.  
  453. /** @defgroup RTCEx_Exported_Functions_Group3 Extended Peripheral Control functions
  454.   * @brief    Extended Peripheral Control functions
  455.   *
  456. @verbatim  
  457.  ===============================================================================
  458.               ##### Extension Peripheral Control functions #####
  459.  ===============================================================================  
  460.     [..]
  461.     This subsection provides functions allowing to
  462.       (+) Writes a data in a specified RTC Backup data register
  463.       (+) Read a data in a specified RTC Backup data register
  464.       (+) Sets the Smooth calibration parameters.
  465.  
  466. @endverbatim
  467.   * @{
  468.   */
  469.  
  470. /**
  471.   * @brief  Writes a data in a specified RTC Backup data register.
  472.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  473.   *                the configuration information for RTC.
  474.   * @param  BackupRegister: RTC Backup data Register number.
  475.   *          This parameter can be: RTC_BKP_DRx where x can be from 1 to 10 (or 42) to
  476.   *                                 specify the register (depending devices).
  477.   * @param  Data: Data to be written in the specified RTC Backup data register.                    
  478.   * @retval None
  479.   */
  480. void HAL_RTCEx_BKUPWrite(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister, uint32_t Data)
  481. {
  482.   uint32_t tmp = 0;
  483.  
  484.   /* Check the parameters */
  485.   assert_param(IS_RTC_BKP(BackupRegister));
  486.  
  487.   tmp = (uint32_t)BKP_BASE;
  488.   tmp += (BackupRegister * 4);
  489.  
  490.   *(__IO uint32_t *) tmp = (Data & BKP_DR1_D);
  491. }
  492.  
  493. /**
  494.   * @brief  Reads data from the specified RTC Backup data Register.
  495.   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains
  496.   *                the configuration information for RTC.
  497.   * @param  BackupRegister: RTC Backup data Register number.
  498.   *          This parameter can be: RTC_BKP_DRx where x can be from 1 to 10 (or 42) to
  499.   *                                 specify the register (depending devices).
  500.   * @retval Read value
  501.   */
  502. uint32_t HAL_RTCEx_BKUPRead(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister)
  503. {
  504.   uint32_t backupregister = 0;
  505.   uint32_t pvalue = 0;
  506.  
  507.   /* Check the parameters */
  508.   assert_param(IS_RTC_BKP(BackupRegister));
  509.  
  510.   backupregister = (uint32_t)BKP_BASE;
  511.   backupregister += (BackupRegister * 4);
  512.  
  513.   pvalue = (*(__IO uint32_t *)(backupregister)) & BKP_DR1_D;
  514.  
  515.   /* Read the specified register */
  516.   return pvalue;
  517. }
  518.  
  519.  
  520. /**
  521.   * @brief  Sets the Smooth calibration parameters.
  522.   * @param  hrtc: RTC handle  
  523.   * @param  SmoothCalibPeriod: Not used (only present for compatibility with another families)
  524.   * @param  SmoothCalibPlusPulses: Not used (only present for compatibility with another families)
  525.   * @param  SmouthCalibMinusPulsesValue: specifies the RTC Clock Calibration value.
  526.   *          This parameter must be a number between 0 and 0x7F.
  527.   * @retval HAL status
  528.   */
  529. HAL_StatusTypeDef HAL_RTCEx_SetSmoothCalib(RTC_HandleTypeDef* hrtc, uint32_t SmoothCalibPeriod, uint32_t SmoothCalibPlusPulses, uint32_t SmouthCalibMinusPulsesValue)
  530. {
  531.   /* Check input parameters */
  532.   if(hrtc == NULL)
  533.   {
  534.      return HAL_ERROR;
  535.   }
  536.  
  537.   /* Check the parameters */
  538.   assert_param(IS_RTC_SMOOTH_CALIB_MINUS(SmouthCalibMinusPulsesValue));
  539.  
  540.   /* Process Locked */
  541.   __HAL_LOCK(hrtc);
  542.  
  543.   hrtc->State = HAL_RTC_STATE_BUSY;
  544.  
  545.   /* Sets RTC Clock Calibration value.*/
  546.   MODIFY_REG(BKP->RTCCR, BKP_RTCCR_CAL, SmouthCalibMinusPulsesValue);
  547.  
  548.   /* Change RTC state */
  549.   hrtc->State = HAL_RTC_STATE_READY;
  550.  
  551.   /* Process Unlocked */
  552.   __HAL_UNLOCK(hrtc);
  553.  
  554.   return HAL_OK;
  555. }
  556.  
  557. /**
  558.   * @}
  559.   */
  560.  
  561. /**
  562.   * @}
  563.   */
  564.  
  565. /**
  566.   * @}
  567.   */
  568.  
  569. #endif /* HAL_RTC_MODULE_ENABLED */
  570.  
  571. /**
  572.   * @}
  573.   */
  574.  
  575. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  576.  
  577.