Input Interrupt

This sample uses the GPIO input function to detect the GPIO input signal by interrupt.

This sample starts with configuring the GPIO as input and enabling the interrupt function. An interrupt is triggered and the interrupt handler prints information when a GPIO input change is detected.

Requirements

The sample supports the following development kits:

Development Kits
Hardware Platforms	Board Name
RTL87x2G HDK	RTL87x2G EVB

For more requirements, please refer to Quick Start.

Wiring

Connect P4_0 to the external input signal.

Building and Downloading

This sample can be found in the SDK folder:

Keil

Project file: samples\peripheral\gpio\input_interrupt\proj\rtl87x2g\mdk

GCC

Project file: samples\peripheral\gpio\input_interrupt\proj\rtl87x2g\gcc

To build and run the sample, follow the steps listed below:

Open sample project file.
To build the target, follow the steps listed on the Generating App Image in Quick Start.
After a successful compilation, the app bin app_MP_xxx.bin will be generated in the directory mdk\bin or gcc\bin.
To download app bin into EVB board, follow the steps listed on the MP Tool Download in Quick Start.
Press reset button on EVB board and it will start running.

Experimental Verification

After resetting the EVB, observe the log messages as shown in the Debug Analyzer.
```
Start input interrupt test!
```
The external input signal is controlled to change from high to low, and P4_0 detects the falling edge signal to trigger an interrupt. The interrupt handler function GPIO_Input_Handler prints the following information.
```
enter GPIO_Pin_Handler success
```

Code Overview

This chapter will be introduced according to the following several parts：

Source code directory.
Peripheral initialization will be introduced in chapter Initialization.
Functional implementation after initialization will be introduced in chapter Functional implementation.

Source Code Directory

Project directory: sdk\samples\peripheral\gpio\input_interrupt\proj
Source code directory: sdk\samples\peripheral\gpio\input_interrupt\src

Source files are currently categorized into several groups as below.

└── Project: output_toggle
    └── secure_only_app
        └── Device                   includes startup code
            ├── startup_rtl.c
            └── system_rtl.c
        ├── CMSIS                    includes CMSIS header files
        ├── CMSE Library             Non-secure callable lib
        ├── lib                      includes all binary symbol files that user application is built on
            └── rtl87x2g_io.lib
        ├── peripheral               includes all peripheral drivers and module code used by the application
            ├── rtl_gpio.c
            ├── rtl_nvic.c
            ├── rtl_pinmux.c
            └── rtl_rcc.c
        └── APP                      includes the ble_peripheral user application implementation
            ├── io_gpio.c
            └── main_ns.c

Initialization

The initialization process includes board_gpio_init and driver_gpio_init .

board_gpio_init contains the PAD and PINMUX settings:

Configure PAD: Set the pin as PINMUX mode, PowerOn, internal Pull-Up.
Configure PINMUX: Multiplex the pin to GPIO function.

driver_gpio_init contains the initialization of GPIO peripheral.

Enable PCC Clock.
Set GPIO_Mode to GPIO input mode.
Enable GPIO Interrupt mode.
Set GPIO interrupt trigger mode GPIO_ITTrigger to edge trigger.
Set GPIO interrupt polarity GPIO_ITPolarity to falling edge trigger.
Enable GPIO Debounce.
1. Set GPIO debounce clock Source, clock division and debounce count limit.
NVIC initialize: determine priority of interrupt and enable GPIO_PIN_INPUT_IRQN channel.
Mask GPIO interrupt, enable GPIO interrupt, clear GPIO interrupt flag, unmask GPIO interrupt.

RCC_PeriphClockCmd(APBPeriph_GPIOB, APBPeriph_GPIOB_CLOCK, ENABLE);
...
GPIO_InitStruct.GPIO_Mode       = GPIO_DIR_IN;
GPIO_InitStruct.GPIO_ITCmd      = ENABLE;
GPIO_InitStruct.GPIO_ITTrigger  = GPIO_INT_Trigger_EDGE;
GPIO_InitStruct.GPIO_ITPolarity = GPIO_INT_POLARITY_ACTIVE_LOW;

GPIO_InitStruct.GPIO_ITDebounce        = GPIO_INT_DEBOUNCE_ENABLE;
GPIO_InitStruct.GPIO_DebounceClkSource = GPIO_DEBOUNCE_32K;
GPIO_InitStruct.GPIO_DebounceClkDiv    = GPIO_DEBOUNCE_DIVIDER_1;
GPIO_InitStruct.GPIO_DebounceCntLimit  = 32 - 1;
...
NVIC_Init(&NVIC_InitStruct);

GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN, ENABLE);
GPIO_INTConfig(GPIO_PORT, GPIO_PIN, ENABLE);
GPIO_ClearINTPendingBit(GPIO_PORT, GPIO_PIN);
GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN, DISABLE);

Functional Implementation

When connecting P4_0 to GND (a falling edge on P4_0), detecting a falling edge of P4_0 triggers a GPIO interrupt. The interrupt handler function GPIO_Pin_Handler prints interrupt information.

In the interrupt handler, disabling and masking the corresponding GPIO interrupt should be executed first, and clearing the interrupt flag, unmasking, and enabling the GPIO interrupt should be executed last.

/* Mask and disable interrupt */
GPIO_INTConfig(GPIO_PORT, GPIO_PIN, DISABLE);
GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN, ENABLE);

DBG_DIRECT("enter GPIO_Pin_Handler success");

/* Clear int flag, unmask and enable interrupt */
GPIO_ClearINTPendingBit(GPIO_PORT, GPIO_PIN);
GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN, DISABLE);
GPIO_INTConfig(GPIO_PORT, GPIO_PIN, ENABLE);

Troubleshooting

GPIO False Trigger Interrupt

GPIO edge-type interrupts will be self-triggered when enabling the GPIO interrupt in the following four modes:

PAD input = high, rising edge triggered interrupt.
PAD input = high, double edge triggered interrupt.
PAD input = low, falling edge triggered interrupt.
PAD input = low, double edge triggered interrupt.

The below flow can be used to enable edge interrupt in these cases to avoid self-triggered interrupt:

Mask GPIO interrupt: GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN, ENABLE).
Enable edge interrupt: GPIO_INTConfig(GPIO_PORT, GPIO_PIN, ENABLE).
Clear GPIO interrupt state: GPIO_ClearPendingBit(GPIO_PORT, GPIO_PIN).
Unmask GPIO interrupt: GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN, DISABLE).

The following flow can modify the GPIO interrupt configurations to avoid self-triggered interrupt:

Mask GPIO interrupt: GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN, ENABLE).
Modify GPIO interrupt configurations (change interrupt trigger edge and polarity): GPIO_SetITTrigger(GPIO_PORT, GPIO_PIN, GPIO_TriggerMode) GPIO_SetITPolarity(GPIO_PORT, GPIO_PIN, GPIO_ITPolarity)....
Clear GPIO interrupt state: GPIO_ClearPendingBit(GPIO_PORT, GPIO_PIN).
Unmask GPIO interrupt: GPIO_MaskINTConfig(GPIO_PORT, GPIO_PIN, DISABLE).