#include "esp_err.h"\r
#include "esp_intr.h"\r
#include "freertos/FreeRTOS.h"\r
-#include "freertos/semphr.h"\r
#include "freertos/xtensa_api.h"\r
#include "soc/soc.h"\r
#include "driver/gpio.h"\r
#define GPIO_ERROR(...)\r
#endif \r
\r
-const uint32_t GPIO_PIN_MUX_REG[40] = {\r
+const uint32_t GPIO_PIN_MUX_REG[GPIO_PIN_COUNT] = {\r
GPIO_PIN_REG_0,\r
GPIO_PIN_REG_1,\r
GPIO_PIN_REG_2,\r
GPIO_PIN_REG_39\r
};\r
\r
-static SemaphoreHandle_t gpio_mutex = NULL;\r
-\r
+#define IS_VALID_GPIO(gpio_num) ( (gpio_num < GPIO_PIN_COUNT && GPIO_PIN_MUX_REG[gpio_num] != 0))\r
static int is_valid_gpio(int gpio_num)\r
{\r
if(gpio_num >= GPIO_PIN_COUNT || GPIO_PIN_MUX_REG[gpio_num] == 0) {\r
return 1;\r
}\r
\r
-static esp_err_t gpio_mutex_init()\r
-{\r
- if(gpio_mutex == NULL) {\r
- gpio_mutex = xSemaphoreCreateRecursiveMutex();\r
- if(gpio_mutex == NULL)\r
- return ESP_FAIL;\r
- }\r
- return ESP_OK;\r
-}\r
-\r
-static esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, uint8_t intr_type)\r
+esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type)\r
{\r
if(!is_valid_gpio(gpio_num))\r
return ESP_ERR_INVALID_ARG;\r
GPIO_ERROR("Unknown GPIO intr:%u\n",intr_type);\r
return ESP_ERR_INVALID_ARG;\r
}\r
- if(gpio_mutex != NULL) {\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- GPIO.pin[gpio_num].int_type = intr_type;\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ESP_OK;\r
- } else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
- }\r
-}\r
-\r
-static esp_err_t gpio_intr_enable(gpio_num_t gpio_num)\r
-{\r
- if(!is_valid_gpio(gpio_num))\r
- return ESP_ERR_INVALID_ARG;\r
- if(gpio_mutex != NULL) {\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- if(xPortGetCoreID() == 0) {\r
- GPIO.pin[gpio_num].int_ena = GPIO_PRO_CPU_INTR_ENA; //enable pro cpu intr\r
- } else {\r
- GPIO.pin[gpio_num].int_ena = GPIO_APP_CPU_INTR_ENA; //enable pro cpu intr\r
- }\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ESP_OK;\r
- } else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
- }\r
-}\r
-\r
-static esp_err_t gpio_intr_disable(gpio_num_t gpio_num)\r
-{\r
- if(!is_valid_gpio(gpio_num))\r
- return ESP_ERR_INVALID_ARG;\r
- if(gpio_mutex != NULL) {\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- GPIO.pin[gpio_num].int_ena = 0; //disable GPIO intr\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ESP_OK;\r
- } else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
- }\r
+ GPIO.pin[gpio_num].int_type = intr_type;\r
+ return ESP_OK;\r
}\r
\r
-static esp_err_t gpio_input_enable(gpio_num_t gpio_num)\r
+esp_err_t gpio_intr_enable(gpio_num_t gpio_num)\r
{\r
if(!is_valid_gpio(gpio_num))\r
return ESP_ERR_INVALID_ARG;\r
- if(gpio_mutex != NULL) {\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[gpio_num]);\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ESP_OK;\r
+ if(xPortGetCoreID() == 0) {\r
+ GPIO.pin[gpio_num].int_ena = GPIO_PRO_CPU_INTR_ENA; //enable pro cpu intr\r
} else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
+ GPIO.pin[gpio_num].int_ena = GPIO_APP_CPU_INTR_ENA; //enable pro cpu intr\r
}\r
+ return ESP_OK;\r
}\r
\r
-static esp_err_t gpio_input_disable(gpio_num_t gpio_num)\r
+esp_err_t gpio_intr_disable(gpio_num_t gpio_num)\r
{\r
if(!is_valid_gpio(gpio_num))\r
return ESP_ERR_INVALID_ARG;\r
- if(gpio_mutex != NULL) {\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[gpio_num]);\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ESP_OK;\r
- } else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
- }\r
+ GPIO.pin[gpio_num].int_ena = 0; //disable GPIO intr\r
+ return ESP_OK;\r
}\r
\r
static esp_err_t gpio_output_disable(gpio_num_t gpio_num)\r
GPIO_ERROR("io_num=%d can only be input\n",gpio_num);\r
return ESP_ERR_INVALID_ARG;\r
}\r
- if(gpio_num >= GPIO_PIN_COUNT || GPIO_PIN_MUX_REG[gpio_num] == 0) {\r
- GPIO_ERROR("io_num=%d does not exist\n",gpio_num);\r
+ if(!is_valid_gpio(gpio_num))\r
return ESP_ERR_INVALID_ARG;\r
- }\r
if(gpio_num < 32) {\r
GPIO.enable_w1ts = (0x1 << gpio_num);\r
} else {\r
\r
esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level)\r
{\r
- if(!is_valid_gpio(gpio_num))\r
+ if(!IS_VALID_GPIO(gpio_num))\r
return ESP_ERR_INVALID_ARG;\r
if(level) {\r
if(gpio_num < 32)\r
\r
esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull)\r
{\r
- if(gpio_mutex != NULL) {\r
- if(!is_valid_gpio(gpio_num))\r
- return ESP_ERR_INVALID_ARG;\r
-\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- esp_err_t ret = ESP_OK;\r
- switch(pull) {\r
- case GPIO_PULLUP_ONLY:\r
- PIN_PULLUP_EN(GPIO_PIN_MUX_REG[gpio_num]);\r
- PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);\r
- break;\r
- case GPIO_PULLDOWN_ONLY:\r
- PIN_PULLUP_DIS(GPIO_PIN_MUX_REG[gpio_num]);\r
- PIN_PULLDWN_EN(GPIO_PIN_MUX_REG[gpio_num]);\r
- break;\r
- case GPIO_PULLUP_PULLDOWN:\r
- PIN_PULLUP_EN(GPIO_PIN_MUX_REG[gpio_num]);\r
- PIN_PULLDWN_EN(GPIO_PIN_MUX_REG[gpio_num]);\r
- break;\r
- case GPIO_FLOATING:\r
- PIN_PULLUP_DIS(GPIO_PIN_MUX_REG[gpio_num]);\r
- PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);\r
- break;\r
- default:\r
- GPIO_ERROR("Unknown pull up/down mode,gpio_num=%u,pull=%u\n",gpio_num,pull);\r
- ret = ESP_ERR_INVALID_ARG;\r
- break;\r
- }\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ret;\r
- } else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
+ if(!is_valid_gpio(gpio_num))\r
+ return ESP_ERR_INVALID_ARG;\r
+ esp_err_t ret = ESP_OK;\r
+ switch(pull) {\r
+ case GPIO_PULLUP_ONLY:\r
+ PIN_PULLUP_EN(GPIO_PIN_MUX_REG[gpio_num]);\r
+ PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);\r
+ break;\r
+ case GPIO_PULLDOWN_ONLY:\r
+ PIN_PULLUP_DIS(GPIO_PIN_MUX_REG[gpio_num]);\r
+ PIN_PULLDWN_EN(GPIO_PIN_MUX_REG[gpio_num]);\r
+ break;\r
+ case GPIO_PULLUP_PULLDOWN:\r
+ PIN_PULLUP_EN(GPIO_PIN_MUX_REG[gpio_num]);\r
+ PIN_PULLDWN_EN(GPIO_PIN_MUX_REG[gpio_num]);\r
+ break;\r
+ case GPIO_FLOATING:\r
+ PIN_PULLUP_DIS(GPIO_PIN_MUX_REG[gpio_num]);\r
+ PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);\r
+ break;\r
+ default:\r
+ GPIO_ERROR("Unknown pull up/down mode,gpio_num=%u,pull=%u\n",gpio_num,pull);\r
+ ret = ESP_ERR_INVALID_ARG;\r
+ break;\r
}\r
+ return ret;\r
}\r
\r
-esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_direction_t direction)\r
+esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode)\r
{\r
- if(gpio_mutex != NULL) {\r
- if(!is_valid_gpio(gpio_num))\r
- return ESP_ERR_INVALID_ARG;\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- esp_err_t ret = ESP_OK;\r
- switch(direction) {\r
- case GPIO_DIR_OUTPUT_ONLY:\r
- gpio_input_disable(gpio_num);\r
- gpio_output_enable(gpio_num);\r
- break;\r
- case GPIO_DIR_INPUT_ONLY:\r
- gpio_input_enable(gpio_num);\r
- gpio_output_disable(gpio_num);\r
- break;\r
- case GPIO_DIR_INPUT_AND_OUTPUT:\r
- gpio_input_enable(gpio_num);\r
- gpio_output_enable(gpio_num);\r
- break;\r
- case GPIO_DIR_DISABLE_IO:\r
- gpio_input_disable(gpio_num);\r
- gpio_output_disable(gpio_num);\r
- break;\r
- default:\r
- GPIO_ERROR("Unknown direction type,gpio_num=%u,direction=%u\n",gpio_num,direction);\r
- ret = ESP_ERR_INVALID_ARG;\r
- break;\r
+ if(!is_valid_gpio(gpio_num))\r
+ return ESP_ERR_INVALID_ARG;\r
+ if(gpio_num >= 34 && (mode & (GPIO_MODE_DEF_OUTPUT))) {\r
+ GPIO_ERROR("io_num=%d can only be input\n",gpio_num);\r
+ return ESP_ERR_INVALID_ARG;\r
+ }\r
+ esp_err_t ret = ESP_OK;\r
+ if(mode & GPIO_MODE_DEF_INPUT) {\r
+ PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[gpio_num]);\r
+ } else {\r
+ PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[gpio_num]);\r
+ }\r
+ if(mode & GPIO_MODE_DEF_OUTPUT) {\r
+ if(gpio_num < 32) {\r
+ GPIO.enable_w1ts = (0x1 << gpio_num);\r
+ } else {\r
+ GPIO.enable1_w1ts.data = (0x1 << (gpio_num - 32));\r
}\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ret;\r
} else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
+ if(gpio_num < 32) {\r
+ GPIO.enable_w1tc = (0x1 << gpio_num);\r
+ } else {\r
+ GPIO.enable1_w1tc.data = (0x1 << (gpio_num - 32));\r
+ }\r
+ }\r
+ if(mode & GPIO_MODE_DEF_OD) {\r
+ GPIO.pin[gpio_num].pad_driver = 1;\r
+ } else {\r
+ GPIO.pin[gpio_num].pad_driver = 0;\r
}\r
+ return ret;\r
}\r
\r
esp_err_t gpio_config(gpio_config_t *pGPIOConfig)\r
{\r
- if(gpio_mutex == NULL) {\r
- gpio_mutex = xSemaphoreCreateRecursiveMutex();\r
- if(gpio_mutex == NULL) {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
- }\r
- }\r
uint64_t gpio_pin_mask = (pGPIOConfig->pin_bit_mask);\r
uint32_t io_reg = 0;\r
- uint8_t io_num = 0;\r
+ uint32_t io_num = 0;\r
uint64_t bit_valid = 0;\r
- if(pGPIOConfig->pin_bit_mask == 0) {\r
- GPIO_ERROR("GPIO_PIN = 0 \n");\r
+ if(pGPIOConfig->pin_bit_mask == 0 || pGPIOConfig->pin_bit_mask >= (((uint64_t) 1) << GPIO_PIN_COUNT)) {\r
+ GPIO_ERROR("GPIO_PIN mask error \n");\r
return ESP_ERR_INVALID_ARG;\r
}\r
- if((pGPIOConfig->mode) & (BIT1)) {\r
+ if((pGPIOConfig->mode) & (GPIO_MODE_DEF_OUTPUT)) {\r
//GPIO 34/35/36/37/38/39 can only be used as input mode;\r
if((gpio_pin_mask & ( GPIO_SEL_34 | GPIO_SEL_35 | GPIO_SEL_36 | GPIO_SEL_37 | GPIO_SEL_38 | GPIO_SEL_39))) {\r
GPIO_ERROR("GPIO34-39 can only be used as input mode\n");\r
return ESP_ERR_INVALID_ARG;\r
}\r
}\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
do {\r
io_reg = GPIO_PIN_MUX_REG[io_num];\r
if(((gpio_pin_mask >> io_num) & BIT(0)) && io_reg) {\r
GPIO_INFO("Gpio%02d |Mode:",io_num);\r
- if((pGPIOConfig->mode) & GPIO_MODE_INPUT) {\r
+ if((pGPIOConfig->mode) & GPIO_MODE_DEF_INPUT) {\r
GPIO_INFO("INPUT ");\r
- gpio_input_enable(io_num);\r
+ PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[io_num]);\r
} else {\r
- gpio_input_disable(io_num);\r
+ PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[io_num]);\r
}\r
- if((pGPIOConfig->mode) & BIT2) {\r
+ if((pGPIOConfig->mode) & GPIO_MODE_DEF_OD) {\r
GPIO_INFO("OD ");\r
GPIO.pin[io_num].pad_driver = 1; /*0x01 Open-drain */\r
} else {\r
GPIO.pin[io_num].pad_driver = 0; /*0x00 Normal gpio output */\r
}\r
- if((pGPIOConfig->mode) & GPIO_MODE_OUTPUT) {\r
+ if((pGPIOConfig->mode) & GPIO_MODE_DEF_OUTPUT) {\r
GPIO_INFO("OUTPUT ");\r
gpio_output_enable(io_num);\r
} else {\r
gpio_output_disable(io_num);\r
- }\r
- GPIO_INFO("|");\r
+ }GPIO_INFO("|");\r
if(pGPIOConfig->pull_up_en) {\r
GPIO_INFO("PU ");\r
PIN_PULLUP_EN(io_reg);\r
}\r
io_num++;\r
} while(io_num < GPIO_PIN_COUNT);\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
return ESP_OK;\r
}\r
\r
-esp_err_t gpio_intr_handler_register(uint8_t gpio_intr_num, void (*fn)(void*), void * arg)\r
+esp_err_t gpio_intr_handler_register(uint32_t gpio_intr_num, void (*fn)(void*), void * arg)\r
{\r
- if(gpio_mutex != NULL) {\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- ESP_INTR_DISABLE(gpio_intr_num);\r
- intr_matrix_set(xPortGetCoreID(), ETS_GPIO_INTR_SOURCE, gpio_intr_num);\r
- xt_set_interrupt_handler(gpio_intr_num, fn, arg);\r
- ESP_INTR_ENABLE(gpio_intr_num);\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ESP_OK;\r
- } else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
- }\r
+ if(fn == NULL)\r
+ return ESP_ERR_INVALID_ARG;\r
+ ESP_INTR_DISABLE(gpio_intr_num);\r
+ intr_matrix_set(xPortGetCoreID(), ETS_GPIO_INTR_SOURCE, gpio_intr_num);\r
+ xt_set_interrupt_handler(gpio_intr_num, fn, arg);\r
+ ESP_INTR_ENABLE(gpio_intr_num);\r
+ return ESP_OK;\r
}\r
\r
/*only level interrupt can be used for wake-up function*/\r
esp_err_t gpio_pin_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type)\r
{\r
- if(gpio_mutex != NULL) {\r
- esp_err_t ret = ESP_OK;\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- if((intr_type == GPIO_PIN_INTR_LOW_LEVEL) || (intr_type == GPIO_PIN_INTR_HIGH_LEVEL)) {\r
- GPIO.pin[gpio_num].int_type = intr_type;\r
- GPIO.pin[gpio_num].wakeup_enable = 0x1;\r
- } else {\r
- GPIO_ERROR("GPIO wakeup only support Level mode,but edge mode set. gpio_num:%u\n",gpio_num);\r
- ret = ESP_ERR_INVALID_ARG;\r
- }\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ret;\r
+ if(!is_valid_gpio(gpio_num))\r
+ return ESP_ERR_INVALID_ARG;\r
+ esp_err_t ret = ESP_OK;\r
+ if((intr_type == GPIO_PIN_INTR_LOW_LEVEL) || (intr_type == GPIO_PIN_INTR_HIGH_LEVEL)) {\r
+ GPIO.pin[gpio_num].int_type = intr_type;\r
+ GPIO.pin[gpio_num].wakeup_enable = 0x1;\r
} else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
+ GPIO_ERROR("GPIO wakeup only support Level mode,but edge mode set. gpio_num:%u\n",gpio_num);\r
+ ret = ESP_ERR_INVALID_ARG;\r
}\r
+ return ret;\r
}\r
\r
esp_err_t gpio_pin_wakeup_disable(gpio_num_t gpio_num)\r
{\r
- if(gpio_mutex != NULL) {\r
- xSemaphoreTakeRecursive(gpio_mutex, portMAX_DELAY);\r
- GPIO.pin[gpio_num].wakeup_enable = 0;\r
- xSemaphoreGiveRecursive(gpio_mutex);\r
- return ESP_OK;\r
- } else {\r
- GPIO_ERROR("Mutex null\n");\r
- return ESP_FAIL;\r
- }\r
-\r
+ if(!is_valid_gpio(gpio_num))\r
+ return ESP_ERR_INVALID_ARG;\r
+ GPIO.pin[gpio_num].wakeup_enable = 0;\r
+ return ESP_OK;\r
}\r
extern "C" {
#endif
-extern const uint32_t GPIO_PIN_MUX_REG[40];
-
#define GPIO_SEL_0 (BIT(0)) /* Pin 0 selected */
#define GPIO_SEL_1 (BIT(1)) /* Pin 1 selected */
#define GPIO_SEL_2 (BIT(2)) /* Pin 2 selected */
#define GPIO_ID_PIN(n) (GPIO_ID_PIN0 + (n))
#define GPIO_PIN_ADDR(i) (GPIO_PIN0_REG + i * 4)
+#define GPIO_MODE_DEF_INPUT (BIT0)
+#define GPIO_MODE_DEF_OUTPUT (BIT1)
+#define GPIO_MODE_DEF_OD (BIT2)
+
+extern const uint32_t GPIO_PIN_MUX_REG[GPIO_PIN_COUNT];
+
typedef enum {
GPIO_NUM_0 = 0,
GPIO_NUM_1 = 1,
} gpio_int_type_t;
typedef enum {
- GPIO_MODE_INPUT = (BIT0), /* GPIO mode : input only */
- GPIO_MODE_OUTPUT = (BIT1), /* GPIO mode : output only mode */
- GPIO_MODE_OUTPUT_OD = ((BIT1)|(BIT2)), /* GPIO mode : output only with open-drain mode */
- GPIO_MODE_INPUT_OUTPUT_OD = ((BIT0)|(BIT1)|(BIT2)), /* GPIO mode : output and input with open-drain mode*/
- GPIO_MODE_INPUT_OUTPUT = ((BIT0)|(BIT1)), /* GPIO mode : output and input mode */
+ GPIO_MODE_INPUT = GPIO_MODE_DEF_INPUT, /* GPIO mode : input only */
+ GPIO_MODE_OUTPUT = GPIO_MODE_DEF_OUTPUT, /* GPIO mode : output only mode */
+ GPIO_MODE_OUTPUT_OD = ((GPIO_MODE_DEF_OUTPUT)|(GPIO_MODE_DEF_OD)), /* GPIO mode : output only with open-drain mode */
+ GPIO_MODE_INPUT_OUTPUT_OD = ((GPIO_MODE_DEF_INPUT)|(GPIO_MODE_DEF_OUTPUT)|(GPIO_MODE_DEF_OD)), /* GPIO mode : output and input with open-drain mode*/
+ GPIO_MODE_INPUT_OUTPUT = ((GPIO_MODE_DEF_INPUT)|(GPIO_MODE_DEF_OUTPUT)), /* GPIO mode : output and input mode */
} gpio_mode_t;
typedef enum {
gpio_int_type_t intr_type; /* GPIO interrupt type */
} gpio_config_t;
-typedef enum {
- GPIO_DIR_OUTPUT_ONLY, /* GPIO output */
- GPIO_DIR_INPUT_ONLY, /* GPIO input */
- GPIO_DIR_INPUT_AND_OUTPUT, /* GPIO input + output */
- GPIO_DIR_DISABLE_IO, /* GPIO disable */
-} gpio_direction_t;
-
typedef enum {
GPIO_LOW_LEVEL = 0,
GPIO_HIGH_LEVEL = 1,
* pGPIOConfig.pull_down_en : Enable or Disable pull-down
* pGPIOConfig.intr_type : Configure GPIO interrupt trigger type
* @return ESP_OK: success ;
- * ESP_ERR_INVALID_ARG: parameters error
- * ESP_FAIL : GPIO mutex error
+ * ESP_ERR_INVALID_ARG: parameter error
+ * ESP_FAIL : GPIO error
*
*/
esp_err_t gpio_config(gpio_config_t *pGPIOConfig);
+
+/**
+ * @brief GPIO set interrupt trigger type
+ *
+ * @parameter[in] gpio_num : GPIO number.
+ * If you want to set output level of GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ * @parameter[in] intr_type: interrupt type, select from gpio_int_type_t
+ *
+ * @return ESP_OK : success
+ * ESP_ERR_INVALID_ARG: parameter error
+ *
+ */
+esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type);
+
+/**
+ * @brief enable GPIO module interrupt signal
+ *
+ * @parameter[in] gpio_num : GPIO number.
+ * If you want to set output level of GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ *
+ * @return ESP_OK : success
+ * ESP_ERR_INVALID_ARG: parameter error
+ *
+ */
+esp_err_t gpio_intr_enable(gpio_num_t gpio_num);
+
+/**
+ * @brief disable GPIO module interrupt signal
+ *
+ * @parameter[in] gpio_num : GPIO number.
+ * If you want to set output level of GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ *
+ * @return ESP_OK : success
+ * ESP_ERR_INVALID_ARG: parameter error
+ *
+ */
+esp_err_t gpio_intr_disable(gpio_num_t gpio_num);
+
/**
* @brief GPIO set output level
*
* @parameter[in] gpio_num : GPIO number.
- * If you want to set output level of GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ * If you want to set output level of GPIO16, gpio_num should be GPIO_NUM_16 (16);
* @parameter[in] level : Output level. 0: low ; 1: high
*
* @return ESP_OK : success
- * ESP_FAIL : GPIO mutex error
+ * ESP_FAIL : GPIO error
*
*/
esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level);
* @brief GPIO get input level
*
* @parameter[in] gpio_num : GPIO number.
- * If you want to get level of pin GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ * If you want to get level of pin GPIO16, gpio_num should be GPIO_NUM_16 (16);
*
* @return 0 : the GPIO input level is 0
* 1 : the GPIO input level is 1
*
* Configure GPIO direction,such as output_only,input_only,output_and_input
*
- * @parameter[in] gpio_num : Configure GPIO pins number,it should GPIO number.
- * If you want to set direction of GPIO16, gpio_num should be GPIO_NUM_16 (16);
- * @parameter[in] direction: Configure GPIO direction,such as output_only,input_only,...
+ * @parameter[in] gpio_num : Configure GPIO pins number,it should be GPIO number.
+ * If you want to set direction of GPIO16, gpio_num should be GPIO_NUM_16 (16);
+ * @parameter[in] mode : Configure GPIO direction,such as output_only,input_only,...
*
* @return ESP_OK : success
* ESP_ERR_INVALID_ARG : fail
- * ESP_FAIL : GPIO mutex error
+ * ESP_FAIL : GPIO error
*
*/
-esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_direction_t direction);
+esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode);
/**
* @brief GPIO set pull
*
* User this Function,configure GPIO pull mode,such as pull-up,pull-down
*
- * @parameter[in] gpio_num : Configure GPIO pins number,it should GPIO number.
+ * @parameter[in] gpio_num : Configure GPIO pins number,it should be GPIO number.
* If you want to set pull up or down mode for GPIO16,gpio_num should be GPIO_NUM_16 (16);
* @parameter[in] pull : Configure GPIO pull up/down mode,such as pullup_only,pulldown_only,pullup_and_pulldown,...
*
* @return ESP_OK : success
* ESP_ERR_INVALID_ARG : fail
- * ESP_FAIL : GPIO mutex error
+ * ESP_FAIL : GPIO error
*
*/
esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull);
* Second , enable the GPIO input,if you use pin_func_as_gpio,you can use gpio_set_direction function
* Third , call gpio_matrix_in function
*
- * @parameter[in] GPIO : Configure GPIO pins number,it should GPIO number.
+ * @parameter[in] GPIO : Configure GPIO pins number,it should be GPIO number.
* If you want to configure GPIO16, gpio_num should be GPIO_NUM_16 (16);
* @parameter[in] signal_idx : the signal_idx,find the signal index from gpio_sig_map.h
*
* Users should know that which CPU is running and then pick a INUM that is not used by system.
* We can find the information of INUM and interrupt level in soc.h.
* TODO: to move INUM options to menu_config
- * @parameter uint8_t gpio_intr_num : GPIO interrupt number,check the info in soc.h, and please see the core-isa.h for more details
+ * @parameter uint32_t gpio_intr_num : GPIO interrupt number,check the info in soc.h, and please see the core-isa.h for more details
* @parameter void (* fn)(void* ) : interrupt handler function.
* Note that the handler function MUST be defined with attribution of "IRAM_ATTR".
* @parameter void * arg : parameter for handler function
*
* @return ESP_OK : success ;
- * ESP_FAIL: gpio_mutex error
+ * ESP_FAIL: gpio_ error
*/
-esp_err_t gpio_intr_handler_register(uint8_t gpio_intr_num, void (*fn)(void*), void * arg);
+esp_err_t gpio_intr_handler_register(uint32_t gpio_intr_num, void (*fn)(void*), void * arg);
+/**
+ * *************** ATTENTION ********************/
+/**
+ *
+ * Each GPIO have their separated registers, so we don't have to use
+ * lock for multi-task issues.
+ * Please make sure that there would be no such situation, in which,
+ * different tasks read-then-write the same GPIO register.
+ */
+
+
/*----------EXAMPLE TO CONIFGURE GPIO AS OUTPUT ------------ */
/* gpio_config_t io_conf;
* io_conf.intr_type = GPIO_PIN_INTR_DISABLE; //disable interrupt
*
*/
-
-
/**
* @}
*/
projects / esp-idf / commitdiff