lib/main/STM32H7/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dts.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32h7xx_hal_dts.c
   4   * @author  MCD Application Team
   5   * @brief   DTS HAL module driver.
   6   *          This file provides firmware functions to manage the following
   7   *          functionalities of the DTS peripheral:
   8   *           + Initialization and de-initialization functions
   9   *           + Start/Stop operation functions in polling mode.
  10   *           + Start/Stop operation functions in interrupt mode.
  11   *           + Peripheral Control functions
  12   *           + Peripheral State functions
  13   *
  14   @verbatim
  15 ================================================================================
  16           ##### DTS Peripheral features #####
  17 ================================================================================
  18
  19   [..]
  20       The STM32h7xx device family integrate one DTS sensor interface :
  21
  22
  23             ##### How to use this driver #####
  24 ================================================================================
  25   [..]
  26
  27
  28   @endverbatim
  29   ******************************************************************************
  30   * @attention
  31   *
  32   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
  33   * All rights reserved.</center></h2>
  34   *
  35   * This software component is licensed by ST under BSD 3-Clause license,
  36   * the "License"; You may not use this file except in compliance with the
  37   * License. You may obtain a copy of the License at:
  38   *                        opensource.org/licenses/BSD-3-Clause
  39   *
  40   ******************************************************************************
  41   */
  42
  43 /* Includes ------------------------------------------------------------------*/
  44 #include "stm32h7xx_hal.h"
  45
  46 /** @addtogroup STM32H7xx_HAL_Driver
  47   * @{
  48   */
  49
  50 #ifdef HAL_DTS_MODULE_ENABLED
  51
  52 #if defined(DTS)
  53
  54 /** @defgroup DTS DTS
  55   * @brief DTS HAL module driver
  56   * @{
  57   */
  58
  59 /* Private typedef -----------------------------------------------------------*/
  60 /* Private define ------------------------------------------------------------*/
  61 /** @addtogroup DTS_Private_Constants
  62   * @{
  63   */
  64
  65 /* @brief Delay for DTS startup time
  66  * @note  Delay required to get ready for DTS Block.
  67  * @note  Unit: ms
  68  */
  69 #define DTS_DELAY_STARTUP (1UL)
  70
  71 /* @brief DTS measure ready flag time out value.
  72  * @note  Maximal measurement time is when LSE is selected as ref_clock and
  73  *        maximal sampling time is used, taking calibration into account this
  74  *        is equivalent to ~620 us. Use 5 ms as arbitrary timeout
  75  * @note Unit: ms
  76  */
  77 #define TS_TIMEOUT_MS     (5UL)
  78
  79 /* Private macro -------------------------------------------------------------*/
  80 /* Private variables ---------------------------------------------------------*/
  81 /* Private function prototypes -----------------------------------------------*/
  82 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
  83 static void DTS_ResetCallback(DTS_HandleTypeDef *hdts);
  84 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
  85 /* Exported functions --------------------------------------------------------*/
  86
  87 /** @defgroup DTS_Exported_Functions DTS Exported Functions
  88   * @{
  89   */
  90
  91 /** @defgroup DTS_Exported_Functions_Group1 Initialization/de-initialization functions
  92  *  @brief    Initialization and de-initialization functions.
  93  *
  94 @verbatim
  95  ===============================================================================
  96               ##### Initialization and de-initialization functions #####
  97  ===============================================================================
  98     [..]  This section provides functions to initialize and de-initialize comparators
  99
 100 @endverbatim
 101   * @{
 102   */
 103
 104 /**
 105   * @brief  Initialize the DTS according to the specified
 106   *         parameters in the DTS_InitTypeDef and initialize the associated handle.
 107   * @param  hdts  DTS handle
 108   * @retval HAL status
 109   */
 110 HAL_StatusTypeDef HAL_DTS_Init(DTS_HandleTypeDef *hdts)
 111 {
 112   /* Check the DTS handle allocation */
 113   if (hdts == NULL)
 114   {
 115     return HAL_ERROR;
 116   }
 117
 118   /* Check the parameters */
 119   assert_param(IS_DTS_ALL_INSTANCE(hdts->Instance));
 120   assert_param(IS_DTS_QUICKMEAS(hdts->Init.QuickMeasure));
 121   assert_param(IS_DTS_REFCLK(hdts->Init.RefClock));
 122   assert_param(IS_DTS_TRIGGERINPUT(hdts->Init.TriggerInput));
 123   assert_param(IS_DTS_SAMPLINGTIME(hdts->Init.SamplingTime));
 124   assert_param(IS_DTS_THRESHOLD(hdts->Init.HighThreshold));
 125   assert_param(IS_DTS_THRESHOLD(hdts->Init.LowThreshold));
 126
 127   if (hdts->State == HAL_DTS_STATE_RESET)
 128   {
 129 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
 130     /* Reset interrupt callbacks to legacy weak callbacks */
 131     DTS_ResetCallback(hdts);
 132
 133     if (hdts->MspInitCallback == NULL)
 134     {
 135       hdts->MspInitCallback = HAL_DTS_MspInit;
 136     }
 137
 138     /* Init the low level hardware : GPIO, CLOCK, NVIC */
 139     hdts->MspInitCallback(hdts);
 140 #else
 141     /* Init the low level hardware : GPIO, CLOCK, NVIC */
 142     HAL_DTS_MspInit(hdts);
 143 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
 144   }
 145
 146   /* Change the DTS state */
 147   hdts->State = HAL_DTS_STATE_BUSY;
 148
 149   /* Check ramp coefficient */
 150   if (hdts->Instance->RAMPVALR == 0UL)
 151   {
 152     return HAL_ERROR;
 153   }
 154
 155   /* Check factory calibration temperature  */
 156   if (hdts->Instance->T0VALR1 == 0UL)
 157   {
 158     return HAL_ERROR;
 159   }
 160
 161   /* Check Quick Measure option is enabled or disabled */
 162   if (hdts->Init.QuickMeasure == DTS_QUICKMEAS_DISABLE)
 163   {
 164     /* Check Reference clock selection */
 165     if (hdts->Init.RefClock == DTS_REFCLKSEL_PCLK)
 166     {
 167       assert_param(IS_DTS_DIVIDER_RATIO_NUMBER(hdts->Init.Divider));
 168     }
 169     /* Quick measurement mode disabled */
 170     CLEAR_BIT(hdts->Instance->CFGR1, DTS_CFGR1_Q_MEAS_OPT);
 171   }
 172   else
 173   {
 174     /* DTS_QUICKMEAS_ENABLE shall be used only when the LSE clock is
 175        selected as reference clock */
 176     if (hdts->Init.RefClock != DTS_REFCLKSEL_LSE)
 177     {
 178       return HAL_ERROR;
 179     }
 180
 181     /* Quick measurement mode enabled - no calibration needed */
 182     SET_BIT(hdts->Instance->CFGR1, DTS_CFGR1_Q_MEAS_OPT);
 183   }
 184
 185   /* set the DTS clk source */
 186   if (hdts->Init.RefClock == DTS_REFCLKSEL_LSE)
 187   {
 188     SET_BIT(hdts->Instance->CFGR1, DTS_CFGR1_REFCLK_SEL);
 189   }
 190   else
 191   {
 192     CLEAR_BIT(hdts->Instance->CFGR1, DTS_CFGR1_REFCLK_SEL);
 193   }
 194
 195   MODIFY_REG(hdts->Instance->CFGR1, DTS_CFGR1_HSREF_CLK_DIV, (hdts->Init.Divider << DTS_CFGR1_HSREF_CLK_DIV_Pos));
 196   MODIFY_REG(hdts->Instance->CFGR1, DTS_CFGR1_TS1_SMP_TIME, hdts->Init.SamplingTime);
 197   MODIFY_REG(hdts->Instance->CFGR1, DTS_CFGR1_TS1_INTRIG_SEL, hdts->Init.TriggerInput);
 198   MODIFY_REG(hdts->Instance->ITR1, DTS_ITR1_TS1_HITTHD, (hdts->Init.HighThreshold << DTS_ITR1_TS1_HITTHD_Pos));
 199   MODIFY_REG(hdts->Instance->ITR1, DTS_ITR1_TS1_LITTHD, hdts->Init.LowThreshold);
 200
 201   /* Change the DTS state */
 202   hdts->State = HAL_DTS_STATE_READY;
 203
 204   return HAL_OK;
 205 }
 206
 207 /**
 208   * @brief  DeInitialize the DTS peripheral.
 209   * @note   Deinitialization cannot be performed if the DTS configuration is locked.
 210   *         To unlock the configuration, perform a system reset.
 211   * @param  hdts  DTS handle
 212   * @retval HAL status
 213   */
 214 HAL_StatusTypeDef HAL_DTS_DeInit(DTS_HandleTypeDef *hdts)
 215 {
 216   /* Check the DTS handle allocation */
 217   if (hdts == NULL)
 218   {
 219     return HAL_ERROR;
 220   }
 221
 222   /* Check the parameter */
 223   assert_param(IS_DTS_ALL_INSTANCE(hdts->Instance));
 224
 225   /* Set DTS_CFGR register to reset value */
 226   CLEAR_REG(hdts->Instance->CFGR1);
 227
 228 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
 229   if (hdts->MspDeInitCallback == NULL)
 230   {
 231     hdts->MspDeInitCallback = HAL_DTS_MspDeInit;
 232   }
 233
 234   /* DeInit the low level hardware: CLOCK, NVIC.*/
 235   hdts->MspDeInitCallback(hdts);
 236 #else
 237   /* DeInit the low level hardware: CLOCK, NVIC.*/
 238   HAL_DTS_MspDeInit(hdts);
 239 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
 240
 241   hdts->State = HAL_DTS_STATE_RESET;
 242
 243   return HAL_OK;
 244 }
 245
 246 /**
 247   * @brief  Initialize the DTS MSP.
 248   * @param  hdts  DTS handle
 249   * @retval None
 250   */
 251 __weak void HAL_DTS_MspInit(DTS_HandleTypeDef *hdts)
 252 {
 253   /* Prevent unused argument(s) compilation warning */
 254   UNUSED(hdts);
 255
 256   /* NOTE : This function should not be modified, when the callback is needed,
 257   the HAL_DTS_MspInit could be implemented in the user file
 258   */
 259 }
 260
 261 /**
 262   * @brief  DeInitialize the DTS MSP.
 263   * @param  hdts  DTS handle
 264   * @retval None
 265   */
 266 __weak void HAL_DTS_MspDeInit(DTS_HandleTypeDef *hdts)
 267 {
 268   /* Prevent unused argument(s) compilation warning */
 269   UNUSED(hdts);
 270
 271   /* NOTE : This function should not be modified, when the callback is needed,
 272   the HAL_DTS_MspDeInit could be implemented in the user file
 273   */
 274 }
 275
 276 /**
 277   * @}
 278   */
 279
 280 /** @defgroup DTS_Exported_Functions_Group2 Start-Stop operation functions
 281  *  @brief   Start-Stop operation functions.
 282  *
 283 @verbatim
 284  ===============================================================================
 285                       ##### DTS Start Stop operation functions #####
 286  ===============================================================================
 287     [..]  This section provides functions allowing to:
 288       (+) Start a DTS Sensor without interrupt.
 289       (+) Stop a DTS Sensor without interrupt.
 290       (+) Start a DTS Sensor with interrupt generation.
 291       (+) Stop a DTS Sensor with interrupt generation.
 292
 293 @endverbatim
 294   * @{
 295   */
 296
 297 /**
 298   * @brief  Start the DTS sensor.
 299   * @param  hdts  DTS handle
 300   * @retval HAL status
 301   */
 302 HAL_StatusTypeDef HAL_DTS_Start(DTS_HandleTypeDef *hdts)
 303 {
 304   uint32_t Ref_Time;
 305
 306   /* Check the DTS handle allocation */
 307   if (hdts == NULL)
 308   {
 309     return HAL_ERROR;
 310   }
 311
 312   if (hdts->State == HAL_DTS_STATE_READY)
 313   {
 314     hdts->State = HAL_DTS_STATE_BUSY;
 315
 316     /* Enable DTS sensor */
 317     __HAL_DTS_ENABLE(hdts);
 318
 319     /* Get Start Tick*/
 320     Ref_Time = HAL_GetTick();
 321
 322     /* Wait till TS1_RDY flag is set */
 323     while (__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_RDY) == RESET)
 324     {
 325       if ((HAL_GetTick() - Ref_Time) > DTS_DELAY_STARTUP)
 326       {
 327         return HAL_TIMEOUT;
 328       }
 329     }
 330
 331     if (__HAL_DTS_GET_TRIGGER(hdts) == DTS_TRIGGER_HW_NONE)
 332     {
 333       /* Start continuous measures */
 334       SET_BIT(hdts->Instance->CFGR1, DTS_CFGR1_TS1_START);
 335
 336       /* Ensure start is taken into account */
 337       HAL_Delay(TS_TIMEOUT_MS);
 338     }
 339
 340     hdts->State = HAL_DTS_STATE_READY;
 341   }
 342   else
 343   {
 344     return HAL_BUSY;
 345   }
 346
 347   return HAL_OK;
 348 }
 349
 350 /**
 351   * @brief  Stop the DTS Sensor.
 352   * @param  hdts  DTS handle
 353   * @retval HAL status
 354   */
 355 HAL_StatusTypeDef HAL_DTS_Stop(DTS_HandleTypeDef *hdts)
 356 {
 357   /* Check the DTS handle allocation */
 358   if (hdts == NULL)
 359   {
 360     return HAL_ERROR;
 361   }
 362
 363   if (hdts->State == HAL_DTS_STATE_READY)
 364   {
 365     hdts->State = HAL_DTS_STATE_BUSY;
 366
 367     if (__HAL_DTS_GET_TRIGGER(hdts) == DTS_TRIGGER_HW_NONE)
 368     {
 369       CLEAR_BIT(hdts->Instance->CFGR1, DTS_CFGR1_TS1_START);
 370     }
 371
 372     /* Disable the selected DTS sensor */
 373     __HAL_DTS_DISABLE(hdts);
 374
 375     hdts->State = HAL_DTS_STATE_READY;
 376   }
 377   else
 378   {
 379     return HAL_BUSY;
 380   }
 381
 382   return HAL_OK;
 383 }
 384
 385 /**
 386   * @brief  Enable the interrupt(s) and start the DTS sensor
 387   * @param  hdts  DTS handle
 388   * @retval HAL status
 389   */
 390 HAL_StatusTypeDef HAL_DTS_Start_IT(DTS_HandleTypeDef *hdts)
 391 {
 392   uint32_t Ref_Time;
 393
 394   /* Check the DTS handle allocation */
 395   if (hdts == NULL)
 396   {
 397     return HAL_ERROR;
 398   }
 399
 400   if (hdts->State == HAL_DTS_STATE_READY)
 401   {
 402     hdts->State = HAL_DTS_STATE_BUSY;
 403
 404     /* On Asynchronous mode enable the asynchronous IT */
 405     if (hdts->Init.RefClock == DTS_REFCLKSEL_LSE)
 406     {
 407       __HAL_DTS_ENABLE_IT(hdts, DTS_IT_TS1_AITE | DTS_IT_TS1_AITL | DTS_IT_TS1_AITH);
 408     }
 409     else
 410     {
 411       /* Enable the IT(s) */
 412       __HAL_DTS_ENABLE_IT(hdts, DTS_IT_TS1_ITE | DTS_IT_TS1_ITL | DTS_IT_TS1_ITH);
 413     }
 414
 415     /* Enable the selected DTS sensor */
 416     __HAL_DTS_ENABLE(hdts);
 417
 418     /* Get Start Tick*/
 419     Ref_Time = HAL_GetTick();
 420
 421     /* Wait till TS1_RDY flag is set */
 422     while (__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_RDY) == RESET)
 423     {
 424       if ((HAL_GetTick() - Ref_Time) > DTS_DELAY_STARTUP)
 425       {
 426         return HAL_TIMEOUT;
 427       }
 428     }
 429
 430     if (__HAL_DTS_GET_TRIGGER(hdts) == DTS_TRIGGER_HW_NONE)
 431     {
 432       /* Start continuous measures */
 433       SET_BIT(hdts->Instance->CFGR1, DTS_CFGR1_TS1_START);
 434
 435       /* Ensure start is taken into account */
 436       HAL_Delay(TS_TIMEOUT_MS);
 437     }
 438
 439     hdts->State = HAL_DTS_STATE_READY;
 440   }
 441   else
 442   {
 443     return HAL_BUSY;
 444   }
 445
 446   return HAL_OK;
 447 }
 448
 449 /**
 450   * @brief  Disable the interrupt(s) and stop the DTS sensor.
 451   * @param  hdts  DTS handle
 452   * @retval HAL status
 453   */
 454 HAL_StatusTypeDef HAL_DTS_Stop_IT(DTS_HandleTypeDef *hdts)
 455 {
 456   /* Check the DTS handle allocation */
 457   if (hdts == NULL)
 458   {
 459     return HAL_ERROR;
 460   }
 461
 462   if (hdts->State == HAL_DTS_STATE_READY)
 463   {
 464     hdts->State = HAL_DTS_STATE_BUSY;
 465
 466     /* On Asynchronous mode disable the asynchronous IT */
 467     if (hdts->Init.RefClock == DTS_REFCLKSEL_LSE)
 468     {
 469       __HAL_DTS_DISABLE_IT(hdts, DTS_IT_TS1_AITE | DTS_IT_TS1_AITL | DTS_IT_TS1_AITH);
 470     }
 471     else
 472     {
 473       /* Disable the IT(s) */
 474       __HAL_DTS_DISABLE_IT(hdts, DTS_IT_TS1_ITE | DTS_IT_TS1_ITL | DTS_IT_TS1_ITH);
 475     }
 476
 477     if (__HAL_DTS_GET_TRIGGER(hdts) == DTS_TRIGGER_HW_NONE)
 478     {
 479       CLEAR_BIT(hdts->Instance->CFGR1, DTS_CFGR1_TS1_START);
 480     }
 481
 482     /* Disable the selected DTS sensor */
 483     __HAL_DTS_DISABLE(hdts);
 484
 485     hdts->State = HAL_DTS_STATE_READY;
 486   }
 487   else
 488   {
 489     return HAL_BUSY;
 490   }
 491
 492   return HAL_OK;
 493 }
 494
 495 /**
 496   * @brief  Get temperature from DTS
 497   * @param  hdts         DTS handle
 498   * @param  Temperature  Temperature in deg C
 499   * @note This function retrieves latest available measure
 500   * @retval HAL status
 501   */
 502 HAL_StatusTypeDef HAL_DTS_GetTemperature(DTS_HandleTypeDef *hdts, int32_t *Temperature)
 503 {
 504   uint32_t freq_meas;
 505   uint32_t samples;
 506   uint32_t t0_temp;
 507   uint32_t t0_freq;
 508   uint32_t ramp_coeff;
 509
 510   if (hdts->State == HAL_DTS_STATE_READY)
 511   {
 512     hdts->State = HAL_DTS_STATE_BUSY;
 513
 514     /* Get the total number of samples */
 515     samples = (hdts->Instance->DR & DTS_DR_TS1_MFREQ);
 516
 517     if ((hdts->Init.SamplingTime == 0UL) || (samples == 0UL))
 518     {
 519       hdts->State = HAL_DTS_STATE_READY;
 520       return HAL_ERROR;
 521     }
 522
 523     if ((hdts->Init.RefClock) == DTS_REFCLKSEL_LSE)
 524     {
 525       freq_meas = (LSE_VALUE * samples) / (hdts->Init.SamplingTime >> DTS_CFGR1_TS1_SMP_TIME_Pos); /* On Hz */
 526     }
 527     else
 528     {
 529       freq_meas = (HAL_RCCEx_GetD3PCLK1Freq() * (hdts->Init.SamplingTime >> DTS_CFGR1_TS1_SMP_TIME_Pos)) / samples; /* On Hz */
 530     }
 531
 532     /* Read factory settings */
 533     t0_temp = hdts->Instance->T0VALR1 >> DTS_T0VALR1_TS1_T0_Pos;
 534
 535     if (t0_temp == 0UL)
 536     {
 537       t0_temp = 30UL; /* 30 deg C */
 538     }
 539     else if (t0_temp == 1UL)
 540     {
 541       t0_temp = 110UL; /* 110 deg C */
 542     }
 543     else
 544     {
 545       hdts->State = HAL_DTS_STATE_READY;
 546       return HAL_ERROR;
 547     }
 548
 549     t0_freq = (hdts->Instance->T0VALR1 & DTS_T0VALR1_TS1_FMT0) * 100UL; /* Hz */
 550
 551     ramp_coeff = hdts->Instance->RAMPVALR & DTS_RAMPVALR_TS1_RAMP_COEFF; /* deg C/Hz */
 552
 553     if (ramp_coeff == 0UL)
 554     {
 555       hdts->State = HAL_DTS_STATE_READY;
 556       return HAL_ERROR;
 557     }
 558
 559     /* Figure out the temperature deg C */
 560     *Temperature = (int32_t)t0_temp + (((int32_t)freq_meas - (int32_t)t0_freq) / (int32_t)ramp_coeff);
 561
 562     hdts->State = HAL_DTS_STATE_READY;
 563   }
 564   else
 565   {
 566     return HAL_BUSY;
 567   }
 568
 569   return HAL_OK;
 570 }
 571
 572 /**
 573   * @brief  DTS sensor IRQ Handler.
 574   * @param  hdts  DTS handle
 575   * @retval None
 576   */
 577 void HAL_DTS_IRQHandler(DTS_HandleTypeDef *hdts)
 578 {
 579   /* Check end of measure Asynchronous IT */
 580   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_AITE)) != RESET)
 581   {
 582       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_AITE);
 583
 584 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
 585       hdts->AsyncEndCallback(hdts);
 586 #else
 587       HAL_DTS_AsyncEndCallback(hdts);
 588 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
 589   }
 590
 591   /* Check low threshold Asynchronous IT */
 592   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_AITL)) != RESET)
 593   {
 594       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_AITL);
 595
 596 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
 597       hdts->AsyncLowCallback(hdts);
 598 #else
 599       HAL_DTS_AsyncLowCallback(hdts);
 600 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
 601   }
 602
 603   /* Check high threshold Asynchronous IT */
 604   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_AITH)) != RESET)
 605   {
 606       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_AITH);
 607
 608 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
 609       hdts->AsyncHighCallback(hdts);
 610 #else
 611       HAL_DTS_AsyncHighCallback(hdts);
 612 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
 613   }
 614
 615   /* Check end of measure IT */
 616   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_ITE)) != RESET)
 617   {
 618       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_ITE);
 619
 620 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
 621       hdts->EndCallback(hdts);
 622 #else
 623       HAL_DTS_EndCallback(hdts);
 624 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
 625   }
 626
 627   /* Check low threshold IT */
 628   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_ITL)) != RESET)
 629   {
 630       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_ITL);
 631
 632 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
 633       hdts->LowCallback(hdts);
 634 #else
 635       HAL_DTS_LowCallback(hdts);
 636 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
 637   }
 638
 639   /* Check high threshold IT */
 640   if ((__HAL_DTS_GET_FLAG(hdts, DTS_FLAG_TS1_ITH)) != RESET)
 641   {
 642       __HAL_DTS_CLEAR_FLAG(hdts, DTS_FLAG_TS1_ITH);
 643
 644 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
 645       hdts->HighCallback(hdts);
 646 #else
 647       HAL_DTS_HighCallback(hdts);
 648 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
 649   }
 650 }
 651
 652 /**
 653   * @brief  DTS Sensor End measure callback.
 654   * @param  hdts  DTS handle
 655   * @retval None
 656   */
 657 __weak void HAL_DTS_EndCallback(DTS_HandleTypeDef *hdts)
 658 {
 659   /* Prevent unused argument(s) compilation warning */
 660   UNUSED(hdts);
 661
 662   /* NOTE : This function should not be modified, when the callback is needed,
 663   the HAL_DTS_EndCallback should be implemented in the user file
 664   */
 665 }
 666
 667 /**
 668   * @brief  DTS Sensor low threshold measure callback.
 669   * @param  hdts  DTS handle
 670   * @retval None
 671   */
 672 __weak void HAL_DTS_LowCallback(DTS_HandleTypeDef *hdts)
 673 {
 674   /* Prevent unused argument(s) compilation warning */
 675   UNUSED(hdts);
 676
 677   /* NOTE : This function should not be modified, when the callback is needed,
 678   the HAL_DTS_LowCallback should be implemented in the user file
 679   */
 680 }
 681
 682 /**
 683   * @brief  DTS Sensor high threshold measure callback.
 684   * @param  hdts  DTS handle
 685   * @retval None
 686   */
 687 __weak void HAL_DTS_HighCallback(DTS_HandleTypeDef *hdts)
 688 {
 689   /* Prevent unused argument(s) compilation warning */
 690   UNUSED(hdts);
 691
 692   /* NOTE : This function should not be modified, when the callback is needed,
 693   the HAL_DTS_HighCallback should be implemented in the user file
 694   */
 695 }
 696
 697 /**
 698   * @brief  DTS Sensor asynchronous end measure callback.
 699   * @param  hdts  DTS handle
 700   * @retval None
 701   */
 702 __weak void HAL_DTS_AsyncEndCallback(DTS_HandleTypeDef *hdts)
 703 {
 704   /* Prevent unused argument(s) compilation warning */
 705   UNUSED(hdts);
 706
 707   /* NOTE : This function should not be modified, when the callback is needed,
 708   the HAL_DTS_AsyncEndCallback should be implemented in the user file
 709   */
 710 }
 711
 712 /**
 713   * @brief  DTS Sensor asynchronous low threshold measure callback.
 714   * @param  hdts  DTS handle
 715   * @retval None
 716   */
 717 __weak void HAL_DTS_AsyncLowCallback(DTS_HandleTypeDef *hdts)
 718 {
 719   /* Prevent unused argument(s) compilation warning */
 720   UNUSED(hdts);
 721
 722   /* NOTE : This function should not be modified, when the callback is needed,
 723   the HAL_DTS_AsyncLowCallback should be implemented in the user file
 724   */
 725 }
 726
 727 /**
 728   * @brief  DTS Sensor asynchronous high threshold measure callback.
 729   * @param  hdts  DTS handle
 730   * @retval None
 731   */
 732 __weak void HAL_DTS_AsyncHighCallback(DTS_HandleTypeDef *hdts)
 733 {
 734   /* Prevent unused argument(s) compilation warning */
 735   UNUSED(hdts);
 736
 737   /* NOTE : This function should not be modified, when the callback is needed,
 738   the HAL_DTS_AsyncHighCallback should be implemented in the user file
 739   */
 740 }
 741
 742 /**
 743   * @}
 744   */
 745
 746 /** @defgroup DTS_Exported_Functions_Group3 Peripheral State functions
 747  *  @brief   Peripheral State functions.
 748  *
 749 @verbatim
 750  ===============================================================================
 751                       ##### Peripheral State functions #####
 752  ===============================================================================
 753     [..]
 754     This subsection permits to get in run-time the status of the peripheral.
 755
 756 @endverbatim
 757   * @{
 758   */
 759
 760 /**
 761   * @brief  Return the DTS handle state.
 762   * @param  hdts  DTS handle
 763   * @retval HAL state
 764   */
 765 HAL_DTS_StateTypeDef HAL_DTS_GetState(DTS_HandleTypeDef *hdts)
 766 {
 767   /* Check the DTS handle allocation */
 768   if (hdts == NULL)
 769   {
 770     return HAL_DTS_STATE_RESET;
 771   }
 772
 773   /* Return DTS handle state */
 774   return hdts->State;
 775 }
 776 /**
 777   * @}
 778   */
 779
 780 /**
 781   * @}
 782   */
 783
 784 /* Private functions ---------------------------------------------------------*/
 785
 786 /** @defgroup DTS_Private_Functions DTS Private Functions
 787   * @{
 788   */
 789 #if (USE_HAL_DTS_REGISTER_CALLBACKS == 1)
 790 /**
 791   * @brief  Reset interrupt callbacks to the legacy weak callbacks.
 792   * @param  hdts pointer to a DTS_HandleTypeDef structure that contains
 793   *                the configuration information for DTS module.
 794   * @retval None
 795   */
 796 static void DTS_ResetCallback(DTS_HandleTypeDef *hdts)
 797 {
 798   /* Reset the DTS callback to the legacy weak callbacks */
 799   hdts->DTS_EndCallback       = HAL_DTS_EndCallback;        /* End measure Callback                 */
 800   hdts->DTS_LowCallback       = HAL_DTS_LowCallback;        /* low threshold Callback               */
 801   hdts->DTS_HighCallback      = HAL_DTS_HighCallback;       /* high threshold Callback              */
 802   hdts->DTS_AsyncEndCallback  = HAL_DTS_AsyncEndCallback;   /* Asynchronous end of measure Callback */
 803   hdts->DTS_AsyncLowCallback  = HAL_DTS_AsyncLowCallback;   /* Asynchronous low threshold Callback  */
 804   hdts->DTS_AsyncHighCallback = HAL_DTS_AsyncHighCallback;  /* Asynchronous high threshold Callback */
 805 }
 806 #endif /* USE_HAL_DTS_REGISTER_CALLBACKS */
 807 /**
 808   * @}
 809   */
 810
 811 /**
 812   * @}
 813   */
 814
 815 #endif /* DTS */
 816
 817 #endif /* HAL_DTS_MODULE_ENABLED */
 818
 819 /**
 820   * @}
 821   */
 822
 823 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/