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