Back to home page

LXR
 
 

    

File indexing completed on 2025-05-11 08:23:07 

0001 /**
0002   ******************************************************************************
0003   * @file    stm32h7xx_hal_dts.c
0004   * @author  MCD Application Team
0005   * @brief   DTS HAL module driver.
0006   *          This file provides firmware functions to manage the following
0007   *          functionalities of the DTS peripheral:
0008   *           + Initialization and de-initialization functions
0009   *           + Start/Stop operation functions in polling mode.
0010   *           + Start/Stop operation functions in interrupt mode.
0011   *           + Peripheral Control functions
0012   *           + Peripheral State functions
0013   *
0014   ******************************************************************************
0015   * @attention
0016   *
0017   * Copyright (c) 2017 STMicroelectronics.
0018   * All rights reserved.
0019   *
0020   * This software is licensed under terms that can be found in the LICENSE file
0021   * in the root directory of this software component.
0022   * If no LICENSE file comes with this software, it is provided AS-IS.
0023   *
0024   ******************************************************************************
0025   @verbatim
0026 ================================================================================
0027           ##### DTS Peripheral features #####
0028 ================================================================================
0029 
0030   [..]
0031       The STM32h7xx device family integrate one DTS sensor interface :
0032 
0033 
0034             ##### How to use this driver #####
0035 ================================================================================
0036   [..]
0037 
0038 
0039   @endverbatim
0040   ******************************************************************************
0041   */
0042 
0043 /* Includes ------------------------------------------------------------------*/
0044 #include "stm32h7xx_hal.h"
0045 
0046 /** @addtogroup STM32H7xx_HAL_Driver
0047   * @{
0048   */
0049 
0050 #ifdef HAL_DTS_MODULE_ENABLED
0051 
0052 #if defined(DTS)
0053 
0054 /** @defgroup DTS DTS
0055   * @ingroup RTEMSBSPsARMSTM32H7
0056   * @brief DTS HAL module driver
0057   * @{
0058   */
0059 
0060 /* Private typedef -----------------------------------------------------------*/
0061 /* Private define ------------------------------------------------------------*/
0062 /** @addtogroup DTS_Private_Constants
0063   * @{
0064   */
0065 
0066 /* @brief Delay for DTS startup time
0067  * @note  Delay required to get ready for DTS Block.
0068  * @note  Unit: ms
0069  */
0070 #define DTS_DELAY_STARTUP (1UL)
0071 
0072 /* @brief DTS measure ready flag time out value.
0073  * @note  Maximal measurement time is when LSE is selected as ref_clock and
0074  *        maximal sampling time is used, taking calibration into account this
0075  *        is equivalent to ~620 us. Use 5 ms as arbitrary timeout
0076  * @note Unit: ms
0077  */
0078 #define TS_TIMEOUT_MS     (5UL)
0079 
0080 /* @brief DTS factory temperatures
0081  * @note  Unit: degree Celsius
0082  */
0083 #define DTS_FACTORY_TEMPERATURE1 (30UL)
0084 #define DTS_FACTORY_TEMPERATURE2 (130UL)
0085 
0086 /**
0087   * @}
0088   */
0089 
0090 /* Private macro -------------------------------------------------------------*/
0091 /* Private variables ---------------------------------------------------------*/
0092 /* Private function prototypes -----------------------------------------------*/
0093 /* Exported functions --------------------------------------------------------*/
0094 
0095 /** @defgroup DTS_Exported_Functions DTS Exported Functions
0096   * @ingroup RTEMSBSPsARMSTM32H7
0097   * @{
0098   */
0099 
0100 /** @defgroup DTS_Exported_Functions_Group1 Initialization/de-initialization functions
0101   * @ingroup RTEMSBSPsARMSTM32H7
0102  *  @brief    Initialization and de-initialization functions.
0103  *
0104 @verbatim
0105  ===============================================================================
0106               ##### Initialization and de-initialization functions #####
0107  ===============================================================================
0108     [..]  This section provides functions to initialize and de-initialize comparators
0109 
0110 @endverbatim
0111   * @{
0112   */
0113 
0114 /**
0115   * @brief  Initialize the DTS according to the specified
0116   *         parameters in the DTS_InitTypeDef and initialize the associated handle.
0117   * @param  hdts  DTS handle
0118   * @retval HAL status
0119   */
0120 HAL_StatusTypeDef HAL_DTS_Init(DTS_HandleTypeDef *hdts)
0121 {
0122   /* Check the DTS handle allocation */
0123   if (hdts == NULL)
0124   {
0125     return HAL_ERROR;
0126   }
0127 
0128   /* Check the parameters */
0129   assert_param(IS_DTS_ALL_INSTANCE(hdts->Instance));
0130   assert_param(IS_DTS_QUICKMEAS(hdts->Init.QuickMeasure));
0131   assert_param(IS_DTS_REFCLK(hdts->Init.RefClock));
0132   assert_param(IS_DTS_TRIGGERINPUT(hdts->Init.TriggerInput));
0133   assert_param(IS_DTS_SAMPLINGTIME(hdts->Init.SamplingTime));
0134   assert_param(IS_DTS_THRESHOLD(hdts->Init.HighThreshold));
0135   assert_param(IS_DTS_THRESHOLD(hdts->Init.LowThreshold));
0136 
0137   if (hdts->State == HAL_DTS_STATE_RESET)
0138   {
0139 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
0140     /* Reset the DTS callback to the legacy weak callbacks */
0141     hdts->EndCallback       = HAL_DTS_EndCallback;        /* End measure Callback                 */
0142     hdts->LowCallback       = HAL_DTS_LowCallback;        /* low threshold Callback               */
0143     hdts->HighCallback      = HAL_DTS_HighCallback;       /* high threshold Callback              */
0144     hdts->AsyncEndCallback  = HAL_DTS_AsyncEndCallback;   /* Asynchronous end of measure Callback */
0145     hdts->AsyncLowCallback  = HAL_DTS_AsyncLowCallback;   /* Asynchronous low threshold Callback  */
0146     hdts->AsyncHighCallback = HAL_DTS_AsyncHighCallback;  /* Asynchronous high threshold Callback */
0147 
0148     if (hdts->MspInitCallback == NULL)
0149     {
0150       hdts->MspInitCallback = HAL_DTS_MspInit;
0151     }
0152 
0153     /* Init the low level hardware : GPIO, CLOCK, NVIC */
0154     hdts->MspInitCallback(hdts);
0155 #else
0156     /* Init the low level hardware : GPIO, CLOCK, NVIC */
0157     HAL_DTS_MspInit(hdts);
0158 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
0159   }
0160 
0161   /* Change the DTS state */
0162   hdts->State = HAL_DTS_STATE_BUSY;
0163 
0164   /* Check ramp coefficient */
0165   if (hdts->Instance->RAMPVALR == 0UL)
0166   {
0167     return HAL_ERROR;
0168   }
0169 
0170   /* Check factory calibration temperature  */
0171   if (hdts->Instance->T0VALR1 == 0UL)
0172   {
0173     return HAL_ERROR;
0174   }
0175 
0176   /* Check Quick Measure option is enabled or disabled */
0177   if (hdts->Init.QuickMeasure == DTS_QUICKMEAS_DISABLE)
0178   {
0179     /* Check Reference clock selection */
0180     if (hdts->Init.RefClock == DTS_REFCLKSEL_PCLK)
0181     {
0182       assert_param(IS_DTS_DIVIDER_RATIO_NUMBER(hdts->Init.Divider));
0183     }
0184     /* Quick measurement mode disabled */
0185     CLEAR_BIT(hdts->Instance->CFGR1, DTS_CFGR1_Q_MEAS_OPT);
0186   }
0187   else
0188   {
0189     /* DTS_QUICKMEAS_ENABLE shall be used only when the LSE clock is
0190        selected as reference clock */
0191     if (hdts->Init.RefClock != DTS_REFCLKSEL_LSE)
0192     {
0193       return HAL_ERROR;
0194     }
0195 
0196     /* Quick measurement mode enabled - no calibration needed */
0197     SET_BIT(hdts->Instance->CFGR1, DTS_CFGR1_Q_MEAS_OPT);
0198   }
0199 
0200   /* set the DTS clk source */
0201   if (hdts->Init.RefClock == DTS_REFCLKSEL_LSE)
0202   {
0203     SET_BIT(hdts->Instance->CFGR1, DTS_CFGR1_REFCLK_SEL);
0204   }
0205   else
0206   {
0207     CLEAR_BIT(hdts->Instance->CFGR1, DTS_CFGR1_REFCLK_SEL);
0208   }
0209 
0210   MODIFY_REG(hdts->Instance->CFGR1, DTS_CFGR1_HSREF_CLK_DIV, (hdts->Init.Divider << DTS_CFGR1_HSREF_CLK_DIV_Pos));
0211   MODIFY_REG(hdts->Instance->CFGR1, DTS_CFGR1_TS1_SMP_TIME, hdts->Init.SamplingTime);
0212   MODIFY_REG(hdts->Instance->CFGR1, DTS_CFGR1_TS1_INTRIG_SEL, hdts->Init.TriggerInput);
0213   MODIFY_REG(hdts->Instance->ITR1, DTS_ITR1_TS1_HITTHD, (hdts->Init.HighThreshold << DTS_ITR1_TS1_HITTHD_Pos));
0214   MODIFY_REG(hdts->Instance->ITR1, DTS_ITR1_TS1_LITTHD, hdts->Init.LowThreshold);
0215 
0216   /* Change the DTS state */
0217   hdts->State = HAL_DTS_STATE_READY;
0218 
0219   return HAL_OK;
0220 }
0221 
0222 /**
0223   * @brief  DeInitialize the DTS peripheral.
0224   * @note   Deinitialization cannot be performed if the DTS configuration is locked.
0225   *         To unlock the configuration, perform a system reset.
0226   * @param  hdts  DTS handle
0227   * @retval HAL status
0228   */
0229 HAL_StatusTypeDef HAL_DTS_DeInit(DTS_HandleTypeDef *hdts)
0230 {
0231   /* Check the DTS handle allocation */
0232   if (hdts == NULL)
0233   {
0234     return HAL_ERROR;
0235   }
0236 
0237   /* Check the parameter */
0238   assert_param(IS_DTS_ALL_INSTANCE(hdts->Instance));
0239 
0240   /* Set DTS_CFGR register to reset value */
0241   CLEAR_REG(hdts->Instance->CFGR1);
0242 
0243 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
0244   if (hdts->MspDeInitCallback == NULL)
0245   {
0246     hdts->MspDeInitCallback = HAL_DTS_MspDeInit;
0247   }
0248 
0249   /* DeInit the low level hardware: CLOCK, NVIC.*/
0250   hdts->MspDeInitCallback(hdts);
0251 #else
0252   /* DeInit the low level hardware: CLOCK, NVIC.*/
0253   HAL_DTS_MspDeInit(hdts);
0254 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
0255 
0256   hdts->State = HAL_DTS_STATE_RESET;
0257 
0258   return HAL_OK;
0259 }
0260 
0261 /**
0262   * @brief  Initialize the DTS MSP.
0263   * @param  hdts  DTS handle
0264   * @retval None
0265   */
0266 __weak void HAL_DTS_MspInit(DTS_HandleTypeDef *hdts)
0267 {
0268   /* Prevent unused argument(s) compilation warning */
0269   UNUSED(hdts);
0270 
0271   /* NOTE : This function should not be modified, when the callback is needed,
0272   the HAL_DTS_MspInit could be implemented in the user file
0273   */
0274 }
0275 
0276 /**
0277   * @brief  DeInitialize the DTS MSP.
0278   * @param  hdts  DTS handle
0279   * @retval None
0280   */
0281 __weak void HAL_DTS_MspDeInit(DTS_HandleTypeDef *hdts)
0282 {
0283   /* Prevent unused argument(s) compilation warning */
0284   UNUSED(hdts);
0285 
0286   /* NOTE : This function should not be modified, when the callback is needed,
0287   the HAL_DTS_MspDeInit could be implemented in the user file
0288   */
0289 }
0290 
0291 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
0292 /**
0293   * @brief  Register a user DTS callback to be used instead of the weak predefined callback.
0294   * @param  hdts DTS handle.
0295   * @param  CallbackID ID of the callback to be registered.
0296   *         This parameter can be one of the following values:
0297   *           @arg @ref HAL_DTS_MEAS_COMPLETE_CB_ID measure complete callback ID.
0298   *           @arg @ref HAL_DTS_ASYNC_MEAS_COMPLETE_CB_ID asynchronous measure complete callback ID.
0299   *           @arg @ref HAL_DTS_LOW_THRESHOLD_CB_ID low threshold detection callback ID.
0300   *           @arg @ref HAL_DTS_ASYNC_LOW_THRESHOLD_CB_ID asynchronous low threshold detection callback ID.
0301   *           @arg @ref HAL_DTS_HIGH_THRESHOLD_CB_ID high threshold detection callback ID.
0302   *           @arg @ref HAL_DTS_ASYNC_HIGH_THRESHOLD_CB_ID asynchronous high threshold detection callback ID.
0303   *           @arg @ref HAL_DTS_MSPINIT_CB_ID MSP init callback ID.
0304   *           @arg @ref HAL_DTS_MSPDEINIT_CB_ID MSP de-init callback ID.
0305   * @param  pCallback pointer to the callback function.
0306   * @retval HAL status.
0307   */
0308 HAL_StatusTypeDef HAL_DTS_RegisterCallback(DTS_HandleTypeDef        *hdts,
0309                                            HAL_DTS_CallbackIDTypeDef CallbackID,
0310                                            pDTS_CallbackTypeDef      pCallback)
0311 {
0312   HAL_StatusTypeDef status = HAL_OK;
0313 
0314   /* Check parameters */
0315   if (pCallback == NULL)
0316   {
0317     /* Update status */
0318     status = HAL_ERROR;
0319   }
0320   else
0321   {
0322     if (hdts->State == HAL_DTS_STATE_READY)
0323     {
0324       switch (CallbackID)
0325       {
0326         case HAL_DTS_MEAS_COMPLETE_CB_ID :
0327           hdts->EndCallback = pCallback;
0328           break;
0329         case HAL_DTS_ASYNC_MEAS_COMPLETE_CB_ID :
0330           hdts->AsyncEndCallback = pCallback;
0331           break;
0332         case HAL_DTS_LOW_THRESHOLD_CB_ID :
0333           hdts->LowCallback = pCallback;
0334           break;
0335         case HAL_DTS_ASYNC_LOW_THRESHOLD_CB_ID :
0336           hdts->AsyncLowCallback = pCallback;
0337           break;
0338         case HAL_DTS_HIGH_THRESHOLD_CB_ID :
0339           hdts->HighCallback = pCallback;
0340           break;
0341         case HAL_DTS_ASYNC_HIGH_THRESHOLD_CB_ID :
0342           hdts->AsyncHighCallback = pCallback;
0343           break;
0344         case HAL_DTS_MSPINIT_CB_ID :
0345           hdts->MspInitCallback = pCallback;
0346           break;
0347         case HAL_DTS_MSPDEINIT_CB_ID :
0348           hdts->MspDeInitCallback = pCallback;
0349           break;
0350         default :
0351           /* Update status */
0352           status = HAL_ERROR;
0353           break;
0354       }
0355     }
0356     else if (hdts->State == HAL_DTS_STATE_RESET)
0357     {
0358       switch (CallbackID)
0359       {
0360         case HAL_DTS_MSPINIT_CB_ID :
0361           hdts->MspInitCallback = pCallback;
0362           break;
0363         case HAL_DTS_MSPDEINIT_CB_ID :
0364           hdts->MspDeInitCallback = pCallback;
0365           break;
0366         default :
0367           /* Update status */
0368           status = HAL_ERROR;
0369           break;
0370       }
0371     }
0372     else
0373     {
0374       /* Update status */
0375       status = HAL_ERROR;
0376     }
0377   }
0378 
0379   /* Return function status */
0380   return status;
0381 }
0382 
0383 /**
0384   * @brief  Unregister a user DTS callback.
0385   *         DTS callback is redirected to the weak predefined callback.
0386   * @param  hdts DTS handle.
0387   * @param  CallbackID ID of the callback to be unregistered.
0388   *         This parameter can be one of the following values:
0389   *           @arg @ref HAL_DTS_MEAS_COMPLETE_CB_ID measure complete callback ID.
0390   *           @arg @ref HAL_DTS_ASYNC_MEAS_COMPLETE_CB_ID asynchronous measure complete callback ID.
0391   *           @arg @ref HAL_DTS_LOW_THRESHOLD_CB_ID low threshold detection callback ID.
0392   *           @arg @ref HAL_DTS_ASYNC_LOW_THRESHOLD_CB_ID asynchronous low threshold detection callback ID.
0393   *           @arg @ref HAL_DTS_HIGH_THRESHOLD_CB_ID high threshold detection callback ID.
0394   *           @arg @ref HAL_DTS_ASYNC_HIGH_THRESHOLD_CB_ID asynchronous high threshold detection callback ID.
0395   *           @arg @ref HAL_DTS_MSPINIT_CB_ID MSP init callback ID.
0396   *           @arg @ref HAL_DTS_MSPDEINIT_CB_ID MSP de-init callback ID.
0397   * @retval HAL status.
0398   */
0399 HAL_StatusTypeDef HAL_DTS_UnRegisterCallback(DTS_HandleTypeDef        *hdts,
0400                                              HAL_DTS_CallbackIDTypeDef CallbackID)
0401 {
0402   HAL_StatusTypeDef status = HAL_OK;
0403 
0404   if (hdts->State == HAL_DTS_STATE_READY)
0405   {
0406     switch (CallbackID)
0407     {
0408       case HAL_DTS_MEAS_COMPLETE_CB_ID :
0409         hdts->EndCallback = HAL_DTS_EndCallback;
0410         break;
0411       case HAL_DTS_ASYNC_MEAS_COMPLETE_CB_ID :
0412         hdts->AsyncEndCallback = HAL_DTS_AsyncEndCallback;
0413         break;
0414       case HAL_DTS_LOW_THRESHOLD_CB_ID :
0415         hdts->LowCallback = HAL_DTS_LowCallback;
0416         break;
0417       case HAL_DTS_ASYNC_LOW_THRESHOLD_CB_ID :
0418         hdts->AsyncLowCallback = HAL_DTS_AsyncLowCallback;
0419         break;
0420       case HAL_DTS_HIGH_THRESHOLD_CB_ID :
0421         hdts->HighCallback = HAL_DTS_HighCallback;
0422         break;
0423       case HAL_DTS_ASYNC_HIGH_THRESHOLD_CB_ID :
0424         hdts->AsyncHighCallback = HAL_DTS_AsyncHighCallback;
0425         break;
0426       case HAL_DTS_MSPINIT_CB_ID :
0427         hdts->MspInitCallback = HAL_DTS_MspInit;
0428         break;
0429       case HAL_DTS_MSPDEINIT_CB_ID :
0430         hdts->MspDeInitCallback = HAL_DTS_MspDeInit;
0431         break;
0432       default :
0433         /* Update status */
0434         status = HAL_ERROR;
0435         break;
0436     }
0437   }
0438   else if (hdts->State == HAL_DTS_STATE_RESET)
0439   {
0440     switch (CallbackID)
0441     {
0442       case HAL_DTS_MSPINIT_CB_ID :
0443         hdts->MspInitCallback = HAL_DTS_MspInit;
0444         break;
0445       case HAL_DTS_MSPDEINIT_CB_ID :
0446         hdts->MspDeInitCallback = HAL_DTS_MspDeInit;
0447         break;
0448       default :
0449         /* Update status */
0450         status = HAL_ERROR;
0451         break;
0452     }
0453   }
0454   else
0455   {
0456     /* Update status */
0457     status = HAL_ERROR;
0458   }
0459 
0460   /* Return function status */
0461   return status;
0462 }
0463 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
0464 
0465 /**
0466   * @}
0467   */
0468 
0469 /** @defgroup DTS_Exported_Functions_Group2 Start-Stop operation functions
0470   * @ingroup RTEMSBSPsARMSTM32H7
0471  *  @brief   Start-Stop operation functions.
0472  *
0473 @verbatim
0474  ===============================================================================
0475                       ##### DTS Start Stop operation functions #####
0476  ===============================================================================
0477     [..]  This section provides functions allowing to:
0478       (+) Start a DTS Sensor without interrupt.
0479       (+) Stop a DTS Sensor without interrupt.
0480       (+) Start a DTS Sensor with interrupt generation.
0481       (+) Stop a DTS Sensor with interrupt generation.
0482 
0483 @endverbatim
0484   * @{
0485   */
0486 
0487 /**
0488   * @brief  Start the DTS sensor.
0489   * @param  hdts  DTS handle
0490   * @retval HAL status
0491   */
0492 HAL_StatusTypeDef HAL_DTS_Start(DTS_HandleTypeDef *hdts)
0493 {
0494   uint32_t Ref_Time;
0495 
0496   /* Check the DTS handle allocation */
0497   if (hdts == NULL)
0498   {
0499     return HAL_ERROR;
0500   }
0501 
0502   if (hdts->State == HAL_DTS_STATE_READY)
0503   {
0504     hdts->State = HAL_DTS_STATE_BUSY;
0505 
0506     /* Enable DTS sensor */
0507     __HAL_DTS_ENABLE(hdts);
0508 
0509     /* Get Start Tick*/
0510     Ref_Time = HAL_GetTick();
0511 
0512     /* Wait till TS1_RDY flag is set */
0513     while (__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_RDY) == RESET)
0514     {
0515       if ((HAL_GetTick() - Ref_Time) > DTS_DELAY_STARTUP)
0516       {
0517         return HAL_TIMEOUT;
0518       }
0519     }
0520 
0521     if (__HAL_DTS_GET_TRIGGER(hdts) == DTS_TRIGGER_HW_NONE)
0522     {
0523       /* Start continuous measures */
0524       SET_BIT(hdts->Instance->CFGR1, DTS_CFGR1_TS1_START);
0525 
0526       /* Ensure start is taken into account */
0527       HAL_Delay(TS_TIMEOUT_MS);
0528     }
0529 
0530     hdts->State = HAL_DTS_STATE_READY;
0531   }
0532   else
0533   {
0534     return HAL_BUSY;
0535   }
0536 
0537   return HAL_OK;
0538 }
0539 
0540 /**
0541   * @brief  Stop the DTS Sensor.
0542   * @param  hdts  DTS handle
0543   * @retval HAL status
0544   */
0545 HAL_StatusTypeDef HAL_DTS_Stop(DTS_HandleTypeDef *hdts)
0546 {
0547   /* Check the DTS handle allocation */
0548   if (hdts == NULL)
0549   {
0550     return HAL_ERROR;
0551   }
0552 
0553   if (hdts->State == HAL_DTS_STATE_READY)
0554   {
0555     hdts->State = HAL_DTS_STATE_BUSY;
0556 
0557     if (__HAL_DTS_GET_TRIGGER(hdts) == DTS_TRIGGER_HW_NONE)
0558     {
0559       CLEAR_BIT(hdts->Instance->CFGR1, DTS_CFGR1_TS1_START);
0560     }
0561 
0562     /* Disable the selected DTS sensor */
0563     __HAL_DTS_DISABLE(hdts);
0564 
0565     hdts->State = HAL_DTS_STATE_READY;
0566   }
0567   else
0568   {
0569     return HAL_BUSY;
0570   }
0571 
0572   return HAL_OK;
0573 }
0574 
0575 /**
0576   * @brief  Enable the interrupt(s) and start the DTS sensor
0577   * @param  hdts  DTS handle
0578   * @retval HAL status
0579   */
0580 HAL_StatusTypeDef HAL_DTS_Start_IT(DTS_HandleTypeDef *hdts)
0581 {
0582   uint32_t Ref_Time;
0583 
0584   /* Check the DTS handle allocation */
0585   if (hdts == NULL)
0586   {
0587     return HAL_ERROR;
0588   }
0589 
0590   if (hdts->State == HAL_DTS_STATE_READY)
0591   {
0592     hdts->State = HAL_DTS_STATE_BUSY;
0593 
0594     /* On Asynchronous mode enable the asynchronous IT */
0595     if (hdts->Init.RefClock == DTS_REFCLKSEL_LSE)
0596     {
0597       __HAL_DTS_ENABLE_IT(hdts, DTS_IT_TS1_AITE | DTS_IT_TS1_AITL | DTS_IT_TS1_AITH);
0598     }
0599     else
0600     {
0601       /* Enable the IT(s) */
0602       __HAL_DTS_ENABLE_IT(hdts, DTS_IT_TS1_ITE | DTS_IT_TS1_ITL | DTS_IT_TS1_ITH);
0603     }
0604 
0605     /* Enable the selected DTS sensor */
0606     __HAL_DTS_ENABLE(hdts);
0607 
0608     /* Get Start Tick*/
0609     Ref_Time = HAL_GetTick();
0610 
0611     /* Wait till TS1_RDY flag is set */
0612     while (__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_RDY) == RESET)
0613     {
0614       if ((HAL_GetTick() - Ref_Time) > DTS_DELAY_STARTUP)
0615       {
0616         return HAL_TIMEOUT;
0617       }
0618     }
0619 
0620     if (__HAL_DTS_GET_TRIGGER(hdts) == DTS_TRIGGER_HW_NONE)
0621     {
0622       /* Start continuous measures */
0623       SET_BIT(hdts->Instance->CFGR1, DTS_CFGR1_TS1_START);
0624 
0625       /* Ensure start is taken into account */
0626       HAL_Delay(TS_TIMEOUT_MS);
0627     }
0628 
0629     hdts->State = HAL_DTS_STATE_READY;
0630   }
0631   else
0632   {
0633     return HAL_BUSY;
0634   }
0635 
0636   return HAL_OK;
0637 }
0638 
0639 /**
0640   * @brief  Disable the interrupt(s) and stop the DTS sensor.
0641   * @param  hdts  DTS handle
0642   * @retval HAL status
0643   */
0644 HAL_StatusTypeDef HAL_DTS_Stop_IT(DTS_HandleTypeDef *hdts)
0645 {
0646   /* Check the DTS handle allocation */
0647   if (hdts == NULL)
0648   {
0649     return HAL_ERROR;
0650   }
0651 
0652   if (hdts->State == HAL_DTS_STATE_READY)
0653   {
0654     hdts->State = HAL_DTS_STATE_BUSY;
0655 
0656     /* On Asynchronous mode disable the asynchronous IT */
0657     if (hdts->Init.RefClock == DTS_REFCLKSEL_LSE)
0658     {
0659       __HAL_DTS_DISABLE_IT(hdts, DTS_IT_TS1_AITE | DTS_IT_TS1_AITL | DTS_IT_TS1_AITH);
0660     }
0661     else
0662     {
0663       /* Disable the IT(s) */
0664       __HAL_DTS_DISABLE_IT(hdts, DTS_IT_TS1_ITE | DTS_IT_TS1_ITL | DTS_IT_TS1_ITH);
0665     }
0666 
0667     if (__HAL_DTS_GET_TRIGGER(hdts) == DTS_TRIGGER_HW_NONE)
0668     {
0669       CLEAR_BIT(hdts->Instance->CFGR1, DTS_CFGR1_TS1_START);
0670     }
0671 
0672     /* Disable the selected DTS sensor */
0673     __HAL_DTS_DISABLE(hdts);
0674 
0675     hdts->State = HAL_DTS_STATE_READY;
0676   }
0677   else
0678   {
0679     return HAL_BUSY;
0680   }
0681 
0682   return HAL_OK;
0683 }
0684 
0685 /**
0686   * @brief  Get temperature from DTS
0687   * @param  hdts         DTS handle
0688   * @param  Temperature  Temperature in deg C
0689   * @note This function retrieves latest available measure
0690   * @retval HAL status
0691   */
0692 HAL_StatusTypeDef HAL_DTS_GetTemperature(DTS_HandleTypeDef *hdts, int32_t *Temperature)
0693 {
0694   uint32_t freq_meas;
0695   uint32_t samples;
0696   uint32_t t0_temp;
0697   uint32_t t0_freq;
0698   uint32_t ramp_coeff;
0699 
0700   if (hdts->State == HAL_DTS_STATE_READY)
0701   {
0702     hdts->State = HAL_DTS_STATE_BUSY;
0703 
0704     /* Get the total number of samples */
0705     samples = (hdts->Instance->DR & DTS_DR_TS1_MFREQ);
0706 
0707     if ((hdts->Init.SamplingTime == 0UL) || (samples == 0UL))
0708     {
0709       hdts->State = HAL_DTS_STATE_READY;
0710       return HAL_ERROR;
0711     }
0712 
0713     if ((hdts->Init.RefClock) == DTS_REFCLKSEL_LSE)
0714     {
0715       freq_meas = (LSE_VALUE * samples) / (hdts->Init.SamplingTime >> DTS_CFGR1_TS1_SMP_TIME_Pos); /* On Hz */
0716     }
0717     else
0718     {
0719       freq_meas = (HAL_RCCEx_GetD3PCLK1Freq() * (hdts->Init.SamplingTime >> DTS_CFGR1_TS1_SMP_TIME_Pos)) / samples; /* On Hz */
0720     }
0721 
0722     /* Read factory settings */
0723     t0_temp = hdts->Instance->T0VALR1 >> DTS_T0VALR1_TS1_T0_Pos;
0724 
0725     if (t0_temp == 0UL)
0726     {
0727       t0_temp = DTS_FACTORY_TEMPERATURE1; /* 30 deg C */
0728     }
0729     else if (t0_temp == 1UL)
0730     {
0731       t0_temp = DTS_FACTORY_TEMPERATURE2; /* 130 deg C */
0732     }
0733     else
0734     {
0735       hdts->State = HAL_DTS_STATE_READY;
0736       return HAL_ERROR;
0737     }
0738 
0739     t0_freq = (hdts->Instance->T0VALR1 & DTS_T0VALR1_TS1_FMT0) * 100UL; /* Hz */
0740 
0741     ramp_coeff = hdts->Instance->RAMPVALR & DTS_RAMPVALR_TS1_RAMP_COEFF; /* deg C/Hz */
0742 
0743     if (ramp_coeff == 0UL)
0744     {
0745       hdts->State = HAL_DTS_STATE_READY;
0746       return HAL_ERROR;
0747     }
0748 
0749     /* Figure out the temperature deg C */
0750     *Temperature = (int32_t)t0_temp + (((int32_t)freq_meas - (int32_t)t0_freq) / (int32_t)ramp_coeff);
0751 
0752     hdts->State = HAL_DTS_STATE_READY;
0753   }
0754   else
0755   {
0756     return HAL_BUSY;
0757   }
0758 
0759   return HAL_OK;
0760 }
0761 
0762 /**
0763   * @brief  DTS sensor IRQ Handler.
0764   * @param  hdts  DTS handle
0765   * @retval None
0766   */
0767 void HAL_DTS_IRQHandler(DTS_HandleTypeDef *hdts)
0768 {
0769   /* Check end of measure Asynchronous IT */
0770   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_AITE)) != RESET)
0771   {
0772       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_AITE);
0773 
0774 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
0775       hdts->AsyncEndCallback(hdts);
0776 #else
0777       HAL_DTS_AsyncEndCallback(hdts);
0778 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
0779   }
0780 
0781   /* Check low threshold Asynchronous IT */
0782   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_AITL)) != RESET)
0783   {
0784       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_AITL);
0785 
0786 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
0787       hdts->AsyncLowCallback(hdts);
0788 #else
0789       HAL_DTS_AsyncLowCallback(hdts);
0790 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
0791   }
0792 
0793   /* Check high threshold Asynchronous IT */
0794   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_AITH)) != RESET)
0795   {
0796       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_AITH);
0797 
0798 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
0799       hdts->AsyncHighCallback(hdts);
0800 #else
0801       HAL_DTS_AsyncHighCallback(hdts);
0802 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
0803   }
0804 
0805   /* Check end of measure IT */
0806   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_ITE)) != RESET)
0807   {
0808       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_ITE);
0809 
0810 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
0811       hdts->EndCallback(hdts);
0812 #else
0813       HAL_DTS_EndCallback(hdts);
0814 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
0815   }
0816 
0817   /* Check low threshold IT */
0818   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_ITL)) != RESET)
0819   {
0820       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_ITL);
0821 
0822 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
0823       hdts->LowCallback(hdts);
0824 #else
0825       HAL_DTS_LowCallback(hdts);
0826 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
0827   }
0828 
0829   /* Check high threshold IT */
0830   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_ITH)) != RESET)
0831   {
0832       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_ITH);
0833 
0834 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
0835       hdts->HighCallback(hdts);
0836 #else
0837       HAL_DTS_HighCallback(hdts);
0838 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
0839   }
0840 }
0841 
0842 /**
0843   * @brief  DTS Sensor End measure callback.
0844   * @param  hdts  DTS handle
0845   * @retval None
0846   */
0847 __weak void HAL_DTS_EndCallback(DTS_HandleTypeDef *hdts)
0848 {
0849   /* Prevent unused argument(s) compilation warning */
0850   UNUSED(hdts);
0851 
0852   /* NOTE : This function should not be modified, when the callback is needed,
0853   the HAL_DTS_EndCallback should be implemented in the user file
0854   */
0855 }
0856 
0857 /**
0858   * @brief  DTS Sensor low threshold measure callback.
0859   * @param  hdts  DTS handle
0860   * @retval None
0861   */
0862 __weak void HAL_DTS_LowCallback(DTS_HandleTypeDef *hdts)
0863 {
0864   /* Prevent unused argument(s) compilation warning */
0865   UNUSED(hdts);
0866 
0867   /* NOTE : This function should not be modified, when the callback is needed,
0868   the HAL_DTS_LowCallback should be implemented in the user file
0869   */
0870 }
0871 
0872 /**
0873   * @brief  DTS Sensor high threshold measure callback.
0874   * @param  hdts  DTS handle
0875   * @retval None
0876   */
0877 __weak void HAL_DTS_HighCallback(DTS_HandleTypeDef *hdts)
0878 {
0879   /* Prevent unused argument(s) compilation warning */
0880   UNUSED(hdts);
0881 
0882   /* NOTE : This function should not be modified, when the callback is needed,
0883   the HAL_DTS_HighCallback should be implemented in the user file
0884   */
0885 }
0886 
0887 /**
0888   * @brief  DTS Sensor asynchronous end measure callback.
0889   * @param  hdts  DTS handle
0890   * @retval None
0891   */
0892 __weak void HAL_DTS_AsyncEndCallback(DTS_HandleTypeDef *hdts)
0893 {
0894   /* Prevent unused argument(s) compilation warning */
0895   UNUSED(hdts);
0896 
0897   /* NOTE : This function should not be modified, when the callback is needed,
0898   the HAL_DTS_AsyncEndCallback should be implemented in the user file
0899   */
0900 }
0901 
0902 /**
0903   * @brief  DTS Sensor asynchronous low threshold measure callback.
0904   * @param  hdts  DTS handle
0905   * @retval None
0906   */
0907 __weak void HAL_DTS_AsyncLowCallback(DTS_HandleTypeDef *hdts)
0908 {
0909   /* Prevent unused argument(s) compilation warning */
0910   UNUSED(hdts);
0911 
0912   /* NOTE : This function should not be modified, when the callback is needed,
0913   the HAL_DTS_AsyncLowCallback should be implemented in the user file
0914   */
0915 }
0916 
0917 /**
0918   * @brief  DTS Sensor asynchronous high threshold measure callback.
0919   * @param  hdts  DTS handle
0920   * @retval None
0921   */
0922 __weak void HAL_DTS_AsyncHighCallback(DTS_HandleTypeDef *hdts)
0923 {
0924   /* Prevent unused argument(s) compilation warning */
0925   UNUSED(hdts);
0926 
0927   /* NOTE : This function should not be modified, when the callback is needed,
0928   the HAL_DTS_AsyncHighCallback should be implemented in the user file
0929   */
0930 }
0931 
0932 /**
0933   * @}
0934   */
0935 
0936 /** @defgroup DTS_Exported_Functions_Group3 Peripheral State functions
0937   * @ingroup RTEMSBSPsARMSTM32H7
0938  *  @brief   Peripheral State functions.
0939  *
0940 @verbatim
0941  ===============================================================================
0942                       ##### Peripheral State functions #####
0943  ===============================================================================
0944     [..]
0945     This subsection permits to get in run-time the status of the peripheral.
0946 
0947 @endverbatim
0948   * @{
0949   */
0950 
0951 /**
0952   * @brief  Return the DTS handle state.
0953   * @param  hdts  DTS handle
0954   * @retval HAL state
0955   */
0956 HAL_DTS_StateTypeDef HAL_DTS_GetState(DTS_HandleTypeDef *hdts)
0957 {
0958   /* Check the DTS handle allocation */
0959   if (hdts == NULL)
0960   {
0961     return HAL_DTS_STATE_RESET;
0962   }
0963 
0964   /* Return DTS handle state */
0965   return hdts->State;
0966 }
0967 /**
0968   * @}
0969   */
0970 
0971 /**
0972   * @}
0973   */
0974 
0975 /**
0976   * @}
0977   */
0978 
0979 #endif /* DTS */
0980 
0981 #endif /* HAL_DTS_MODULE_ENABLED */
0982 
0983 /**
0984   * @}
0985   */
0986
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!