ESP32 做第一个 Matter Wi-Fi 小灯：从编译到控制器配对

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-wifi-light"
export LAB_BUILD="/absolute/path/r09-enabled"
idf.py -C "$LAB_PROJECT" -B "$LAB_BUILD" -D IDF_TARGET=esp32s3 \
  -D SDKCONFIG="$LAB_BUILD/sdkconfig" \
  -D "SDKCONFIG_DEFAULTS=$LAB_PROJECT/sdkconfig.defaults;$LAB_PROJECT/sdkconfig.lab" build
# 板修订/备份/UART口核对后，实体flash monitor命令见下载README。

// ---- 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 "input_policy.h"

extern "C" bool lab_enabled(void);
using namespace esp_matter;
using namespace chip::app::Clusters;
static constexpr gpio_num_t LED = GPIO_NUM_4;
static constexpr gpio_num_t BUTTON = GPIO_NUM_5;
static const char *TAG = "r09";
static uint16_t light_id;

static esp_err_t update_cb(attribute::callback_type_t type, uint16_t endpoint_id,
                           uint32_t cluster_id, uint32_t attribute_id,
                           esp_matter_attr_val_t *value, void *)
{
    if (type == attribute::PRE_UPDATE && endpoint_id == light_id &&
        cluster_id == OnOff::Id && attribute_id == OnOff::Attributes::OnOff::Id && value) {
        return gpio_set_level(LED, value->val.b ? 1 : 0);
    }
    return ESP_OK;
}

static esp_err_t identify_cb(identification::callback_type_t, uint16_t, uint8_t, uint8_t, void *)
{
    // Identification is logged, not mixed with the persistent OnOff output.
    ESP_LOGI(TAG, "Identify requested (no extra blink implemented)");
    return ESP_OK;
}

static void event_cb(const chip::DeviceLayer::ChipDeviceEvent *event, intptr_t)
{
    // Numeric SDK event only: commissioning completion is not an LED observation.
    ESP_LOGI(TAG, "Matter event=%u", static_cast<unsigned>(event->Type));
}

static void input_task(void *)
{
    lab::Button button;
    bool initialized_output = false, pending_toggle = false, pending_reset = false;
    unsigned dropped = 0;
    bool codes_printed = false;
    for (;;) {
        const uint64_t now = static_cast<uint64_t>(esp_timer_get_time() / 1000);
        const auto edge = button.sample(gpio_get_level(BUTTON) == 0, now);
        if (edge == lab::Edge::Release) {
            if (button.last_hold_ms >= 8000) {
                pending_reset = true;
                pending_toggle = false;
            } else if (!pending_reset) {
                if (pending_toggle) ESP_LOGW(TAG, "Pending toggle full; drop new=%u", ++dropped);
                else pending_toggle = true;
            }
        }
        // One bounded owner; a busy stack does not block button sampling.
        // Remote updates and this read/update execute under the same CHIP lock.
        auto &manager = chip::DeviceLayer::PlatformMgr();
        if ((pending_reset || pending_toggle || !initialized_output) && manager.TryLockChipStack()) {
            if (!codes_printed) {
                PrintOnboardingCodes(chip::RendezvousInformationFlags(chip::RendezvousInformationFlag::kBLE));
                codes_printed = true;
            }
            auto *onoff = attribute::get(light_id, OnOff::Id, OnOff::Attributes::OnOff::Id);
            esp_matter_attr_val_t value = esp_matter_bool(false);
            const esp_err_t read = onoff ? attribute::get_val(onoff, &value) : ESP_ERR_NOT_FOUND;
            if (!initialized_output && read == ESP_OK) {
                initialized_output = gpio_set_level(LED, value.val.b ? 1 : 0) == ESP_OK;
                ESP_LOGI(TAG, "Restored OnOff=%u, GPIO apply=%u", value.val.b, initialized_output);
            }
            if (pending_reset) {
                const esp_err_t result = esp_matter::factory_reset();
                pending_reset = false;
                ESP_LOGW(TAG, "Explicit released 8s hold: factory-reset request=%s", esp_err_to_name(result));
                // The SDK schedules its reset even if its local namespace erase fails.
                manager.UnlockChipStack();
                vTaskDelete(nullptr);
                return;
            }
            if (pending_toggle) {
                esp_err_t result = read;
                if (read == ESP_OK) {
                    value.val.b = !value.val.b;
                    result = attribute::update(light_id, OnOff::Id, OnOff::Attributes::OnOff::Id, &value);
                }
                ESP_LOGI(TAG, "Local toggle request=%s (not controller acknowledgement)", esp_err_to_name(result));
                pending_toggle = false; // A failed request is not replayed later.
            }
            manager.UnlockChipStack();
        }
        vTaskDelay(pdMS_TO_TICKS(10));
    }
}

extern "C" void app_main(void)
{
    gpio_config_t output = {};
    output.pin_bit_mask = 1ULL << LED;
    output.mode = GPIO_MODE_OUTPUT;
    ESP_ERROR_CHECK(gpio_config(&output));
    ESP_ERROR_CHECK(gpio_set_level(LED, 0));
    if (!lab_enabled()) {
        ESP_LOGW(TAG, "LAB_DISABLED: LED off; no NVS change, BLE advertisement or Matter start. 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 << BUTTON;
    input.mode = GPIO_MODE_INPUT; // External 10k pull-up to 3.3V.
    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::on_off_light::config_t light_config;
    light_config.on_off.on_off = false;
    light_config.on_off_lighting.start_up_on_off = nullptr;
    endpoint_t *light = endpoint::on_off_light::create(node, &light_config, ENDPOINT_FLAG_NONE, nullptr);
    if (!light) { ESP_LOGE(TAG, "endpoint create failed"); return; }
    light_id = endpoint::get_id(light);
    ESP_LOGW(TAG, "Development/test DAC and setup parameters only. endpoint=%u", light_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, "r09_input", 4096, nullptr, 4, nullptr) != pdPASS)
        ESP_LOGE(TAG, "Input task unavailable; remote Matter stack may remain active");
}

// ---- 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_; }
};
}
// ---- 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/r09-policy-host
/tmp/r09-policy-host