mirror of
https://github.com/espressif/esp-idf.git
synced 2025-11-04 14:14:11 +00:00
535 lines
18 KiB
C
535 lines
18 KiB
C
// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#pragma once
|
|
#include "sdkconfig.h"
|
|
#include "esp_err.h"
|
|
#include <esp_types.h>
|
|
#include <esp_bit_defs.h>
|
|
#include "esp_attr.h"
|
|
#include "esp_intr_alloc.h"
|
|
#include "soc/soc_caps.h"
|
|
#include "soc/gpio_periph.h"
|
|
#include "hal/gpio_types.h"
|
|
|
|
// |================================= WARNING ====================================================== |
|
|
// | Including ROM header file in a PUBLIC API file will be REMOVED in the next major release (5.x). |
|
|
// | User should include "esp_rom_gpio.h" in their code if they have to use those ROM API. |
|
|
// |================================================================================================ |
|
|
#if CONFIG_IDF_TARGET_ESP32
|
|
#include "esp32/rom/gpio.h"
|
|
#elif CONFIG_IDF_TARGET_ESP32S2
|
|
#include "esp32s2/rom/gpio.h"
|
|
#elif CONFIG_IDF_TARGET_ESP32C3
|
|
#include "esp32c3/rom/gpio.h"
|
|
#endif
|
|
|
|
#ifdef CONFIG_LEGACY_INCLUDE_COMMON_HEADERS
|
|
#include "soc/rtc_io_reg.h"
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define GPIO_PIN_COUNT (SOC_GPIO_PIN_COUNT)
|
|
/// Check whether it is a valid GPIO number
|
|
#define GPIO_IS_VALID_GPIO(gpio_num) (((1ULL << (gpio_num)) & SOC_GPIO_VALID_GPIO_MASK) != 0)
|
|
/// Check whether it can be a valid GPIO number of output mode
|
|
#define GPIO_IS_VALID_OUTPUT_GPIO(gpio_num) (((1ULL << (gpio_num)) & SOC_GPIO_VALID_OUTPUT_GPIO_MASK) != 0)
|
|
/// Check whether it can be a valid digital I/O pad
|
|
#define GPIO_IS_VALID_DIGITAL_IO_PAD(gpio_num) ((gpio_num >= 0) && \
|
|
(((1ULL << (gpio_num)) & SOC_GPIO_VALID_DIGITAL_IO_PAD_MASK) != 0))
|
|
|
|
typedef intr_handle_t gpio_isr_handle_t;
|
|
|
|
/**
|
|
* @brief GPIO common configuration
|
|
*
|
|
* Configure GPIO's Mode,pull-up,PullDown,IntrType
|
|
*
|
|
* @param pGPIOConfig Pointer to GPIO configure struct
|
|
*
|
|
* @return
|
|
* - ESP_OK success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*
|
|
*/
|
|
esp_err_t gpio_config(const gpio_config_t *pGPIOConfig);
|
|
|
|
/**
|
|
* @brief Reset an gpio to default state (select gpio function, enable pullup and disable input and output).
|
|
*
|
|
* @param gpio_num GPIO number.
|
|
*
|
|
* @note This function also configures the IOMUX for this pin to the GPIO
|
|
* function, and disconnects any other peripheral output configured via GPIO
|
|
* Matrix.
|
|
*
|
|
* @return Always return ESP_OK.
|
|
*/
|
|
esp_err_t gpio_reset_pin(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief GPIO set interrupt trigger type
|
|
*
|
|
* @param gpio_num GPIO number. If you want to set the trigger type of e.g. of GPIO16, gpio_num should be GPIO_NUM_16 (16);
|
|
* @param 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
|
|
*
|
|
* @note Please do not use the interrupt of GPIO36 and GPIO39 when using ADC or Wi-Fi and Bluetooth with sleep mode enabled.
|
|
* Please refer to the comments of `adc1_get_raw`.
|
|
* Please refer to section 3.11 of 'ECO_and_Workarounds_for_Bugs_in_ESP32' for the description of this issue.
|
|
* As a workaround, call adc_power_acquire() in the app. This will result in higher power consumption (by ~1mA),
|
|
* but will remove the glitches on GPIO36 and GPIO39.
|
|
*
|
|
* @param gpio_num GPIO number. If you want to enable an interrupt on e.g. 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
|
|
*
|
|
* @param gpio_num GPIO number. If you want to disable the interrupt of e.g. 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
|
|
*
|
|
* @param gpio_num GPIO number. If you want to set the output level of e.g. GPIO16, gpio_num should be GPIO_NUM_16 (16);
|
|
* @param level Output level. 0: low ; 1: high
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG GPIO number error
|
|
*
|
|
*/
|
|
esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level);
|
|
|
|
/**
|
|
* @brief GPIO get input level
|
|
*
|
|
* @warning If the pad is not configured for input (or input and output) the returned value is always 0.
|
|
*
|
|
* @param gpio_num GPIO number. If you want to get the logic level of e.g. 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
|
|
*
|
|
*/
|
|
int gpio_get_level(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief GPIO set direction
|
|
*
|
|
* Configure GPIO direction,such as output_only,input_only,output_and_input
|
|
*
|
|
* @param gpio_num Configure GPIO pins number, it should be GPIO number. If you want to set direction of e.g. GPIO16, gpio_num should be GPIO_NUM_16 (16);
|
|
* @param mode GPIO direction
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG GPIO error
|
|
*
|
|
*/
|
|
esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode);
|
|
|
|
/**
|
|
* @brief Configure GPIO pull-up/pull-down resistors
|
|
*
|
|
* Only pins that support both input & output have integrated pull-up and pull-down resistors. Input-only GPIOs 34-39 do not.
|
|
*
|
|
* @param gpio_num GPIO number. If you want to set pull up or down mode for e.g. GPIO16, gpio_num should be GPIO_NUM_16 (16);
|
|
* @param pull GPIO pull up/down mode.
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG : Parameter error
|
|
*
|
|
*/
|
|
esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull);
|
|
|
|
/**
|
|
* @brief Enable GPIO wake-up function.
|
|
*
|
|
* @param gpio_num GPIO number.
|
|
*
|
|
* @param intr_type GPIO wake-up type. Only GPIO_INTR_LOW_LEVEL or GPIO_INTR_HIGH_LEVEL can be used.
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type);
|
|
|
|
/**
|
|
* @brief Disable GPIO wake-up function.
|
|
*
|
|
* @param gpio_num GPIO number
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_wakeup_disable(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief Register GPIO interrupt handler, the handler is an ISR.
|
|
* The handler will be attached to the same CPU core that this function is running on.
|
|
*
|
|
* This ISR function is called whenever any GPIO interrupt occurs. See
|
|
* the alternative gpio_install_isr_service() and
|
|
* gpio_isr_handler_add() API in order to have the driver support
|
|
* per-GPIO ISRs.
|
|
*
|
|
* @param fn Interrupt handler function.
|
|
* @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.
|
|
* @param arg Parameter for handler function
|
|
* @param handle Pointer to return handle. If non-NULL, a handle for the interrupt will be returned here.
|
|
*
|
|
* \verbatim embed:rst:leading-asterisk
|
|
* To disable or remove the ISR, pass the returned handle to the :doc:`interrupt allocation functions </api-reference/system/intr_alloc>`.
|
|
* \endverbatim
|
|
*
|
|
* @return
|
|
* - ESP_OK Success ;
|
|
* - ESP_ERR_INVALID_ARG GPIO error
|
|
* - ESP_ERR_NOT_FOUND No free interrupt found with the specified flags
|
|
*/
|
|
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.
|
|
*
|
|
* @param gpio_num GPIO number
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_pullup_en(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief Disable pull-up on GPIO.
|
|
*
|
|
* @param gpio_num GPIO number
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_pullup_dis(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief Enable pull-down on GPIO.
|
|
*
|
|
* @param gpio_num GPIO number
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_pulldown_en(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief Disable pull-down on GPIO.
|
|
*
|
|
* @param gpio_num GPIO number
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_pulldown_dis(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief Install the driver's GPIO ISR handler service, which allows per-pin GPIO interrupt handlers.
|
|
*
|
|
* This function is incompatible with gpio_isr_register() - if that function is used, a single global ISR is registered for all GPIO interrupts. If this function is used, the ISR service provides a global GPIO ISR and individual pin handlers are registered via the gpio_isr_handler_add() function.
|
|
*
|
|
* @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_ERR_NO_MEM No memory to install this service
|
|
* - ESP_ERR_INVALID_STATE ISR service already installed.
|
|
* - ESP_ERR_NOT_FOUND No free interrupt found with the specified flags
|
|
* - ESP_ERR_INVALID_ARG GPIO error
|
|
*/
|
|
esp_err_t gpio_install_isr_service(int intr_alloc_flags);
|
|
|
|
/**
|
|
* @brief Uninstall the driver's GPIO ISR service, freeing related resources.
|
|
*/
|
|
void gpio_uninstall_isr_service(void);
|
|
|
|
/**
|
|
* @brief Add ISR handler for the corresponding GPIO pin.
|
|
*
|
|
* Call this function after using gpio_install_isr_service() to
|
|
* install the driver's GPIO ISR handler service.
|
|
*
|
|
* The pin ISR 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 is a stack
|
|
* size limit (configurable as "ISR stack size" in menuconfig). This
|
|
* limit is smaller compared to a global GPIO interrupt handler due
|
|
* to the additional 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);
|
|
|
|
/**
|
|
* @brief Remove ISR handler for the corresponding GPIO pin.
|
|
*
|
|
* @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);
|
|
|
|
/**
|
|
* @brief Set GPIO pad drive capability
|
|
*
|
|
* @param gpio_num GPIO number, only support output GPIOs
|
|
* @param strength Drive capability of the pad
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_set_drive_capability(gpio_num_t gpio_num, gpio_drive_cap_t strength);
|
|
|
|
/**
|
|
* @brief Get GPIO pad drive capability
|
|
*
|
|
* @param gpio_num GPIO number, only support output GPIOs
|
|
* @param strength Pointer to accept drive capability of the pad
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_get_drive_capability(gpio_num_t gpio_num, gpio_drive_cap_t *strength);
|
|
|
|
/**
|
|
* @brief Enable gpio pad hold function.
|
|
*
|
|
* The gpio pad hold function works in both input and output modes, but must be output-capable gpios.
|
|
* If pad hold enabled:
|
|
* in output mode: the output level of the pad will be force locked and can not be changed.
|
|
* in input mode: the input value read will not change, regardless the changes of input signal.
|
|
*
|
|
* The state of digital gpio cannot be held during Deep-sleep, and it will resume the hold function
|
|
* when the chip wakes up from Deep-sleep. If the digital gpio also needs to be held during Deep-sleep,
|
|
* `gpio_deep_sleep_hold_en` should also be called.
|
|
*
|
|
* Power down or call gpio_hold_dis will disable this function.
|
|
*
|
|
* @param gpio_num GPIO number, only support output-capable GPIOs
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_NOT_SUPPORTED Not support pad hold function
|
|
*/
|
|
esp_err_t gpio_hold_en(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief Disable gpio pad hold function.
|
|
*
|
|
* When the chip is woken up from Deep-sleep, the gpio will be set to the default mode, so, the gpio will output
|
|
* the default level if this function is called. If you don't want the level changes, the gpio should be configured to
|
|
* a known state before this function is called.
|
|
* e.g.
|
|
* If you hold gpio18 high during Deep-sleep, after the chip is woken up and `gpio_hold_dis` is called,
|
|
* gpio18 will output low level(because gpio18 is input mode by default). If you don't want this behavior,
|
|
* you should configure gpio18 as output mode and set it to hight level before calling `gpio_hold_dis`.
|
|
*
|
|
* @param gpio_num GPIO number, only support output-capable GPIOs
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_NOT_SUPPORTED Not support pad hold function
|
|
*/
|
|
esp_err_t gpio_hold_dis(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief Enable all digital gpio pad hold function during Deep-sleep.
|
|
*
|
|
* When the chip is in Deep-sleep mode, all digital gpio will hold the state before sleep, and when the chip is woken up,
|
|
* the status of digital gpio will not be held. Note that the pad hold feature only works when the chip is in Deep-sleep mode,
|
|
* when not in sleep mode, the digital gpio state can be changed even you have called this function.
|
|
*
|
|
* Power down or call gpio_hold_dis will disable this function, otherwise, the digital gpio hold feature works as long as the chip enter Deep-sleep.
|
|
*/
|
|
void gpio_deep_sleep_hold_en(void);
|
|
|
|
/**
|
|
* @brief Disable all digital gpio pad hold function during Deep-sleep.
|
|
*
|
|
*/
|
|
void gpio_deep_sleep_hold_dis(void);
|
|
|
|
/**
|
|
* @brief Set pad input to a peripheral signal through the IOMUX.
|
|
* @param gpio_num GPIO number of the pad.
|
|
* @param signal_idx Peripheral signal id to input. One of the ``*_IN_IDX`` signals in ``soc/gpio_sig_map.h``.
|
|
*/
|
|
void gpio_iomux_in(uint32_t gpio_num, uint32_t signal_idx);
|
|
|
|
/**
|
|
* @brief Set peripheral output to an GPIO pad through the IOMUX.
|
|
* @param gpio_num gpio_num GPIO number of the pad.
|
|
* @param func The function number of the peripheral pin to output pin.
|
|
* One of the ``FUNC_X_*`` of specified pin (X) in ``soc/io_mux_reg.h``.
|
|
* @param oen_inv True if the output enable needs to be inverted, otherwise False.
|
|
*/
|
|
void gpio_iomux_out(uint8_t gpio_num, int func, bool oen_inv);
|
|
|
|
#if SOC_GPIO_SUPPORT_FORCE_HOLD
|
|
/**
|
|
* @brief Force hold digital and rtc gpio pad.
|
|
* @note GPIO force hold, whether the chip in sleep mode or wakeup mode.
|
|
* */
|
|
esp_err_t gpio_force_hold_all(void);
|
|
|
|
/**
|
|
* @brief Force unhold digital and rtc gpio pad.
|
|
* @note GPIO force unhold, whether the chip in sleep mode or wakeup mode.
|
|
* */
|
|
esp_err_t gpio_force_unhold_all(void);
|
|
#endif
|
|
|
|
#if SOC_GPIO_SUPPORT_SLP_SWITCH
|
|
/**
|
|
* @brief Enable SLP_SEL to change GPIO status automantically in lightsleep.
|
|
* @param gpio_num GPIO number of the pad.
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
*
|
|
*/
|
|
esp_err_t gpio_sleep_sel_en(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief Disable SLP_SEL to change GPIO status automantically in lightsleep.
|
|
* @param gpio_num GPIO number of the pad.
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
*/
|
|
esp_err_t gpio_sleep_sel_dis(gpio_num_t gpio_num);
|
|
|
|
/**
|
|
* @brief GPIO set direction at sleep
|
|
*
|
|
* Configure GPIO direction,such as output_only,input_only,output_and_input
|
|
*
|
|
* @param gpio_num Configure GPIO pins number, it should be GPIO number. If you want to set direction of e.g. GPIO16, gpio_num should be GPIO_NUM_16 (16);
|
|
* @param mode GPIO direction
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG GPIO error
|
|
*/
|
|
esp_err_t gpio_sleep_set_direction(gpio_num_t gpio_num, gpio_mode_t mode);
|
|
|
|
/**
|
|
* @brief Configure GPIO pull-up/pull-down resistors at sleep
|
|
*
|
|
* Only pins that support both input & output have integrated pull-up and pull-down resistors. Input-only GPIOs 34-39 do not.
|
|
*
|
|
* @param gpio_num GPIO number. If you want to set pull up or down mode for e.g. GPIO16, gpio_num should be GPIO_NUM_16 (16);
|
|
* @param pull GPIO pull up/down mode.
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG : Parameter error
|
|
*/
|
|
esp_err_t gpio_sleep_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull);
|
|
#endif
|
|
|
|
#if SOC_GPIO_SUPPORT_DEEPSLEEP_WAKEUP
|
|
|
|
#define GPIO_IS_DEEP_SLEEP_WAKEUP_VALID_GPIO(gpio_num) ((gpio_num >= 0) && \
|
|
(((1ULL << (gpio_num)) & SOC_GPIO_DEEP_SLEEP_WAKEUP_VALID_GPIO_MASK) != 0))
|
|
|
|
/**
|
|
* @brief Enable GPIO deep-sleep wake-up function.
|
|
*
|
|
* @param gpio_num GPIO number.
|
|
*
|
|
* @param intr_type GPIO wake-up type. Only GPIO_INTR_LOW_LEVEL or GPIO_INTR_HIGH_LEVEL can be used.
|
|
*
|
|
* @note Called by the SDK. User shouldn't call this directly in the APP.
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_deep_sleep_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type);
|
|
|
|
/**
|
|
* @brief Disable GPIO deep-sleep wake-up function.
|
|
*
|
|
* @param gpio_num GPIO number
|
|
*
|
|
* @return
|
|
* - ESP_OK Success
|
|
* - ESP_ERR_INVALID_ARG Parameter error
|
|
*/
|
|
esp_err_t gpio_deep_sleep_wakeup_disable(gpio_num_t gpio_num);
|
|
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|