gpio_driver: add per-pin interrupt handlers

1. add ISR handler apis so that users of different layers can hook their own isr handler on different GPIO.
    Audio project has different software layers, they need different gpio isr handler for layer instead of processing all GPIO interrupts in one handler.
    If this kind of calling a handler from isr is not proper, please kindly point out.
2. add gpio example code.
3. improve gpio.rst
4. add readme for gpio example

Squashed commits:
[278e50f] update: GPIO
1. coding style, add a space between conditional or loop keyword and an opening paren.
2. modify some return value and doc
3. use printf in example code
Squashed commits:
[efb23bb] minor change of comment

components/driver/gpio.c

@@ -72,45 +72,59 @@ const uint32_t GPIO_PIN_MUX_REG[GPIO_PIN_COUNT] = {
     GPIO_PIN_REG_39
 };
 
-esp_err_t gpio_pullup_en(gpio_num_t gpio_num) {
+typedef struct {
+    gpio_isr_t fn;   /*!< isr function */
+    void* args;      /*!< isr function args */
+} gpio_isr_func_t;
+
+static gpio_isr_func_t* gpio_isr_func = NULL;
+static gpio_isr_handle_t gpio_isr_handle;
+static portMUX_TYPE gpio_spinlock = portMUX_INITIALIZER_UNLOCKED;
+
+esp_err_t gpio_pullup_en(gpio_num_t gpio_num)
+{
     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
-    if(RTC_GPIO_IS_VALID_GPIO(gpio_num)){
+    if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
         rtc_gpio_pullup_en(gpio_num);
-    }else{
+    } else {
         REG_SET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PU);
     }
     return ESP_OK;
 }
 
-esp_err_t gpio_pullup_dis(gpio_num_t gpio_num) {
+esp_err_t gpio_pullup_dis(gpio_num_t gpio_num)
+{
     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
-    if(RTC_GPIO_IS_VALID_GPIO(gpio_num)){
+    if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
         rtc_gpio_pullup_dis(gpio_num);
-    }else{
+    } else {
         REG_CLR_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PU);
     }
     return ESP_OK;
 }
 
-esp_err_t gpio_pulldown_en(gpio_num_t gpio_num) {
+esp_err_t gpio_pulldown_en(gpio_num_t gpio_num)
+{
     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
-    if(RTC_GPIO_IS_VALID_GPIO(gpio_num)){
+    if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
         rtc_gpio_pulldown_en(gpio_num);
-    }else{
-         REG_SET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PD);
+    } else {
+        REG_SET_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PD);
     }
     return ESP_OK;
 }
 
-esp_err_t gpio_pulldown_dis(gpio_num_t gpio_num) {
+esp_err_t gpio_pulldown_dis(gpio_num_t gpio_num)
+{
     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
-    if(RTC_GPIO_IS_VALID_GPIO(gpio_num)){
-        rtc_gpio_pulldown_dis(gpio_num);   
-    }else{
+    if (RTC_GPIO_IS_VALID_GPIO(gpio_num)) {
+        rtc_gpio_pulldown_dis(gpio_num);
+    } else {
         REG_CLR_BIT(GPIO_PIN_MUX_REG[gpio_num], FUN_PD);
     }
     return ESP_OK;
 }
+
 esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type)
 {
     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
@@ -323,6 +337,96 @@ esp_err_t gpio_config(gpio_config_t *pGPIOConfig)
     return ESP_OK;
 }
 
+void IRAM_ATTR gpio_intr_service(void* arg)
+{
+    //GPIO intr process
+    uint32_t gpio_num = 0;
+    //read status to get interrupt status for GPIO0-31
+    uint32_t gpio_intr_status;
+    gpio_intr_status = GPIO.status;
+    //read status1 to get interrupt status for GPIO32-39
+    uint32_t gpio_intr_status_h;
+    gpio_intr_status_h = GPIO.status1.intr_st;
+
+    if (gpio_isr_func == NULL) {
+        return;
+    }
+    do {
+        if (gpio_num < 32) {
+            if (gpio_intr_status & BIT(gpio_num)) { //gpio0-gpio31
+                if (gpio_isr_func[gpio_num].fn != NULL) {
+                    gpio_isr_func[gpio_num].fn(gpio_isr_func[gpio_num].args);
+                }
+                GPIO.status_w1tc = BIT(gpio_num);
+            }
+        } else {
+            if (gpio_intr_status_h & BIT(gpio_num - 32)) {
+                if (gpio_isr_func[gpio_num].fn != NULL) {
+                    gpio_isr_func[gpio_num].fn(gpio_isr_func[gpio_num].args);
+                }
+                GPIO.status1_w1tc.intr_st = BIT(gpio_num - 32);
+            }
+        }
+    } while (++gpio_num < GPIO_PIN_COUNT);
+}
+
+esp_err_t gpio_isr_handler_add(gpio_num_t gpio_num, gpio_isr_t isr_handler, void* args)
+{
+    GPIO_CHECK(gpio_isr_func != NULL, "GPIO isr service is not installed, call gpio_install_isr_service() first", ESP_ERR_INVALID_STATE);
+    GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
+    portENTER_CRITICAL(&gpio_spinlock);
+    gpio_intr_disable(gpio_num);
+    if (gpio_isr_func) {
+        gpio_isr_func[gpio_num].fn = isr_handler;
+        gpio_isr_func[gpio_num].args = args;
+    }
+    gpio_intr_enable(gpio_num);
+    portEXIT_CRITICAL(&gpio_spinlock);
+    return ESP_OK;
+}
+
+esp_err_t gpio_isr_handler_remove(gpio_num_t gpio_num)
+{
+    GPIO_CHECK(gpio_isr_func != NULL, "GPIO isr service is not installed, call gpio_install_isr_service() first", ESP_ERR_INVALID_STATE);
+    GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
+    portENTER_CRITICAL(&gpio_spinlock);
+    gpio_intr_disable(gpio_num);
+    if (gpio_isr_func) {
+        gpio_isr_func[gpio_num].fn = NULL;
+        gpio_isr_func[gpio_num].args = NULL;
+    }
+    portEXIT_CRITICAL(&gpio_spinlock);
+    return ESP_OK;
+}
+
+esp_err_t gpio_install_isr_service(int intr_alloc_flags)
+{
+    GPIO_CHECK(gpio_isr_func == NULL, "GPIO isr service already installed", ESP_FAIL);
+    esp_err_t ret;
+    portENTER_CRITICAL(&gpio_spinlock);
+    gpio_isr_func = (gpio_isr_func_t*) calloc(GPIO_NUM_MAX, sizeof(gpio_isr_func_t));
+    if (gpio_isr_func == NULL) {
+        ret = ESP_ERR_NO_MEM;
+    } else {
+        ret = gpio_isr_register(gpio_intr_service, NULL, intr_alloc_flags, &gpio_isr_handle);
+    }
+    portEXIT_CRITICAL(&gpio_spinlock);
+    return ret;
+}
+
+void gpio_uninstall_isr_service()
+{
+    if (gpio_isr_func == NULL) {
+        return;
+    }
+    portENTER_CRITICAL(&gpio_spinlock);
+    esp_intr_free(gpio_isr_handle);
+    free(gpio_isr_func);
+    gpio_isr_func = NULL;
+    portEXIT_CRITICAL(&gpio_spinlock);
+    return;
+}
+
 esp_err_t gpio_isr_register(void (*fn)(void*), void * arg, int intr_alloc_flags, gpio_isr_handle_t *handle)
 {
     GPIO_CHECK(fn, "GPIO ISR null", ESP_ERR_INVALID_ARG);
@@ -334,7 +438,7 @@ esp_err_t gpio_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type)
 {
     GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
     esp_err_t ret = ESP_OK;
-    if ((intr_type == GPIO_INTR_LOW_LEVEL) || (intr_type == GPIO_INTR_HIGH_LEVEL)) {
+    if (( intr_type == GPIO_INTR_LOW_LEVEL ) || ( intr_type == GPIO_INTR_HIGH_LEVEL )) {
         GPIO.pin[gpio_num].int_type = intr_type;
         GPIO.pin[gpio_num].wakeup_enable = 0x1;
     } else {

components/driver/include/driver/gpio.h

@@ -156,6 +156,7 @@ typedef enum {
     GPIO_NUM_37 = 37,   /*!< GPIO37, input mode only */
     GPIO_NUM_38 = 38,   /*!< GPIO38, input mode only */
     GPIO_NUM_39 = 39,   /*!< GPIO39, input mode only */
+    GPIO_NUM_MAX = 40,
 } gpio_num_t;
 
 typedef enum {
@@ -205,9 +206,8 @@ typedef enum {
 } gpio_pull_mode_t;
 
 
-
+typedef void (*gpio_isr_t)(void*);
 typedef intr_handle_t gpio_isr_handle_t;
-typedef void (*gpio_event_callback)(gpio_num_t gpio_intr_num);
 
 /**
  * @brief GPIO common configuration
@@ -357,8 +357,6 @@ esp_err_t gpio_wakeup_disable(gpio_num_t gpio_num);
  */
 esp_err_t gpio_isr_register(void (*fn)(void*), void * arg, int intr_alloc_flags, gpio_isr_handle_t *handle);
 
-
-
 /**
   * @brief Enable pull-up on GPIO.
   *
@@ -403,93 +401,55 @@ esp_err_t gpio_pulldown_en(gpio_num_t gpio_num);
   */
 esp_err_t gpio_pulldown_dis(gpio_num_t gpio_num);
 
-
-/**
- * ***************        ATTENTION       ********************/
 /**
- *@attention
- *     Each GPIO has its own separate configuration register, so we do not use
- *     a lock to serialize access to them. This works under the assumption that
- *     no situation will occur where two tasks try to configure the same GPIO
- *     pin simultaneously. It is up to the application developer to guarantee this.
- */
+  * @brief Install a GPIO ISR service, so we can assign different ISR handler for different pins
+  *
+  * @param intr_alloc_flags Flags used to allocate the interrupt. One or multiple (ORred)
+  *            ESP_INTR_FLAG_* values. See esp_intr_alloc.h for more info.
+  *
+  * @return
+  *     - ESP_OK Success
+  *     - ESP_FAIL Operation fail
+  *     - ESP_ERR_NO_MEM No memory to install this service
+  */
+esp_err_t gpio_install_isr_service(int intr_alloc_flags);
 
 /**
- *----------EXAMPLE TO CONFIGURE GPIO AS OUTPUT ------------ *
- * @code{c}
- *     gpio_config_t io_conf;
- *     io_conf.intr_type = GPIO_INTR_DISABLE;             //disable interrupt
- *     io_conf.mode = GPIO_MODE_OUTPUT;                       //set as output mode
- *     io_conf.pin_bit_mask = GPIO_SEL_18 | GPIO_SEL_19;      //bit mask of the pins that you want to set,e.g.GPIO18/19
- *     io_conf.pull_down_en = 0;                              //disable pull-down mode
- *     io_conf.pull_up_en = 0;                                //disable pull-up mode
- *     gpio_config(&io_conf);                                 //configure GPIO with the given settings
- * @endcode
- **/
+  * @brief Un-install GPIO ISR service, free the resources.
+  */
+void gpio_uninstall_isr_service();
 
 /**
- *----------EXAMPLE TO CONFIGURE GPIO AS OUTPUT ------------ *
- * @code{c}
- *     io_conf.intr_type = GPIO_INTR_POSEDGE;             //set posedge interrupt
- *     io_conf.mode = GPIO_MODE_INPUT;                        //set as input
- *     io_conf.pin_bit_mask = GPIO_SEL_4 | GPIO_SEL_5;        //bit mask of the pins that you want to set, e.g.,GPIO4/5
- *     io_conf.pull_down_en = 0;                              //disable pull-down mode
- *     io_conf.pull_up_en = 1;                                //enable pull-up mode
- *     gpio_config(&io_conf);                                 //configure GPIO with the given settings
- * @endcode
- */
-/**
- *----------EXAMPLE TO SET ISR HANDLER ----------------------
- * @code{c}
- * gpio_isr_register(gpio_intr_test, 0, NULL);    //hook the isr handler for GPIO interrupt
- * @endcode
- */
-/**
- *-------------EXAMPLE OF HANDLER FUNCTION-------------------*
- * @code{c}
- * #include "esp_attr.h"
- * void IRAM_ATTR gpio_intr_test(void* arg)
- * {
- *     //GPIO intr process
- *     ets_printf("in gpio_intr\n");
- *     uint32_t gpio_num = 0;
- *     uint32_t gpio_intr_status = READ_PERI_REG(GPIO_STATUS_REG);   //read status to get interrupt status for GPIO0-31
- *     uint32_t gpio_intr_status_h = READ_PERI_REG(GPIO_STATUS1_REG);//read status1 to get interrupt status for GPIO32-39
- *     SET_PERI_REG_MASK(GPIO_STATUS_W1TC_REG, gpio_intr_status);    //Clear intr for gpio0-gpio31
- *     SET_PERI_REG_MASK(GPIO_STATUS1_W1TC_REG, gpio_intr_status_h); //Clear intr for gpio32-39
- *     do {
- *         if(gpio_num < 32) {
- *             if(gpio_intr_status & BIT(gpio_num)) { //gpio0-gpio31
- *                 ets_printf("Intr GPIO%d ,val: %d\n",gpio_num,gpio_get_level(gpio_num));
- *                 //This is an isr handler, you should post an event to process it in RTOS queue.
- *             }
- *         } else {
- *             if(gpio_intr_status_h & BIT(gpio_num - 32)) {
- *                 ets_printf("Intr GPIO%d, val : %d\n",gpio_num,gpio_get_level(gpio_num));
- *                 //This is an isr handler, you should post an event to process it in RTOS queue.
- *             }
- *         }
- *     } while(++gpio_num < GPIO_PIN_COUNT);
- * }
- * @endcode
- */
+  * @brief Add ISR handler for the corresponding GPIO.
+  *
+  *        Interrupt handlers no longer need to be declared with IRAM_ATTR, unless you pass the ESP_INTR_FLAG_IRAM flag
+  *        when allocating the ISR in gpio_install_isr_service().
+  *        This ISR handler will be called from an ISR. So there probably is some stack size limit, and this limit
+  *        is smaller compared to a "raw" interrupt handler due to another level of indirection.
+  *
+  * @param gpio_num GPIO number
+  * @param isr_handler ISR handler function for the corresponding GPIO number.
+  * @param args parameter for ISR handler.
+  *
+  * @return
+  *     - ESP_OK Success
+  *     - ESP_ERR_INVALID_STATE Wrong state, the ISR service has not been initialized.
+  *     - ESP_ERR_INVALID_ARG Parameter error
+  */
+esp_err_t gpio_isr_handler_add(gpio_num_t gpio_num, gpio_isr_t isr_handler, void* args);
 
 /**
- *----EXAMPLE OF I2C CONFIG AND PICK SIGNAL FOR IO MATRIX---*
- * @code{c}
- * gpio_config_t io_conf;
- * io_conf.intr_type = GPIO_INTR_DISABLE;                 //disable interrupt
- * io_conf.mode = GPIO_MODE_INPUT_OUTPUT_OD;              //set as output mode
- * io_conf.pin_bit_mask = GPIO_SEL_21 | GPIO_SEL_22;      //bit mask of the pins that you want to set,e.g.GPIO21/22
- * io_conf.pull_down_en = 0;                              //disable pull-down mode
- * io_conf.pull_up_en = 1;                                //enable pull-up mode
- * gpio_config(&io_conf);                                 //configure GPIO with the given settings
- * gpio_matrix_out(21, EXT_I2C_SCL_O_IDX, 0,  0);         //set output signal for io_matrix
- * gpio_matrix_out(22, EXT_I2C_SDA_O_IDX, 0,  0);         //set output signal for io_matrix
- * gpio_matrix_in( 22, EXT_I2C_SDA_I_IDX, 0);             //set input signal for io_matrix
- * @endcode
- *
- */
+  * @brief Remove ISR handler for the corresponding GPIO.
+  *
+  * @param gpio_num GPIO number
+  *
+  * @return
+  *     - ESP_OK Success
+  *     - ESP_ERR_INVALID_STATE Wrong state, the ISR service has not been initialized.
+  *     - ESP_ERR_INVALID_ARG Parameter error
+  */
+esp_err_t gpio_isr_handler_remove(gpio_num_t gpio_num);
+
 
 #ifdef __cplusplus
 }

docs/api/gpio.rst

@@ -4,20 +4,17 @@ GPIO
 Overview
 --------
 
-`Instructions`_
+The ESP32 chip features 40 physical GPIO pads. Some GPIO pads cannot be used or do not have the corresponding pin on the chip package(refer to technical reference manual ). Each pad can be used as a general purpose I/O or can be connected to an internal peripheral signal.
+Note that GPIO6-11 are usually used for SPI flash. GPIO34-39 can only be set as input mode.
 
 Application Example
 -------------------
 
-`Instructions`_
+GPIO output and input interrupt example: `examples/21_gpio <https://github.com/espressif/esp-idf/tree/master/examples/21_gpio>`_.
 
 API Reference
 -------------
 
-`Instructions`_
-
-.. _Instructions: template.html
-
 Header Files
 ^^^^^^^^^^^^
 
@@ -110,7 +107,8 @@ Macros
 Type Definitions
 ^^^^^^^^^^^^^^^^
 
-.. doxygentypedef:: gpio_event_callback
+.. doxygentypedef:: gpio_isr_t
+.. doxygentypedef:: gpio_isr_handle_t
 
 Enumerations
 ^^^^^^^^^^^^
@@ -122,6 +120,13 @@ Enumerations
 .. doxygenenum:: gpio_pulldown_t
 .. doxygenenum:: gpio_pull_mode_t
 
+Structures
+^^^^^^^^^^
+
+.. doxygenstruct:: gpio_config_t
+    :members:
+
+
 Functions
 ^^^^^^^^^
 
@@ -136,3 +141,12 @@ Functions
 .. doxygenfunction:: gpio_wakeup_enable
 .. doxygenfunction:: gpio_wakeup_disable
 .. doxygenfunction:: gpio_isr_register
+.. doxygenfunction:: gpio_pullup_en
+.. doxygenfunction:: gpio_pullup_dis
+.. doxygenfunction:: gpio_pulldown_en
+.. doxygenfunction:: gpio_pulldown_dis
+.. doxygenfunction:: gpio_install_isr_service
+.. doxygenfunction:: gpio_uninstall_isr_service
+.. doxygenfunction:: gpio_isr_handler_add
+.. doxygenfunction:: gpio_isr_handler_remove
+

examples/21_gpio/Makefile

@@ -0,0 +1,9 @@
+#
+# This is a project Makefile. It is assumed the directory this Makefile resides in is a
+# project subdirectory.
+#
+
+PROJECT_NAME := gpio
+
+include $(IDF_PATH)/make/project.mk
+

examples/21_gpio/README.md

@@ -0,0 +1,20 @@
+# Example: GPIO
+
+###This test code shows how to configure gpio and how to use gpio interrupt.
+
+ 
+####GPIO functions:
+
+ * GPIO18: output
+ * GPIO19: output
+ * GPIO4:  input, pulled up, interrupt from rising edge and falling edge
+ * GPIO5:  input, pulled up, interrupt from rising edge.
+ 
+####Test:
+ * Connect GPIO18 with GPIO4
+ * Connect GPIO19 with GPIO5
+ * Generate pulses on GPIO18/19, that triggers interrupt on GPIO4/5
+ 
+
+
+

examples/21_gpio/main/component.mk

@@ -0,0 +1,3 @@
+#
+# Main Makefile. This is basically the same as a component makefile.
+#

examples/21_gpio/main/gpio_test.c

@@ -0,0 +1,114 @@
+/* GPIO Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "driver/gpio.h"
+
+/**
+ * Brief:
+ * This test code shows how to configure gpio and how to use gpio interrupt.
+ *
+ * GPIO status:
+ * GPIO18: output
+ * GPIO19: output
+ * GPIO4:  input, pulled up, interrupt from rising edge and falling edge
+ * GPIO5:  input, pulled up, interrupt from rising edge.
+ *
+ * Test:
+ * Connect GPIO18 with GPIO4
+ * Connect GPIO19 with GPIO5
+ * Generate pulses on GPIO18/19, that triggers interrupt on GPIO4/5
+ *
+ */
+
+#define GPIO_OUTPUT_IO_0    18
+#define GPIO_OUTPUT_IO_1    19
+#define GPIO_OUTPUT_PIN_SEL  ((1<<GPIO_OUTPUT_IO_0) | (1<<GPIO_OUTPUT_IO_1))
+#define GPIO_INPUT_IO_0     4
+#define GPIO_INPUT_IO_1     5
+#define GPIO_INPUT_PIN_SEL  ((1<<GPIO_INPUT_IO_0) | (1<<GPIO_INPUT_IO_1))
+#define ESP_INTR_FLAG_DEFAULT 0
+
+static xQueueHandle gpio_evt_queue = NULL;
+
+void IRAM_ATTR gpio_isr_handler(void* arg)
+{
+    uint32_t gpio_num = (uint32_t) arg;
+    xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);
+}
+
+void gpio_task_example(void* arg)
+{
+    uint32_t io_num;
+    for(;;) {
+        if(xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY)) {
+            printf("GPIO[%d] intr, val: %d\n", io_num, gpio_get_level(io_num));
+        }
+    }
+}
+
+void app_main()
+{
+    gpio_config_t io_conf;
+    //disable interrupt
+    io_conf.intr_type = GPIO_PIN_INTR_DISABLE;
+    //set as output mode        
+    io_conf.mode = GPIO_MODE_OUTPUT;
+    //bit mask of the pins that you want to set,e.g.GPIO18/19
+    io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL;
+    //disable pull-down mode
+    io_conf.pull_down_en = 0;
+    //disable pull-up mode
+    io_conf.pull_up_en = 0;
+    //configure GPIO with the given settings
+    gpio_config(&io_conf);
+
+    //interrupt of rising edge
+    io_conf.intr_type = GPIO_PIN_INTR_POSEDGE;
+    //bit mask of the pins, use GPIO4/5 here
+    io_conf.pin_bit_mask = GPIO_INPUT_PIN_SEL;
+    //set as input mode    
+    io_conf.mode = GPIO_MODE_INPUT;
+    //enable pull-up mode
+    io_conf.pull_up_en = 1;
+    gpio_config(&io_conf);
+
+    //change gpio intrrupt type for one pin
+    gpio_set_intr_type(GPIO_INPUT_IO_0, GPIO_INTR_ANYEDGE);
+
+    //create a queue to handle gpio event from isr
+    gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));
+    //start gpio task
+    xTaskCreate(gpio_task_example, "gpio_task_example", 2048, NULL, 10, NULL);
+
+    //install gpio isr service
+    gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT);
+    //hook isr handler for specific gpio pin
+    gpio_isr_handler_add(GPIO_INPUT_IO_0, gpio_isr_handler, (void*) GPIO_INPUT_IO_0);
+    //hook isr handler for specific gpio pin
+    gpio_isr_handler_add(GPIO_INPUT_IO_1, gpio_isr_handler, (void*) GPIO_INPUT_IO_1);
+
+    //remove isr handler for gpio number.
+    gpio_isr_handler_remove(GPIO_INPUT_IO_0);
+    //hook isr handler for specific gpio pin again
+    gpio_isr_handler_add(GPIO_INPUT_IO_0, gpio_isr_handler, (void*) GPIO_INPUT_IO_0);
+
+    int cnt = 0;
+    while(1) {
+        printf("cnt: %d\n", cnt++);
+        vTaskDelay(1000 / portTICK_RATE_MS);
+        gpio_set_level(GPIO_OUTPUT_IO_0, cnt % 2);
+        gpio_set_level(GPIO_OUTPUT_IO_1, cnt % 2);
+    }
+}
+