Mercurial > public > ostc4
comparison Common/Drivers/STM32F4xx_HAL_DRIVER_v120/Src/stm32f4xx_hal_gpio.c @ 38:5f11787b4f42
include in ostc4 repository
author | heinrichsweikamp |
---|---|
date | Sat, 28 Apr 2018 11:52:34 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
37:ccc45c0e1ea2 | 38:5f11787b4f42 |
---|---|
1 /** | |
2 ****************************************************************************** | |
3 * @file stm32f4xx_hal_gpio.c | |
4 * @author MCD Application Team | |
5 * @version V1.2.0 | |
6 * @date 26-December-2014 | |
7 * @brief GPIO HAL module driver. | |
8 * This file provides firmware functions to manage the following | |
9 * functionalities of the General Purpose Input/Output (GPIO) peripheral: | |
10 * + Initialization and de-initialization functions | |
11 * + IO operation functions | |
12 * | |
13 @verbatim | |
14 ============================================================================== | |
15 ##### GPIO Peripheral features ##### | |
16 ============================================================================== | |
17 [..] | |
18 Subject to the specific hardware characteristics of each I/O port listed in the datasheet, each | |
19 port bit of the General Purpose IO (GPIO) Ports, can be individually configured by software | |
20 in several modes: | |
21 (+) Input mode | |
22 (+) Analog mode | |
23 (+) Output mode | |
24 (+) Alternate function mode | |
25 (+) External interrupt/event lines | |
26 | |
27 [..] | |
28 During and just after reset, the alternate functions and external interrupt | |
29 lines are not active and the I/O ports are configured in input floating mode. | |
30 | |
31 [..] | |
32 All GPIO pins have weak internal pull-up and pull-down resistors, which can be | |
33 activated or not. | |
34 | |
35 [..] | |
36 In Output or Alternate mode, each IO can be configured on open-drain or push-pull | |
37 type and the IO speed can be selected depending on the VDD value. | |
38 | |
39 [..] | |
40 All ports have external interrupt/event capability. To use external interrupt | |
41 lines, the port must be configured in input mode. All available GPIO pins are | |
42 connected to the 16 external interrupt/event lines from EXTI0 to EXTI15. | |
43 | |
44 [..] | |
45 The external interrupt/event controller consists of up to 23 edge detectors | |
46 (16 lines are connected to GPIO) for generating event/interrupt requests (each | |
47 input line can be independently configured to select the type (interrupt or event) | |
48 and the corresponding trigger event (rising or falling or both). Each line can | |
49 also be masked independently. | |
50 | |
51 ##### How to use this driver ##### | |
52 ============================================================================== | |
53 [..] | |
54 (#) Enable the GPIO AHB clock using the following function: __HAL_RCC_GPIOx_CLK_ENABLE(). | |
55 | |
56 (#) Configure the GPIO pin(s) using HAL_GPIO_Init(). | |
57 (++) Configure the IO mode using "Mode" member from GPIO_InitTypeDef structure | |
58 (++) Activate Pull-up, Pull-down resistor using "Pull" member from GPIO_InitTypeDef | |
59 structure. | |
60 (++) In case of Output or alternate function mode selection: the speed is | |
61 configured through "Speed" member from GPIO_InitTypeDef structure. | |
62 (++) In alternate mode is selection, the alternate function connected to the IO | |
63 is configured through "Alternate" member from GPIO_InitTypeDef structure. | |
64 (++) Analog mode is required when a pin is to be used as ADC channel | |
65 or DAC output. | |
66 (++) In case of external interrupt/event selection the "Mode" member from | |
67 GPIO_InitTypeDef structure select the type (interrupt or event) and | |
68 the corresponding trigger event (rising or falling or both). | |
69 | |
70 (#) In case of external interrupt/event mode selection, configure NVIC IRQ priority | |
71 mapped to the EXTI line using HAL_NVIC_SetPriority() and enable it using | |
72 HAL_NVIC_EnableIRQ(). | |
73 | |
74 (#) To get the level of a pin configured in input mode use HAL_GPIO_ReadPin(). | |
75 | |
76 (#) To set/reset the level of a pin configured in output mode use | |
77 HAL_GPIO_WritePin()/HAL_GPIO_TogglePin(). | |
78 | |
79 (#) To lock pin configuration until next reset use HAL_GPIO_LockPin(). | |
80 | |
81 | |
82 (#) During and just after reset, the alternate functions are not | |
83 active and the GPIO pins are configured in input floating mode (except JTAG | |
84 pins). | |
85 | |
86 (#) The LSE oscillator pins OSC32_IN and OSC32_OUT can be used as general purpose | |
87 (PC14 and PC15, respectively) when the LSE oscillator is off. The LSE has | |
88 priority over the GPIO function. | |
89 | |
90 (#) The HSE oscillator pins OSC_IN/OSC_OUT can be used as | |
91 general purpose PH0 and PH1, respectively, when the HSE oscillator is off. | |
92 The HSE has priority over the GPIO function. | |
93 | |
94 @endverbatim | |
95 ****************************************************************************** | |
96 * @attention | |
97 * | |
98 * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2> | |
99 * | |
100 * Redistribution and use in source and binary forms, with or without modification, | |
101 * are permitted provided that the following conditions are met: | |
102 * 1. Redistributions of source code must retain the above copyright notice, | |
103 * this list of conditions and the following disclaimer. | |
104 * 2. Redistributions in binary form must reproduce the above copyright notice, | |
105 * this list of conditions and the following disclaimer in the documentation | |
106 * and/or other materials provided with the distribution. | |
107 * 3. Neither the name of STMicroelectronics nor the names of its contributors | |
108 * may be used to endorse or promote products derived from this software | |
109 * without specific prior written permission. | |
110 * | |
111 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
112 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
113 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
114 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
115 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
116 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
117 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
118 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
119 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
120 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
121 * | |
122 ****************************************************************************** | |
123 */ | |
124 | |
125 /* Includes ------------------------------------------------------------------*/ | |
126 #include "stm32f4xx_hal.h" | |
127 | |
128 /** @addtogroup STM32F4xx_HAL_Driver | |
129 * @{ | |
130 */ | |
131 | |
132 /** @defgroup GPIO GPIO | |
133 * @brief GPIO HAL module driver | |
134 * @{ | |
135 */ | |
136 | |
137 #ifdef HAL_GPIO_MODULE_ENABLED | |
138 | |
139 /* Private typedef -----------------------------------------------------------*/ | |
140 /* Private define ------------------------------------------------------------*/ | |
141 /** @addtogroup GPIO_Private_Constants GPIO Private Constants | |
142 * @{ | |
143 */ | |
144 #define GPIO_MODE ((uint32_t)0x00000003) | |
145 #define EXTI_MODE ((uint32_t)0x10000000) | |
146 #define GPIO_MODE_IT ((uint32_t)0x00010000) | |
147 #define GPIO_MODE_EVT ((uint32_t)0x00020000) | |
148 #define RISING_EDGE ((uint32_t)0x00100000) | |
149 #define FALLING_EDGE ((uint32_t)0x00200000) | |
150 #define GPIO_OUTPUT_TYPE ((uint32_t)0x00000010) | |
151 | |
152 #define GPIO_NUMBER ((uint32_t)16) | |
153 /** | |
154 * @} | |
155 */ | |
156 /* Private macro -------------------------------------------------------------*/ | |
157 /* Private variables ---------------------------------------------------------*/ | |
158 /* Private function prototypes -----------------------------------------------*/ | |
159 /* Private functions ---------------------------------------------------------*/ | |
160 /* Exported functions --------------------------------------------------------*/ | |
161 /** @defgroup GPIO_Exported_Functions GPIO Exported Functions | |
162 * @{ | |
163 */ | |
164 | |
165 /** @defgroup GPIO_Exported_Functions_Group1 Initialization and de-initialization functions | |
166 * @brief Initialization and Configuration functions | |
167 * | |
168 @verbatim | |
169 =============================================================================== | |
170 ##### Initialization and de-initialization functions ##### | |
171 =============================================================================== | |
172 [..] | |
173 This section provides functions allowing to initialize and de-initialize the GPIOs | |
174 to be ready for use. | |
175 | |
176 @endverbatim | |
177 * @{ | |
178 */ | |
179 | |
180 | |
181 /** | |
182 * @brief Initializes the GPIOx peripheral according to the specified parameters in the GPIO_Init. | |
183 * @param GPIOx: where x can be (A..K) to select the GPIO peripheral for STM32F429X device or | |
184 * x can be (A..I) to select the GPIO peripheral for STM32F40XX and STM32F427X devices. | |
185 * @param GPIO_Init: pointer to a GPIO_InitTypeDef structure that contains | |
186 * the configuration information for the specified GPIO peripheral. | |
187 * @retval None | |
188 */ | |
189 void HAL_GPIO_Init(GPIO_TypeDef *GPIOx, GPIO_InitTypeDef *GPIO_Init) | |
190 { | |
191 uint32_t position; | |
192 uint32_t ioposition = 0x00; | |
193 uint32_t iocurrent = 0x00; | |
194 uint32_t temp = 0x00; | |
195 | |
196 /* Check the parameters */ | |
197 assert_param(IS_GPIO_ALL_INSTANCE(GPIOx)); | |
198 assert_param(IS_GPIO_PIN(GPIO_Init->Pin)); | |
199 assert_param(IS_GPIO_MODE(GPIO_Init->Mode)); | |
200 assert_param(IS_GPIO_PULL(GPIO_Init->Pull)); | |
201 | |
202 /* Configure the port pins */ | |
203 for(position = 0; position < GPIO_NUMBER; position++) | |
204 { | |
205 /* Get the IO position */ | |
206 ioposition = ((uint32_t)0x01) << position; | |
207 /* Get the current IO position */ | |
208 iocurrent = (uint32_t)(GPIO_Init->Pin) & ioposition; | |
209 | |
210 if(iocurrent == ioposition) | |
211 { | |
212 /*--------------------- GPIO Mode Configuration ------------------------*/ | |
213 /* In case of Alternate function mode selection */ | |
214 if((GPIO_Init->Mode == GPIO_MODE_AF_PP) || (GPIO_Init->Mode == GPIO_MODE_AF_OD)) | |
215 { | |
216 /* Check the Alternate function parameter */ | |
217 assert_param(IS_GPIO_AF(GPIO_Init->Alternate)); | |
218 /* Configure Alternate function mapped with the current IO */ | |
219 temp = GPIOx->AFR[position >> 3]; | |
220 temp &= ~((uint32_t)0xF << ((uint32_t)(position & (uint32_t)0x07) * 4)) ; | |
221 temp |= ((uint32_t)(GPIO_Init->Alternate) << (((uint32_t)position & (uint32_t)0x07) * 4)); | |
222 GPIOx->AFR[position >> 3] = temp; | |
223 } | |
224 | |
225 /* Configure IO Direction mode (Input, Output, Alternate or Analog) */ | |
226 temp = GPIOx->MODER; | |
227 temp &= ~(GPIO_MODER_MODER0 << (position * 2)); | |
228 temp |= ((GPIO_Init->Mode & GPIO_MODE) << (position * 2)); | |
229 GPIOx->MODER = temp; | |
230 | |
231 /* In case of Output or Alternate function mode selection */ | |
232 if((GPIO_Init->Mode == GPIO_MODE_OUTPUT_PP) || (GPIO_Init->Mode == GPIO_MODE_AF_PP) || | |
233 (GPIO_Init->Mode == GPIO_MODE_OUTPUT_OD) || (GPIO_Init->Mode == GPIO_MODE_AF_OD)) | |
234 { | |
235 /* Check the Speed parameter */ | |
236 assert_param(IS_GPIO_SPEED(GPIO_Init->Speed)); | |
237 /* Configure the IO Speed */ | |
238 temp = GPIOx->OSPEEDR; | |
239 temp &= ~(GPIO_OSPEEDER_OSPEEDR0 << (position * 2)); | |
240 temp |= (GPIO_Init->Speed << (position * 2)); | |
241 GPIOx->OSPEEDR = temp; | |
242 | |
243 /* Configure the IO Output Type */ | |
244 temp = GPIOx->OTYPER; | |
245 temp &= ~(GPIO_OTYPER_OT_0 << position) ; | |
246 temp |= (((GPIO_Init->Mode & GPIO_OUTPUT_TYPE) >> 4) << position); | |
247 GPIOx->OTYPER = temp; | |
248 } | |
249 | |
250 /* Activate the Pull-up or Pull down resistor for the current IO */ | |
251 temp = GPIOx->PUPDR; | |
252 temp &= ~(GPIO_PUPDR_PUPDR0 << (position * 2)); | |
253 temp |= ((GPIO_Init->Pull) << (position * 2)); | |
254 GPIOx->PUPDR = temp; | |
255 | |
256 /*--------------------- EXTI Mode Configuration ------------------------*/ | |
257 /* Configure the External Interrupt or event for the current IO */ | |
258 if((GPIO_Init->Mode & EXTI_MODE) == EXTI_MODE) | |
259 { | |
260 /* Enable SYSCFG Clock */ | |
261 __HAL_RCC_SYSCFG_CLK_ENABLE(); | |
262 | |
263 temp = SYSCFG->EXTICR[position >> 2]; | |
264 temp &= ~(((uint32_t)0x0F) << (4 * (position & 0x03))); | |
265 temp |= ((uint32_t)(GPIO_GET_INDEX(GPIOx)) << (4 * (position & 0x03))); | |
266 SYSCFG->EXTICR[position >> 2] = temp; | |
267 | |
268 /* Clear EXTI line configuration */ | |
269 temp = EXTI->IMR; | |
270 temp &= ~((uint32_t)iocurrent); | |
271 if((GPIO_Init->Mode & GPIO_MODE_IT) == GPIO_MODE_IT) | |
272 { | |
273 temp |= iocurrent; | |
274 } | |
275 EXTI->IMR = temp; | |
276 | |
277 temp = EXTI->EMR; | |
278 temp &= ~((uint32_t)iocurrent); | |
279 if((GPIO_Init->Mode & GPIO_MODE_EVT) == GPIO_MODE_EVT) | |
280 { | |
281 temp |= iocurrent; | |
282 } | |
283 EXTI->EMR = temp; | |
284 | |
285 /* Clear Rising Falling edge configuration */ | |
286 temp = EXTI->RTSR; | |
287 temp &= ~((uint32_t)iocurrent); | |
288 if((GPIO_Init->Mode & RISING_EDGE) == RISING_EDGE) | |
289 { | |
290 temp |= iocurrent; | |
291 } | |
292 EXTI->RTSR = temp; | |
293 | |
294 temp = EXTI->FTSR; | |
295 temp &= ~((uint32_t)iocurrent); | |
296 if((GPIO_Init->Mode & FALLING_EDGE) == FALLING_EDGE) | |
297 { | |
298 temp |= iocurrent; | |
299 } | |
300 EXTI->FTSR = temp; | |
301 } | |
302 } | |
303 } | |
304 } | |
305 | |
306 /** | |
307 * @brief De-initializes the GPIOx peripheral registers to their default reset values. | |
308 * @param GPIOx: where x can be (A..K) to select the GPIO peripheral for STM32F429X device or | |
309 * x can be (A..I) to select the GPIO peripheral for STM32F40XX and STM32F427X devices. | |
310 * @param GPIO_Pin: specifies the port bit to be written. | |
311 * This parameter can be one of GPIO_PIN_x where x can be (0..15). | |
312 * @retval None | |
313 */ | |
314 void HAL_GPIO_DeInit(GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin) | |
315 { | |
316 uint32_t position; | |
317 uint32_t ioposition = 0x00; | |
318 uint32_t iocurrent = 0x00; | |
319 uint32_t tmp = 0x00; | |
320 | |
321 /* Check the parameters */ | |
322 assert_param(IS_GPIO_ALL_INSTANCE(GPIOx)); | |
323 | |
324 /* Configure the port pins */ | |
325 for(position = 0; position < GPIO_NUMBER; position++) | |
326 { | |
327 /* Get the IO position */ | |
328 ioposition = ((uint32_t)0x01) << position; | |
329 /* Get the current IO position */ | |
330 iocurrent = (GPIO_Pin) & ioposition; | |
331 | |
332 if(iocurrent == ioposition) | |
333 { | |
334 /*------------------------- GPIO Mode Configuration --------------------*/ | |
335 /* Configure IO Direction in Input Floating Mode */ | |
336 GPIOx->MODER &= ~(GPIO_MODER_MODER0 << (position * 2)); | |
337 | |
338 /* Configure the default Alternate Function in current IO */ | |
339 GPIOx->AFR[position >> 3] &= ~((uint32_t)0xF << ((uint32_t)(position & (uint32_t)0x07) * 4)) ; | |
340 | |
341 /* Configure the default value for IO Speed */ | |
342 GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (position * 2)); | |
343 | |
344 /* Configure the default value IO Output Type */ | |
345 GPIOx->OTYPER &= ~(GPIO_OTYPER_OT_0 << position) ; | |
346 | |
347 /* Deactivate the Pull-up and Pull-down resistor for the current IO */ | |
348 GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << (position * 2)); | |
349 | |
350 /*------------------------- EXTI Mode Configuration --------------------*/ | |
351 /* Configure the External Interrupt or event for the current IO */ | |
352 tmp = ((uint32_t)0x0F) << (4 * (position & 0x03)); | |
353 SYSCFG->EXTICR[position >> 2] &= ~tmp; | |
354 | |
355 /* Clear EXTI line configuration */ | |
356 EXTI->IMR &= ~((uint32_t)iocurrent); | |
357 EXTI->EMR &= ~((uint32_t)iocurrent); | |
358 | |
359 /* Clear Rising Falling edge configuration */ | |
360 EXTI->RTSR &= ~((uint32_t)iocurrent); | |
361 EXTI->FTSR &= ~((uint32_t)iocurrent); | |
362 } | |
363 } | |
364 } | |
365 | |
366 /** | |
367 * @} | |
368 */ | |
369 | |
370 /** @defgroup GPIO_Exported_Functions_Group2 IO operation functions | |
371 * @brief GPIO Read and Write | |
372 * | |
373 @verbatim | |
374 =============================================================================== | |
375 ##### IO operation functions ##### | |
376 =============================================================================== | |
377 | |
378 @endverbatim | |
379 * @{ | |
380 */ | |
381 | |
382 /** | |
383 * @brief Reads the specified input port pin. | |
384 * @param GPIOx: where x can be (A..K) to select the GPIO peripheral for STM32F429X device or | |
385 * x can be (A..I) to select the GPIO peripheral for STM32F40XX and STM32F427X devices. | |
386 * @param GPIO_Pin: specifies the port bit to read. | |
387 * This parameter can be GPIO_PIN_x where x can be (0..15). | |
388 * @retval The input port pin value. | |
389 */ | |
390 GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) | |
391 { | |
392 GPIO_PinState bitstatus; | |
393 | |
394 /* Check the parameters */ | |
395 assert_param(IS_GPIO_PIN(GPIO_Pin)); | |
396 | |
397 if((GPIOx->IDR & GPIO_Pin) != (uint32_t)GPIO_PIN_RESET) | |
398 { | |
399 bitstatus = GPIO_PIN_SET; | |
400 } | |
401 else | |
402 { | |
403 bitstatus = GPIO_PIN_RESET; | |
404 } | |
405 return bitstatus; | |
406 } | |
407 | |
408 /** | |
409 * @brief Sets or clears the selected data port bit. | |
410 * | |
411 * @note This function uses GPIOx_BSRR register to allow atomic read/modify | |
412 * accesses. In this way, there is no risk of an IRQ occurring between | |
413 * the read and the modify access. | |
414 * | |
415 * @param GPIOx: where x can be (A..K) to select the GPIO peripheral for STM32F429X device or | |
416 * x can be (A..I) to select the GPIO peripheral for STM32F40XX and STM32F427X devices. | |
417 * @param GPIO_Pin: specifies the port bit to be written. | |
418 * This parameter can be one of GPIO_PIN_x where x can be (0..15). | |
419 * @param PinState: specifies the value to be written to the selected bit. | |
420 * This parameter can be one of the GPIO_PinState enum values: | |
421 * @arg GPIO_PIN_RESET: to clear the port pin | |
422 * @arg GPIO_PIN_SET: to set the port pin | |
423 * @retval None | |
424 */ | |
425 void HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState) | |
426 { | |
427 /* Check the parameters */ | |
428 assert_param(IS_GPIO_PIN(GPIO_Pin)); | |
429 assert_param(IS_GPIO_PIN_ACTION(PinState)); | |
430 | |
431 if(PinState != GPIO_PIN_RESET) | |
432 { | |
433 GPIOx->BSRR = GPIO_Pin; | |
434 } | |
435 else | |
436 { | |
437 GPIOx->BSRR = (uint32_t)GPIO_Pin << 16; | |
438 } | |
439 } | |
440 | |
441 /** | |
442 * @brief Toggles the specified GPIO pins. | |
443 * @param GPIOx: Where x can be (A..K) to select the GPIO peripheral for STM32F429X device or | |
444 * x can be (A..I) to select the GPIO peripheral for STM32F40XX and STM32F427X devices. | |
445 * @param GPIO_Pin: Specifies the pins to be toggled. | |
446 * @retval None | |
447 */ | |
448 void HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) | |
449 { | |
450 /* Check the parameters */ | |
451 assert_param(IS_GPIO_PIN(GPIO_Pin)); | |
452 | |
453 GPIOx->ODR ^= GPIO_Pin; | |
454 } | |
455 | |
456 /** | |
457 * @brief Locks GPIO Pins configuration registers. | |
458 * @note The locked registers are GPIOx_MODER, GPIOx_OTYPER, GPIOx_OSPEEDR, | |
459 * GPIOx_PUPDR, GPIOx_AFRL and GPIOx_AFRH. | |
460 * @note The configuration of the locked GPIO pins can no longer be modified | |
461 * until the next reset. | |
462 * @param GPIOx: where x can be (A..F) to select the GPIO peripheral for STM32F4 family | |
463 * @param GPIO_Pin: specifies the port bit to be locked. | |
464 * This parameter can be any combination of GPIO_PIN_x where x can be (0..15). | |
465 * @retval None | |
466 */ | |
467 HAL_StatusTypeDef HAL_GPIO_LockPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin) | |
468 { | |
469 __IO uint32_t tmp = GPIO_LCKR_LCKK; | |
470 | |
471 /* Check the parameters */ | |
472 assert_param(IS_GPIO_PIN(GPIO_Pin)); | |
473 | |
474 /* Apply lock key write sequence */ | |
475 tmp |= GPIO_Pin; | |
476 /* Set LCKx bit(s): LCKK='1' + LCK[15-0] */ | |
477 GPIOx->LCKR = tmp; | |
478 /* Reset LCKx bit(s): LCKK='0' + LCK[15-0] */ | |
479 GPIOx->LCKR = GPIO_Pin; | |
480 /* Set LCKx bit(s): LCKK='1' + LCK[15-0] */ | |
481 GPIOx->LCKR = tmp; | |
482 /* Read LCKK bit*/ | |
483 tmp = GPIOx->LCKR; | |
484 | |
485 if((GPIOx->LCKR & GPIO_LCKR_LCKK) != RESET) | |
486 { | |
487 return HAL_OK; | |
488 } | |
489 else | |
490 { | |
491 return HAL_ERROR; | |
492 } | |
493 } | |
494 | |
495 /** | |
496 * @brief This function handles EXTI interrupt request. | |
497 * @param GPIO_Pin: Specifies the pins connected EXTI line | |
498 * @retval None | |
499 */ | |
500 void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin) | |
501 { | |
502 /* EXTI line interrupt detected */ | |
503 if(__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != RESET) | |
504 { | |
505 __HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin); | |
506 HAL_GPIO_EXTI_Callback(GPIO_Pin); | |
507 } | |
508 } | |
509 | |
510 /** | |
511 * @brief EXTI line detection callbacks. | |
512 * @param GPIO_Pin: Specifies the pins connected EXTI line | |
513 * @retval None | |
514 */ | |
515 __weak void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) | |
516 { | |
517 /* NOTE: This function Should not be modified, when the callback is needed, | |
518 the HAL_GPIO_EXTI_Callback could be implemented in the user file | |
519 */ | |
520 } | |
521 | |
522 /** | |
523 * @} | |
524 */ | |
525 | |
526 | |
527 /** | |
528 * @} | |
529 */ | |
530 | |
531 #endif /* HAL_GPIO_MODULE_ENABLED */ | |
532 /** | |
533 * @} | |
534 */ | |
535 | |
536 /** | |
537 * @} | |
538 */ | |
539 | |
540 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |