Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 18 | mjames | 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 |