stm32f1xx_hal_exti.c - tdse-tp3_02-code

Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_exti.c (15048B)
Line numbers
   1 /**
   2   ******************************************************************************
   3   * @file    stm32f1xx_hal_exti.c
   4   * @author  MCD Application Team
   5   * @brief   EXTI HAL module driver.
   6   *          This file provides firmware functions to manage the following
   7   *          functionalities of the Extended Interrupts and events controller (EXTI) peripheral:
   8   *           + Initialization and de-initialization functions
   9   *           + IO operation functions
  10   *
  11   ******************************************************************************
  12   * @attention
  13   *
  14   * Copyright (c) 2019 STMicroelectronics.
  15   * All rights reserved.
  16   *
  17   * This software is licensed under terms that can be found in the LICENSE file
  18   * in the root directory of this software component.
  19   * If no LICENSE file comes with this software, it is provided AS-IS.
  20   *
  21   ******************************************************************************
  22   @verbatim
  23   ==============================================================================
  24                     ##### EXTI Peripheral features #####
  25   ==============================================================================
  26   [..]
  27     (+) Each Exti line can be configured within this driver.
  28 
  29     (+) Exti line can be configured in 3 different modes
  30         (++) Interrupt
  31         (++) Event
  32         (++) Both of them
  33 
  34     (+) Configurable Exti lines can be configured with 3 different triggers
  35         (++) Rising
  36         (++) Falling
  37         (++) Both of them
  38 
  39     (+) When set in interrupt mode, configurable Exti lines have two different
  40         interrupts pending registers which allow to distinguish which transition
  41         occurs:
  42         (++) Rising edge pending interrupt
  43         (++) Falling
  44 
  45     (+) Exti lines 0 to 15 are linked to gpio pin number 0 to 15. Gpio port can
  46         be selected through multiplexer.
  47 
  48                      ##### How to use this driver #####
  49   ==============================================================================
  50   [..]
  51 
  52     (#) Configure the EXTI line using HAL_EXTI_SetConfigLine().
  53         (++) Choose the interrupt line number by setting "Line" member from
  54              EXTI_ConfigTypeDef structure.
  55         (++) Configure the interrupt and/or event mode using "Mode" member from
  56              EXTI_ConfigTypeDef structure.
  57         (++) For configurable lines, configure rising and/or falling trigger
  58              "Trigger" member from EXTI_ConfigTypeDef structure.
  59         (++) For Exti lines linked to gpio, choose gpio port using "GPIOSel"
  60              member from GPIO_InitTypeDef structure.
  61 
  62     (#) Get current Exti configuration of a dedicated line using
  63         HAL_EXTI_GetConfigLine().
  64         (++) Provide exiting handle as parameter.
  65         (++) Provide pointer on EXTI_ConfigTypeDef structure as second parameter.
  66 
  67     (#) Clear Exti configuration of a dedicated line using HAL_EXTI_ClearConfigLine().
  68         (++) Provide exiting handle as parameter.
  69 
  70     (#) Register callback to treat Exti interrupts using HAL_EXTI_RegisterCallback().
  71         (++) Provide exiting handle as first parameter.
  72         (++) Provide which callback will be registered using one value from
  73              EXTI_CallbackIDTypeDef.
  74         (++) Provide callback function pointer.
  75 
  76     (#) Get interrupt pending bit using HAL_EXTI_GetPending().
  77 
  78     (#) Clear interrupt pending bit using HAL_EXTI_ClearPending().
  79 
  80     (#) Generate software interrupt using HAL_EXTI_GenerateSWI().
  81 
  82   @endverbatim
  83   */
  84 
  85 /* Includes ------------------------------------------------------------------*/
  86 #include "stm32f1xx_hal.h"
  87 
  88 /** @addtogroup STM32F1xx_HAL_Driver
  89   * @{
  90   */
  91 
  92 /** @addtogroup EXTI
  93   * @{
  94   */
  95 /** MISRA C:2012 deviation rule has been granted for following rule:
  96   * Rule-18.1_b - Medium: Array `EXTICR' 1st subscript interval [0,7] may be out
  97   * of bounds [0,3] in following API :
  98   * HAL_EXTI_SetConfigLine
  99   * HAL_EXTI_GetConfigLine
 100   * HAL_EXTI_ClearConfigLine
 101   */
 102 
 103 #ifdef HAL_EXTI_MODULE_ENABLED
 104 
 105 /* Private typedef -----------------------------------------------------------*/
 106 /* Private defines -----------------------------------------------------------*/
 107 /** @defgroup EXTI_Private_Constants EXTI Private Constants
 108   * @{
 109   */
 110 
 111 /**
 112   * @}
 113   */
 114 
 115 /* Private macros ------------------------------------------------------------*/
 116 /* Private variables ---------------------------------------------------------*/
 117 /* Private function prototypes -----------------------------------------------*/
 118 /* Exported functions --------------------------------------------------------*/
 119 
 120 /** @addtogroup EXTI_Exported_Functions
 121   * @{
 122   */
 123 
 124 /** @addtogroup EXTI_Exported_Functions_Group1
 125   *  @brief    Configuration functions
 126   *
 127 @verbatim
 128  ===============================================================================
 129               ##### Configuration functions #####
 130  ===============================================================================
 131 
 132 @endverbatim
 133   * @{
 134   */
 135 
 136 /**
 137   * @brief  Set configuration of a dedicated Exti line.
 138   * @param  hexti Exti handle.
 139   * @param  pExtiConfig Pointer on EXTI configuration to be set.
 140   * @retval HAL Status.
 141   */
 142 HAL_StatusTypeDef HAL_EXTI_SetConfigLine(EXTI_HandleTypeDef *hexti, EXTI_ConfigTypeDef *pExtiConfig)
 143 {
 144   uint32_t regval;
 145   uint32_t linepos;
 146   uint32_t maskline;
 147 
 148   /* Check null pointer */
 149   if ((hexti == NULL) || (pExtiConfig == NULL))
 150   {
 151     return HAL_ERROR;
 152   }
 153 
 154   /* Check parameters */
 155   assert_param(IS_EXTI_LINE(pExtiConfig->Line));
 156   assert_param(IS_EXTI_MODE(pExtiConfig->Mode));
 157 
 158   /* Assign line number to handle */
 159   hexti->Line = pExtiConfig->Line;
 160 
 161   /* Compute line mask */
 162   linepos = (pExtiConfig->Line & EXTI_PIN_MASK);
 163   maskline = (1uL << linepos);
 164 
 165   /* Configure triggers for configurable lines */
 166   if ((pExtiConfig->Line & EXTI_CONFIG) != 0x00u)
 167   {
 168     assert_param(IS_EXTI_TRIGGER(pExtiConfig->Trigger));
 169 
 170     /* Configure rising trigger */
 171     /* Mask or set line */
 172     if ((pExtiConfig->Trigger & EXTI_TRIGGER_RISING) != 0x00u)
 173     {
 174       EXTI->RTSR |= maskline;
 175     }
 176     else
 177     {
 178       EXTI->RTSR &= ~maskline;
 179     }
 180 
 181     /* Configure falling trigger */
 182     /* Mask or set line */
 183     if ((pExtiConfig->Trigger & EXTI_TRIGGER_FALLING) != 0x00u)
 184     {
 185       EXTI->FTSR |= maskline;
 186     }
 187     else
 188     {
 189       EXTI->FTSR &= ~maskline;
 190     }
 191 
 192 
 193     /* Configure gpio port selection in case of gpio exti line */
 194     if ((pExtiConfig->Line & EXTI_GPIO) == EXTI_GPIO)
 195     {
 196       assert_param(IS_EXTI_GPIO_PORT(pExtiConfig->GPIOSel));
 197       assert_param(IS_EXTI_GPIO_PIN(linepos));
 198       
 199       regval = AFIO->EXTICR[linepos >> 2u];
 200       regval &= ~(AFIO_EXTICR1_EXTI0 << (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
 201       regval |= (pExtiConfig->GPIOSel << (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
 202       AFIO->EXTICR[linepos >> 2u] = regval;
 203     }
 204   }
 205 
 206   /* Configure interrupt mode : read current mode */
 207   /* Mask or set line */
 208   if ((pExtiConfig->Mode & EXTI_MODE_INTERRUPT) != 0x00u)
 209   {
 210     EXTI->IMR |= maskline;
 211   }
 212   else
 213   {
 214     EXTI->IMR &= ~maskline;
 215   }
 216 
 217   /* Configure event mode : read current mode */
 218   /* Mask or set line */
 219   if ((pExtiConfig->Mode & EXTI_MODE_EVENT) != 0x00u)
 220   {
 221     EXTI->EMR |= maskline;
 222   }
 223   else
 224   {
 225     EXTI->EMR &= ~maskline;
 226   }
 227 
 228   return HAL_OK;
 229 }
 230 
 231 /**
 232   * @brief  Get configuration of a dedicated Exti line.
 233   * @param  hexti Exti handle.
 234   * @param  pExtiConfig Pointer on structure to store Exti configuration.
 235   * @retval HAL Status.
 236   */
 237 HAL_StatusTypeDef HAL_EXTI_GetConfigLine(EXTI_HandleTypeDef *hexti, EXTI_ConfigTypeDef *pExtiConfig)
 238 {
 239   uint32_t regval;
 240   uint32_t linepos;
 241   uint32_t maskline;
 242 
 243   /* Check null pointer */
 244   if ((hexti == NULL) || (pExtiConfig == NULL))
 245   {
 246     return HAL_ERROR;
 247   }
 248 
 249   /* Check the parameter */
 250   assert_param(IS_EXTI_LINE(hexti->Line));
 251 
 252   /* Store handle line number to configuration structure */
 253   pExtiConfig->Line = hexti->Line;
 254 
 255   /* Compute line mask */
 256   linepos = (pExtiConfig->Line & EXTI_PIN_MASK);
 257   maskline = (1uL << linepos);
 258 
 259   /* 1] Get core mode : interrupt */
 260 
 261   /* Check if selected line is enable */
 262   if ((EXTI->IMR & maskline) != 0x00u)
 263   {
 264     pExtiConfig->Mode = EXTI_MODE_INTERRUPT;
 265   }
 266   else
 267   {
 268     pExtiConfig->Mode = EXTI_MODE_NONE;
 269   }
 270 
 271   /* Get event mode */
 272   /* Check if selected line is enable */
 273   if ((EXTI->EMR & maskline) != 0x00u)
 274   {
 275     pExtiConfig->Mode |= EXTI_MODE_EVENT;
 276   }
 277 
 278   /* Get default Trigger and GPIOSel configuration */
 279   pExtiConfig->Trigger = EXTI_TRIGGER_NONE;
 280   pExtiConfig->GPIOSel = 0x00u;
 281 
 282   /* 2] Get trigger for configurable lines : rising */
 283   if ((pExtiConfig->Line & EXTI_CONFIG) != 0x00u)
 284   {
 285     /* Check if configuration of selected line is enable */
 286     if ((EXTI->RTSR & maskline) != 0x00u)
 287     {
 288       pExtiConfig->Trigger = EXTI_TRIGGER_RISING;
 289     }
 290 
 291     /* Get falling configuration */
 292     /* Check if configuration of selected line is enable */
 293     if ((EXTI->FTSR & maskline) != 0x00u)
 294     {
 295       pExtiConfig->Trigger |= EXTI_TRIGGER_FALLING;
 296     }
 297 
 298     /* Get Gpio port selection for gpio lines */
 299     if ((pExtiConfig->Line & EXTI_GPIO) == EXTI_GPIO)
 300     {
 301       assert_param(IS_EXTI_GPIO_PIN(linepos));
 302 
 303       regval = AFIO->EXTICR[linepos >> 2u];
 304       pExtiConfig->GPIOSel = (regval >> (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u))) & AFIO_EXTICR1_EXTI0;
 305     }
 306   }
 307 
 308   return HAL_OK;
 309 }
 310 
 311 /**
 312   * @brief  Clear whole configuration of a dedicated Exti line.
 313   * @param  hexti Exti handle.
 314   * @retval HAL Status.
 315   */
 316 HAL_StatusTypeDef HAL_EXTI_ClearConfigLine(EXTI_HandleTypeDef *hexti)
 317 {
 318   uint32_t regval;
 319   uint32_t linepos;
 320   uint32_t maskline;
 321 
 322   /* Check null pointer */
 323   if (hexti == NULL)
 324   {
 325     return HAL_ERROR;
 326   }
 327 
 328   /* Check the parameter */
 329   assert_param(IS_EXTI_LINE(hexti->Line));
 330 
 331   /* compute line mask */
 332   linepos = (hexti->Line & EXTI_PIN_MASK);
 333   maskline = (1uL << linepos);
 334 
 335   /* 1] Clear interrupt mode */
 336   EXTI->IMR = (EXTI->IMR & ~maskline);
 337 
 338   /* 2] Clear event mode */
 339   EXTI->EMR = (EXTI->EMR & ~maskline);
 340 
 341   /* 3] Clear triggers in case of configurable lines */
 342   if ((hexti->Line & EXTI_CONFIG) != 0x00u)
 343   {
 344     EXTI->RTSR = (EXTI->RTSR & ~maskline);
 345     EXTI->FTSR = (EXTI->FTSR & ~maskline);
 346 
 347     /* Get Gpio port selection for gpio lines */
 348     if ((hexti->Line & EXTI_GPIO) == EXTI_GPIO)
 349     {
 350       assert_param(IS_EXTI_GPIO_PIN(linepos));
 351 
 352       regval = AFIO->EXTICR[linepos >> 2u];
 353       regval &= ~(AFIO_EXTICR1_EXTI0 << (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
 354       AFIO->EXTICR[linepos >> 2u] = regval;
 355     }
 356   }
 357 
 358   return HAL_OK;
 359 }
 360 
 361 /**
 362   * @brief  Register callback for a dedicated Exti line.
 363   * @param  hexti Exti handle.
 364   * @param  CallbackID User callback identifier.
 365   *         This parameter can be one of @arg @ref EXTI_CallbackIDTypeDef values.
 366   * @param  pPendingCbfn function pointer to be stored as callback.
 367   * @retval HAL Status.
 368   */
 369 HAL_StatusTypeDef HAL_EXTI_RegisterCallback(EXTI_HandleTypeDef *hexti, EXTI_CallbackIDTypeDef CallbackID, void (*pPendingCbfn)(void))
 370 {
 371   HAL_StatusTypeDef status = HAL_OK;
 372 
 373   switch (CallbackID)
 374   {
 375     case  HAL_EXTI_COMMON_CB_ID:
 376       hexti->PendingCallback = pPendingCbfn;
 377       break;
 378 
 379     default:
 380       status = HAL_ERROR;
 381       break;
 382   }
 383 
 384   return status;
 385 }
 386 
 387 /**
 388   * @brief  Store line number as handle private field.
 389   * @param  hexti Exti handle.
 390   * @param  ExtiLine Exti line number.
 391   *         This parameter can be from 0 to @ref EXTI_LINE_NB.
 392   * @retval HAL Status.
 393   */
 394 HAL_StatusTypeDef HAL_EXTI_GetHandle(EXTI_HandleTypeDef *hexti, uint32_t ExtiLine)
 395 {
 396   /* Check the parameters */
 397   assert_param(IS_EXTI_LINE(ExtiLine));
 398 
 399   /* Check null pointer */
 400   if (hexti == NULL)
 401   {
 402     return HAL_ERROR;
 403   }
 404   else
 405   {
 406     /* Store line number as handle private field */
 407     hexti->Line = ExtiLine;
 408 
 409     return HAL_OK;
 410   }
 411 }
 412 
 413 /**
 414   * @}
 415   */
 416 
 417 /** @addtogroup EXTI_Exported_Functions_Group2
 418   *  @brief EXTI IO functions.
 419   *
 420 @verbatim
 421  ===============================================================================
 422                        ##### IO operation functions #####
 423  ===============================================================================
 424 
 425 @endverbatim
 426   * @{
 427   */
 428 
 429 /**
 430   * @brief  Handle EXTI interrupt request.
 431   * @param  hexti Exti handle.
 432   * @retval none.
 433   */
 434 void HAL_EXTI_IRQHandler(EXTI_HandleTypeDef *hexti)
 435 {
 436   uint32_t regval;
 437   uint32_t maskline;
 438 
 439   /* Compute line mask */
 440   maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
 441 
 442   /* Get pending bit  */
 443   regval = (EXTI->PR & maskline);
 444   if (regval != 0x00u)
 445   {
 446     /* Clear pending bit */
 447     EXTI->PR = maskline;
 448 
 449     /* Call callback */
 450     if (hexti->PendingCallback != NULL)
 451     {
 452       hexti->PendingCallback();
 453     }
 454   }
 455 }
 456 
 457 /**
 458   * @brief  Get interrupt pending bit of a dedicated line.
 459   * @param  hexti Exti handle.
 460   * @param  Edge Specify which pending edge as to be checked.
 461   *         This parameter can be one of the following values:
 462   *           @arg @ref EXTI_TRIGGER_RISING_FALLING
 463   *         This parameter is kept for compatibility with other series.
 464   * @retval 1 if interrupt is pending else 0.
 465   */
 466 uint32_t HAL_EXTI_GetPending(EXTI_HandleTypeDef *hexti, uint32_t Edge)
 467 {
 468   uint32_t regval;
 469   uint32_t maskline;
 470   uint32_t linepos;
 471 
 472   /* Check parameters */
 473   assert_param(IS_EXTI_LINE(hexti->Line));
 474   assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
 475   assert_param(IS_EXTI_PENDING_EDGE(Edge));
 476 
 477   /* Prevent unused argument compilation warning */
 478   UNUSED(Edge);
 479 
 480   /* Compute line mask */
 481   linepos = (hexti->Line & EXTI_PIN_MASK);
 482   maskline = (1uL << linepos);
 483 
 484   /* return 1 if bit is set else 0 */
 485   regval = ((EXTI->PR & maskline) >> linepos);
 486   return regval;
 487 }
 488 
 489 /**
 490   * @brief  Clear interrupt pending bit of a dedicated line.
 491   * @param  hexti Exti handle.
 492   * @param  Edge Specify which pending edge as to be clear.
 493   *         This parameter can be one of the following values:
 494   *           @arg @ref EXTI_TRIGGER_RISING_FALLING
 495   *         This parameter is kept for compatibility with other series.
 496   * @retval None.
 497   */
 498 void HAL_EXTI_ClearPending(EXTI_HandleTypeDef *hexti, uint32_t Edge)
 499 {
 500   uint32_t maskline;
 501 
 502   /* Check parameters */
 503   assert_param(IS_EXTI_LINE(hexti->Line));
 504   assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
 505   assert_param(IS_EXTI_PENDING_EDGE(Edge));
 506 
 507   /* Prevent unused argument compilation warning */
 508   UNUSED(Edge);
 509 
 510   /* Compute line mask */
 511   maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
 512 
 513   /* Clear Pending bit */
 514   EXTI->PR =  maskline;
 515 }
 516 
 517 /**
 518   * @brief  Generate a software interrupt for a dedicated line.
 519   * @param  hexti Exti handle.
 520   * @retval None.
 521   */
 522 void HAL_EXTI_GenerateSWI(EXTI_HandleTypeDef *hexti)
 523 {
 524   uint32_t maskline;
 525 
 526   /* Check parameters */
 527   assert_param(IS_EXTI_LINE(hexti->Line));
 528   assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
 529 
 530   /* Compute line mask */
 531   maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
 532 
 533   /* Generate Software interrupt */
 534   EXTI->SWIER = maskline;
 535 }
 536 
 537 /**
 538   * @}
 539   */
 540 
 541 /**
 542   * @}
 543   */
 544 
 545 #endif /* HAL_EXTI_MODULE_ENABLED */
 546 /**
 547   * @}
 548   */
 549 
 550 /**
 551   * @}
 552   */
 553
tdse-tp3_02-code_integration
