espresso_frame/firmware/main/next_button.c

#include <stdint.h>

#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_sleep.h"
#include "soc/soc_caps.h"

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#include "wifi_provisioning.h"

#include "next_button.h"

static const char *TAG = "next_button";

#if CONFIG_FRAME_NEXT_BUTTON_GPIO >= 0

#define NEXT_BUTTON_GPIO ((gpio_num_t)CONFIG_FRAME_NEXT_BUTTON_GPIO)
#define NEXT_BUTTON_DEBOUNCE_MS 20
#define NEXT_BUTTON_DEBOUNCE_CHECKS 3
#define NEXT_BUTTON_POLL_MS 100

void next_button_init(void)
{
    /* Every deep sleep with this pin armed as a wakeup source leaves it
     * "held" (ESP-IDF locks the pin's pull/config across the sleep
     * transition -- see esp_sleep_gpio_wakeup_prepare_on_hp_periph_powerdown()
     * in sleep_modes.c) and, confirmed on hardware, never un-holds it on
     * wake -- the application has to. Must run before gpio_config() below. */
    gpio_hold_dis(NEXT_BUTTON_GPIO);

    gpio_config_t io_conf = {
        .pin_bit_mask = 1ULL << NEXT_BUTTON_GPIO,
        .mode = GPIO_MODE_INPUT,
        .pull_up_en = GPIO_PULLUP_ENABLE,
    };
    gpio_config(&io_conf);

#if SOC_GPIO_SUPPORT_HP_PERIPH_PD_SLEEP_WAKEUP
    /* Not esp_sleep_enable_ext1_wakeup_io() on its own: on a target
     * without RTC-independent digital pull registers, ext1's internal
     * pull resistors don't hold once the RTC_PERIPH domain powers down
     * for deep sleep, so the pin floats and reads spuriously low, waking
     * the device instantly on every sleep entry (confirmed on hardware,
     * ESP32-C6). This GPIO-wakeup variant manages the pull resistor
     * itself across the sleep transition, sidestepping the issue
     * entirely -- but it only exists on chips with this capability
     * (currently just ESP32-C6; see the #else below for other targets,
     * e.g. ESP32-S3). */
    esp_sleep_enable_gpio_wakeup_on_hp_periph_powerdown(1ULL << NEXT_BUTTON_GPIO, ESP_GPIO_WAKEUP_GPIO_LOW);
#else
    /* No HP-periph-powerdown wakeup API here (e.g. ESP32-S3) -- fall
     * back to ext1, but NOT naively: on every non-original-ESP32 target
     * (ESP32-S3 included), gpio_pullup_en() -- which the gpio_config()
     * call above invokes via pull_up_en -- delegates to
     * rtc_gpio_pullup_en() for RTC-capable pins (confirmed in
     * esp_driver_gpio's gpio.c: GPIO_RTCIO_ARE_INDEPENDENT is 1 for
     * every target except the original ESP32, meaning digital and RTC
     * pull registers are independent hardware and gpio_config() already
     * routes the pull-up through the RTC pad's own register for these
     * pins, not just the digital one). That's exactly what was missing
     * in the ext1 attempt that failed on hardware above -- so on this
     * target the pull-up already survives the RTC_PERIPH power-down
     * ext1 wakeup requires, without needing a separate rtc_gpio_*_en()
     * call here. _io() (not the bare esp_sleep_enable_ext1_wakeup(),
     * which resets any previously-configured mask) is additive across
     * this file's, back_button.c's, and combo_button.c's independent
     * init calls -- confirmed in esp_hw_support's sleep_modes.c -- so no
     * shared-mask coordination between the three button files is
     * needed. Still unconfirmed on real EE02 hardware: this avoids the
     * *documented* failure mode of the earlier ext1 attempt, but that
     * attempt was never root-caused beyond "confirmed spurious wakeup on
     * hardware" -- treat this as untested until it's actually run on an
     * EE02 board. */
    ESP_ERROR_CHECK(esp_sleep_enable_ext1_wakeup_io(1ULL << NEXT_BUTTON_GPIO, ESP_EXT1_WAKEUP_ANY_LOW));
#endif
}

next_button_result_t next_button_check(void)
{
    /* A quick tap can easily release before this runs (~0.4-0.5s into
     * boot, confirmed on hardware -- a live gpio_get_level() check here
     * missed real presses that had already woken the device). The wakeup
     * status register is latched at the moment of waking and isn't
     * cleared until the next sleep entry, so it reliably reflects a tap
     * regardless of how quickly it was released. */
#if SOC_GPIO_SUPPORT_HP_PERIPH_PD_SLEEP_WAKEUP
    bool caused_wake = esp_sleep_get_gpio_wakeup_status() & (1ULL << NEXT_BUTTON_GPIO);
#else
    bool caused_wake = esp_sleep_get_ext1_wakeup_status() & (1ULL << NEXT_BUTTON_GPIO);
#endif

    if (!caused_wake) {
        /* Not a GPIO-wakeup-from-this-pin boot (normal timer wake, or a
         * fresh power-on/reflash) -- fall back to a live, debounced level
         * check so holding the button down while powering on also
         * works. */
        if (gpio_get_level(NEXT_BUTTON_GPIO) != 0) {
            return NEXT_BUTTON_NOT_PRESSED;
        }
        for (int i = 0; i < NEXT_BUTTON_DEBOUNCE_CHECKS; i++) {
            vTaskDelay(pdMS_TO_TICKS(NEXT_BUTTON_DEBOUNCE_MS));
            if (gpio_get_level(NEXT_BUTTON_GPIO) != 0) {
                return NEXT_BUTTON_NOT_PRESSED; /* noise, not a real press */
            }
        }
    }

    /* Confirmed pressed (either the wake cause, or debounced during
     * power-on) -- measure how long, same polling pattern as
     * combo_button.c's own hold-tier detection. Reads the last hold
     * duration the server reported (persisted from a previous cycle,
     * see frame_config_get_hold_duration_ms's own doc comment), falling
     * back to the Kconfig default before the device has ever fetched
     * one. */
    uint32_t hold_threshold_ms;
    if (frame_config_get_hold_duration_ms(&hold_threshold_ms) != ESP_OK) {
        hold_threshold_ms = CONFIG_FRAME_HOLD_ACTION_MS;
    }

    uint32_t elapsed_ms = 0;
    while (gpio_get_level(NEXT_BUTTON_GPIO) == 0) {
        if (elapsed_ms >= hold_threshold_ms) {
            ESP_LOGI(TAG, "Next button held past %ums, triggering global hold action",
                     (unsigned)hold_threshold_ms);
            return NEXT_BUTTON_HOLD;
        }
        vTaskDelay(pdMS_TO_TICKS(NEXT_BUTTON_POLL_MS));
        elapsed_ms += NEXT_BUTTON_POLL_MS;
    }

    ESP_LOGI(TAG, "Next-photo button short press (%ums), forcing advance", (unsigned)elapsed_ms);
    return NEXT_BUTTON_SHORT_PRESS;
}

#else

void next_button_init(void) {}
next_button_result_t next_button_check(void) { return NEXT_BUTTON_NOT_PRESSED; }

#endif