ESP32-C6 Matter over Thread 按钮：补齐 Border Router 和控制器链路

export LAB_DEPS="/absolute/path/matter-1.5-tools"
python tools/prepare_dependencies.py --prefix "$LAB_DEPS" --verify
export ESP_MATTER_PATH="$LAB_DEPS/esp-matter"
export MATTER_SDK_PATH="$ESP_MATTER_PATH/connectedhomeip/connectedhomeip"
export PATH="$LAB_DEPS/tools/gn:$PATH"
export PYTHONPATH="$LAB_DEPS/python-overlay:$MATTER_SDK_PATH/scripts/py_matter_idl:${PYTHONPATH:-}"

export LAB_PROJECT="/absolute/path/esp32-matter-thread-button"
export LAB_BUILD="/absolute/path/r10-enabled"
idf.py -C "$LAB_PROJECT" -B "$LAB_BUILD" -D IDF_TARGET=esp32c6 \
  -D SDKCONFIG="$LAB_BUILD/sdkconfig" \
  -D "SDKCONFIG_DEFAULTS=$LAB_PROJECT/sdkconfig.defaults;$LAB_PROJECT/sdkconfig.lab" build

// ---- main/main.cpp ----
// SPDX-License-Identifier: MIT
#include <inttypes.h>
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_matter.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "nvs_flash.h"
#include <platform/PlatformManager.h>
#include <setup_payload/OnboardingCodesUtil.h>
#include <platform/ESP32/OpenthreadLauncher.h>
#include "input_policy.h"

extern "C" bool lab_enabled(void);
using namespace esp_matter;
using namespace chip::app::Clusters;
static constexpr gpio_num_t EVENT_BUTTON = GPIO_NUM_10;
static constexpr gpio_num_t RESET_BUTTON = GPIO_NUM_11;
static const char *TAG = "r10";
static uint16_t switch_id;

static esp_err_t update_cb(attribute::callback_type_t, uint16_t, uint32_t, uint32_t,
                           esp_matter_attr_val_t *, void *) { return ESP_OK; }
static esp_err_t identify_cb(identification::callback_type_t, uint16_t, uint8_t, uint8_t, void *)
{
    ESP_LOGI(TAG, "Identify requested (no output indicator fitted)");
    return ESP_OK;
}
static void event_cb(const chip::DeviceLayer::ChipDeviceEvent *event, intptr_t)
{
    ESP_LOGI(TAG, "Matter event=%u", static_cast<unsigned>(event->Type));
}

static esp_err_t set_position(bool down)
{
    esp_matter_attr_val_t value = esp_matter_uint8(down ? 1 : 0);
    return attribute::update(switch_id, Switch::Id, Switch::Attributes::CurrentPosition::Id, &value);
}

static void input_task(void *)
{
    lab::Button event_button, reset_button;
    lab::Edges edges;
    lab::Dispatch dispatch;
    bool initialized_position = false, reset_pending = false;
    unsigned observed_overflows = 0;
    bool codes_printed = false;
    for (;;) {
        const uint64_t now = static_cast<uint64_t>(esp_timer_get_time() / 1000);
        const auto event_edge = event_button.sample(gpio_get_level(EVENT_BUTTON) == 0, now);
        if (event_edge != lab::Edge::None) edges.push(event_edge == lab::Edge::Press);
        if (reset_button.sample(gpio_get_level(RESET_BUTTON) == 0, now) == lab::Edge::Release &&
            reset_button.last_hold_ms >= 8000) reset_pending = true;
        if (edges.overflows != observed_overflows) {
            observed_overflows = edges.overflows;
            ESP_LOGW(TAG, "Four-edge backlog overflow=%u: discard backlog, resync position without event replay", observed_overflows);
        }
        auto &manager = chip::DeviceLayer::PlatformMgr();
        if (manager.TryLockChipStack()) {
            if (!codes_printed) {
                PrintOnboardingCodes(chip::RendezvousInformationFlags(chip::RendezvousInformationFlag::kBLE));
                codes_printed = true;
            }
            if (reset_pending) {
                const esp_err_t result = esp_matter::factory_reset();
                ESP_LOGW(TAG, "Maintenance button released after 8s: reset request=%s", esp_err_to_name(result));
                manager.UnlockChipStack();
                vTaskDelete(nullptr);
                return;
            }
            if (!initialized_position) {
                // Persisted position is not treated as a new physical gesture.
                initialized_position = set_position(false) == ESP_OK;
                dispatch.resync();
            }
            if (!initialized_position) {
                manager.UnlockChipStack();
                vTaskDelay(pdMS_TO_TICKS(10));
                continue;
            }
            bool down = false;
            if (edges.resync(down)) {
                const esp_err_t result = set_position(down);
                dispatch.resync();
                ESP_LOGW(TAG, "Position-only resync=%u result=%s; no recovered event", down, esp_err_to_name(result));
            }
            // Bounded four-item drain. No SDK call occurs in a GPIO ISR.
            while (edges.pop(down)) {
                const esp_err_t result = set_position(down);
                if (result != ESP_OK) {
                    dispatch.resync();
                    ESP_LOGE(TAG, "Position update failed=%s; suppress matching release event", esp_err_to_name(result));
                    continue;
                }
                const auto event = dispatch.next(down, true);
                if (event == lab::SwitchEvent::InitialPress) {
                    cluster::switch_cluster::event::send_initial_press(switch_id, 1);
                    ESP_LOGI(TAG, "InitialPress submitted to SDK; not a controller delivery acknowledgement");
                } else if (event == lab::SwitchEvent::ShortRelease) {
                    cluster::switch_cluster::event::send_short_release(switch_id, 1);
                    ESP_LOGI(TAG, "ShortRelease submitted to SDK; not replayed after disconnect");
                }
            }
            manager.UnlockChipStack();
        }
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

extern "C" void app_main(void)
{
    if (!lab_enabled()) {
        ESP_LOGW(TAG, "LAB_DISABLED: no NVS change, Thread/Matter start or BLE advertisement. Explicit sdkconfig.lab required.");
        return;
    }
    const esp_err_t nvs = nvs_flash_init();
    if (nvs != ESP_OK) {
        ESP_LOGE(TAG, "NVS init=%s; preserve data, do not auto-erase", esp_err_to_name(nvs));
        return;
    }
    gpio_config_t input = {};
    input.pin_bit_mask = (1ULL << EVENT_BUTTON) | (1ULL << RESET_BUTTON);
    input.mode = GPIO_MODE_INPUT; // Each SPST has its own external 10k pull-up.
    ESP_ERROR_CHECK(gpio_config(&input));
    node::config_t node_config;
    node_t *node = node::create(&node_config, update_cb, identify_cb);
    if (!node) { ESP_LOGE(TAG, "node create failed"); return; }
    endpoint::generic_switch::config_t switch_config;
    switch_config.switch_cluster.number_of_positions = 2;
    switch_config.switch_cluster.current_position = 0;
    switch_config.switch_cluster.feature_flags =
        cluster::switch_cluster::feature::momentary_switch::get_id() |
        cluster::switch_cluster::feature::momentary_switch_release::get_id();
    endpoint_t *endpoint = endpoint::generic_switch::create(node, &switch_config, ENDPOINT_FLAG_NONE, nullptr);
    if (!endpoint) { ESP_LOGE(TAG, "endpoint create failed"); return; }
    switch_id = endpoint::get_id(endpoint);
    auto *position = attribute::get(switch_id, Switch::Id, Switch::Attributes::CurrentPosition::Id);
    if (!position || attribute::set_deferred_persistence(position) != ESP_OK) {
        ESP_LOGE(TAG, "CurrentPosition deferred persistence unavailable"); return;
    }
    // Native C6 radio, not a UART RCP and not a Border Router.
    esp_openthread_platform_config_t thread = {};
    thread.radio_config.radio_mode = RADIO_MODE_NATIVE;
    thread.host_config.host_connection_mode = HOST_CONNECTION_MODE_NONE;
    thread.port_config.storage_partition_name = "nvs";
    thread.port_config.netif_queue_size = 10;
    thread.port_config.task_queue_size = 10;
    const esp_err_t platform = set_openthread_platform_config(&thread);
    if (platform != ESP_OK) {
        ESP_LOGE(TAG, "Thread platform config=%s", esp_err_to_name(platform)); return;
    }
    ESP_LOGW(TAG, "Development/test credentials; GenericSwitch endpoint=%u, Thread receiver-on lab", switch_id);
    const esp_err_t result = esp_matter::start(event_cb);
    if (result != ESP_OK) { ESP_LOGE(TAG, "Matter start=%s", esp_err_to_name(result)); return; }
    if (xTaskCreate(input_task, "r10_input", 4096, nullptr, 4, nullptr) != pdPASS)
        ESP_LOGE(TAG, "Input task unavailable; Matter stack may remain active without button sampling");
}

// ---- main/input_policy.h ----
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
namespace lab {
enum class Edge { None, Press, Release };
// One owner calls sample() with monotonic milliseconds. Start held is ignored
// until a stable release. No ISR, no allocation, no SDK dependency.
class Button {
    bool candidate_ = false, stable_ = false, armed_ = false, started_ = false;
    uint64_t candidate_at_ = 0, press_at_ = 0;
public:
    uint64_t last_hold_ms = 0;
    Edge sample(bool down, uint64_t now) {
        if (!started_) { started_ = true; candidate_ = down; candidate_at_ = now; return Edge::None; }
        if (down != candidate_) { candidate_ = down; candidate_at_ = now; return Edge::None; }
        if (now < candidate_at_ || now - candidate_at_ < 30) return Edge::None;
        if (!armed_) {
            stable_ = candidate_;
            if (!stable_) armed_ = true;
            return Edge::None;
        }
        if (stable_ == candidate_) return Edge::None;
        stable_ = candidate_;
        if (stable_) { press_at_ = now; return Edge::Press; }
        last_hold_ms = now >= press_at_ ? now - press_at_ : 0;
        return Edge::Release;
    }
    bool down() const { return armed_ && stable_; }
};
// At most four ordered position changes. On overflow drop the backlog and
// suppress events until the consumer resynchronizes the latest position.
class Edges {
    bool values_[4] = {}; unsigned head_ = 0, count_ = 0;
    bool resync_ = false, latest_ = false;
public:
    unsigned overflows = 0;
    void push(bool down) {
        latest_ = down;
        if (resync_) return;
        if (count_ == 4) { head_ = count_ = 0; resync_ = true; ++overflows; return; }
        values_[(head_ + count_) % 4] = down; ++count_;
    }
    bool resync(bool &position) {
        if (!resync_) return false;
        position = latest_; resync_ = false; return true;
    }
    bool pop(bool &position) {
        if (!count_) return false;
        position = values_[head_]; head_ = (head_ + 1) % 4; --count_; return true;
    }
};
enum class SwitchEvent { None, InitialPress, ShortRelease };
class Dispatch {
    bool active_ = false;
public:
    void resync() { active_ = false; }
    SwitchEvent next(bool down, bool position_ok) {
        if (!position_ok) { active_ = false; return SwitchEvent::None; }
        if (down) { active_ = true; return SwitchEvent::InitialPress; }
        if (!active_) return SwitchEvent::None;
        active_ = false; return SwitchEvent::ShortRelease;
    }
};
}
// ---- main/lab_config.c ----
// SPDX-License-Identifier: MIT
#include <stdbool.h>
#include "sdkconfig.h"
bool lab_enabled(void) {
#ifdef CONFIG_LAB_ENABLE_MATTER
    return true;
#else
    return false;
#endif
}

clang++ -std=c++17 -Wall -Wextra -Werror -fsanitize=address,undefined \
  -fno-omit-frame-pointer tests/host.cpp -o /tmp/r10-policy-host
/tmp/r10-policy-host