ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
gpio.cpp
Go to the documentation of this file.
2// Always built: InternalGPIOPin is this class, so components that merely hold a
3// pointer to it reference these methods even in configs without a pin.
4#ifdef USE_ESP32
5
6#include "gpio.h"
7#include "esphome/core/hal.h"
8#include "esphome/core/log.h"
9#include "driver/gpio.h"
10#include "driver/rtc_io.h"
11#include "hal/gpio_hal.h"
12#include "soc/soc_caps.h"
13#include "soc/gpio_periph.h"
14#include <cinttypes>
15
16#if (SOC_RTCIO_PIN_COUNT > 0)
17#include "hal/rtc_io_hal.h"
18#endif
19
20// some variants don't map rtcio to gpio 1:1
21#if defined(USE_ESP32_VARIANT_ESP32) || defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32H21)
22#define RTCIO_NEED_MAPPING 1 // NOLINT
23#endif
24
25#if defined(USE_ESP32_VARIANT_ESP32) || (SOC_RTCIO_PIN_COUNT > 0 && defined(USE_GPIO_HOLD))
26#define ISR_PIN_USE_RTC 1 // NOLINT
27#endif
28
29namespace esphome {
30namespace esp32 {
31
32ESPHOME_LOG_TAG(TAG, "esp32");
33
34static const gpio_hal_context_t GPIO_HAL = {.dev = GPIO_HAL_GET_HW(GPIO_PORT_0)};
35
36bool ESP32InternalGPIOPin::isr_service_installed = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
37
38static gpio_mode_t flags_to_mode(gpio::Flags flags) {
41 return GPIO_MODE_INPUT;
43 return GPIO_MODE_OUTPUT;
45 return GPIO_MODE_OUTPUT_OD;
47 return GPIO_MODE_INPUT_OUTPUT_OD;
49 return GPIO_MODE_INPUT_OUTPUT;
50 // unsupported or gpio::FLAG_NONE
51 return GPIO_MODE_DISABLE;
52}
53
54struct ISRPinArg {
55 gpio_num_t pin;
57 bool inverted;
58#ifdef USE_GPIO_HOLD
59 bool hold;
60#endif
61#ifdef ISR_PIN_USE_RTC
62 bool use_rtc;
63#ifdef RTCIO_NEED_MAPPING
64 int rtc_pin;
65#endif
66#endif
67};
68
69#ifdef USE_GPIO_HOLD
70// Re-latch a held pad onto the values just written to its registers.
71static inline void refresh_hold(const ESP32InternalGPIOPin &pin) {
72 pin.set_hold(false);
73 pin.set_hold(true);
74}
75
76static inline void IRAM_ATTR isr_refresh_hold(const ISRPinArg *arg) {
77 if (!arg->hold)
78 return;
79#if defined(ISR_PIN_USE_RTC) && defined(SOC_RTCIO_HOLD_SUPPORTED)
80 if (arg->use_rtc) {
81#ifdef RTCIO_NEED_MAPPING
82 rtcio_hal_hold_disable(arg->rtc_pin);
83 rtcio_hal_hold_enable(arg->rtc_pin);
84#else
85 rtcio_hal_hold_disable(arg->pin);
86 rtcio_hal_hold_enable(arg->pin);
87#endif
88 return;
89 }
90#endif
91 gpio_hal_hold_dis(&GPIO_HAL, arg->pin);
92 gpio_hal_hold_en(&GPIO_HAL, arg->pin);
93}
94#endif
95
97 auto *arg = new ISRPinArg{}; // NOLINT(cppcoreguidelines-owning-memory)
98 arg->pin = this->get_pin_num();
99 arg->flags = gpio::FLAG_NONE;
100 arg->inverted = this->pin_flags_.inverted;
101#ifdef USE_GPIO_HOLD
102 arg->hold = this->get_hold();
103#endif
104#ifdef ISR_PIN_USE_RTC
105 arg->use_rtc = rtc_gpio_is_valid_gpio(this->get_pin_num());
106#ifdef RTCIO_NEED_MAPPING
107 if (arg->use_rtc)
108 arg->rtc_pin = rtc_io_number_get(this->get_pin_num());
109#endif
110#endif
111 return ISRInternalGPIOPin((void *) arg);
112}
113
114void ESP32InternalGPIOPin::attach_interrupt_(void (*func)(void *), void *arg, gpio::InterruptType type) const {
115 gpio_int_type_t idf_type = GPIO_INTR_ANYEDGE;
116 switch (type) {
118 idf_type = this->pin_flags_.inverted ? GPIO_INTR_NEGEDGE : GPIO_INTR_POSEDGE;
119 break;
121 idf_type = this->pin_flags_.inverted ? GPIO_INTR_POSEDGE : GPIO_INTR_NEGEDGE;
122 break;
124 idf_type = GPIO_INTR_ANYEDGE;
125 break;
127 idf_type = this->pin_flags_.inverted ? GPIO_INTR_HIGH_LEVEL : GPIO_INTR_LOW_LEVEL;
128 break;
130 idf_type = this->pin_flags_.inverted ? GPIO_INTR_LOW_LEVEL : GPIO_INTR_HIGH_LEVEL;
131 break;
132 }
133 gpio_set_intr_type(this->get_pin_num(), idf_type);
134 gpio_intr_enable(this->get_pin_num());
136 auto res = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL3);
137 if (res != ESP_OK) {
138 ESP_LOGE(TAG, "attach_interrupt(): call to gpio_install_isr_service() failed, error code: %d", res);
139 return;
140 }
142 }
143 gpio_isr_handler_add(this->get_pin_num(), func, arg);
144}
145
146size_t ESP32InternalGPIOPin::dump_summary(char *buffer, size_t len) const {
147 return snprintf(buffer, len, "GPIO%" PRIu32, static_cast<uint32_t>(this->pin_));
148}
149
150#ifdef USE_GPIO_HOLD
151void ESP32InternalGPIOPin::set_hold(bool hold) const {
152 if (!this->get_hold())
153 return;
154 if (hold) {
155 gpio_hold_en(this->get_pin_num());
156 } else {
157 gpio_hold_dis(this->get_pin_num());
158 }
159}
160#endif
161
163#ifdef USE_GPIO_HOLD
164 // Hold before gpio_config so the pad keeps its state while the registers change
165 this->set_hold(true);
166#endif
167 gpio_config_t conf{};
168 conf.pin_bit_mask = 1ULL << static_cast<uint32_t>(this->pin_);
169 conf.mode = flags_to_mode(this->flags_);
170 conf.pull_up_en = this->flags_ & gpio::FLAG_PULLUP ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
171 conf.pull_down_en = this->flags_ & gpio::FLAG_PULLDOWN ? GPIO_PULLDOWN_ENABLE : GPIO_PULLDOWN_DISABLE;
172 conf.intr_type = GPIO_INTR_DISABLE;
173 gpio_config(&conf);
174#ifdef CONFIG_FREERTOS_USE_TICKLESS_IDLE
175 // If auto light sleep is used gpio sleep mode needs to be disabled for the pin
176 gpio_sleep_sel_dis(this->get_pin_num());
177#endif
178 if (this->flags_ & gpio::FLAG_OUTPUT) {
179 gpio_set_drive_capability(this->get_pin_num(), this->get_drive_strength());
180 }
181#ifdef USE_GPIO_HOLD
182 // gpio_hold_dis logs an error on input-only pads
183 if (GPIO_IS_VALID_OUTPUT_GPIO(this->get_pin_num())) {
184 if (!this->get_hold()) {
185 // Release a hold left behind by an earlier boot
186 gpio_hold_dis(this->get_pin_num());
187 } else if (this->flags_ & gpio::FLAG_INPUT) {
188 // Inputs apply the config now so reads work; outputs wait for the first write
189 refresh_hold(*this);
190 }
191 }
192#endif
193}
194
196 // can't call gpio_config here because that logs in esp-idf which may cause issues
197 gpio_set_direction(this->get_pin_num(), flags_to_mode(flags));
198 gpio_pull_mode_t pull_mode = GPIO_FLOATING;
200 pull_mode = GPIO_PULLUP_PULLDOWN;
201 } else if (flags & gpio::FLAG_PULLUP) {
202 pull_mode = GPIO_PULLUP_ONLY;
203 } else if (flags & gpio::FLAG_PULLDOWN) {
204 pull_mode = GPIO_PULLDOWN_ONLY;
205 }
206 gpio_set_pull_mode(this->get_pin_num(), pull_mode);
207#ifdef USE_GPIO_HOLD
208 refresh_hold(*this);
209#endif
210}
211
213 return bool(gpio_get_level(this->get_pin_num())) != this->pin_flags_.inverted;
214}
216 gpio_set_level(this->get_pin_num(), value != this->pin_flags_.inverted ? 1 : 0);
217#ifdef USE_GPIO_HOLD
218 refresh_hold(*this);
219#endif
220}
221void ESP32InternalGPIOPin::detach_interrupt() const { gpio_intr_disable(this->get_pin_num()); }
222
223} // namespace esp32
224
225using namespace esp32;
226
227// NOLINTBEGIN(clang-analyzer-core.FixedAddressDereference) -- some gpio_hal functions use MMIO at fixed addresses
228// internally
230 auto *arg = reinterpret_cast<ISRPinArg *>(this->arg_);
231 return bool(gpio_hal_get_level(&GPIO_HAL, arg->pin)) != arg->inverted;
232}
233
235 auto *arg = reinterpret_cast<ISRPinArg *>(this->arg_);
236 gpio_hal_set_level(&GPIO_HAL, arg->pin, value != arg->inverted);
237#ifdef USE_GPIO_HOLD
238 isr_refresh_hold(arg);
239#endif
240}
241
243 // not supported
244}
245
247 auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
248 gpio::Flags diff = (gpio::Flags) (flags ^ arg->flags);
249 if (diff & gpio::FLAG_OUTPUT) {
250 if (flags & gpio::FLAG_OUTPUT) {
251 gpio_hal_output_enable(&GPIO_HAL, arg->pin);
253 gpio_hal_od_enable(&GPIO_HAL, arg->pin);
254 } else {
255 gpio_hal_output_disable(&GPIO_HAL, arg->pin);
256 }
257 }
258 if (diff & gpio::FLAG_INPUT) {
259 if (flags & gpio::FLAG_INPUT) {
260 gpio_hal_input_enable(&GPIO_HAL, arg->pin);
261#ifdef USE_ESP32_VARIANT_ESP32
262 // Only ESP32 uses the RTC registers for pullup/pulldown
263 if (arg->use_rtc) {
264 if (flags & gpio::FLAG_PULLUP) {
265 rtcio_hal_pullup_enable(arg->rtc_pin);
266 } else {
267 rtcio_hal_pullup_disable(arg->rtc_pin);
268 }
270 rtcio_hal_pulldown_enable(arg->rtc_pin);
271 } else {
272 rtcio_hal_pulldown_disable(arg->rtc_pin);
273 }
274 } else
275#endif
276 {
277 if (flags & gpio::FLAG_PULLUP) {
278 gpio_hal_pullup_en(&GPIO_HAL, arg->pin);
279 } else {
280 gpio_hal_pullup_dis(&GPIO_HAL, arg->pin);
281 }
283 gpio_hal_pulldown_en(&GPIO_HAL, arg->pin);
284 } else {
285 gpio_hal_pulldown_dis(&GPIO_HAL, arg->pin);
286 }
287 }
288 } else {
289 gpio_hal_input_disable(&GPIO_HAL, arg->pin);
290 }
291 }
292#ifdef USE_GPIO_HOLD
293 isr_refresh_hold(arg);
294#endif
295 arg->flags = flags;
296}
297// NOLINTEND(clang-analyzer-core.FixedAddressDereference)
298
299} // namespace esphome
300
301#endif // USE_ESP32
bool get_hold() const
Definition gpio_pin.h:89
Copy of GPIOPin that is safe to use from ISRs (with no virtual functions)
Definition gpio_pin.h:98
void digital_write(bool value)
Definition gpio.cpp:234
void pin_mode(gpio::Flags flags)
Definition gpio.cpp:246
gpio_num_t get_pin_num() const
Definition gpio.h:37
struct esphome::esp32::ESP32InternalGPIOPin::PinFlags pin_flags_
gpio_drive_cap_t get_drive_strength() const
Definition gpio.h:38
void set_hold(bool hold) const
Apply or release the pad hold. Does nothing unless the pin is configured with hold_state.
Definition gpio.cpp:151
void pin_mode(gpio::Flags flags) override
Definition gpio.cpp:195
void attach_interrupt_(void(*func)(void *), void *arg, gpio::InterruptType type) const
Definition gpio.cpp:114
void digital_write(bool value) override
Definition gpio.cpp:215
ISRInternalGPIOPin to_isr() const
Definition gpio.cpp:96
size_t dump_summary(char *buffer, size_t len) const override
Definition gpio.cpp:146
uint16_t flags
uint8_t type
uint32_t buffer
Definition gif.cpp:50
ESPHOME_LOG_TAG(TAG, CRASH_LOG_TAG)
@ INTERRUPT_FALLING_EDGE
Definition gpio_pin.h:53
@ INTERRUPT_RISING_EDGE
Definition gpio_pin.h:52
@ INTERRUPT_HIGH_LEVEL
Definition gpio_pin.h:56
@ INTERRUPT_LOW_LEVEL
Definition gpio_pin.h:55
@ INTERRUPT_ANY_EDGE
Definition gpio_pin.h:54
uint32_t value
Definition hal.cpp:41
const void size_t len
Definition hal.h:68
static void uint32_t