From 6ed86b2541ce529114158453e0ab05760e435e20 Mon Sep 17 00:00:00 2001 From: SuGlider Date: Wed, 3 Dec 2025 17:12:12 -0300 Subject: [PATCH 1/6] feat(matter): adds water leak detector matter endpoint --- CMakeLists.txt | 1 + docs/en/matter/ep_water_leak_detector.rst | 138 +++++++++++++ docs/en/matter/matter.rst | 1 + .../MatterWaterLeakDetector.ino | 162 ++++++++++++++++ .../MatterWaterLeakDetector/README.md | 182 ++++++++++++++++++ .../examples/MatterWaterLeakDetector/ci.yml | 5 + libraries/Matter/keywords.txt | 3 + libraries/Matter/src/Matter.h | 8 + .../MatterWaterLeakDetector.cpp | 105 ++++++++++ .../MatterEndpoints/MatterWaterLeakDetector.h | 55 ++++++ 10 files changed, 660 insertions(+) create mode 100644 docs/en/matter/ep_water_leak_detector.rst create mode 100644 libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino create mode 100644 libraries/Matter/examples/MatterWaterLeakDetector/README.md create mode 100644 libraries/Matter/examples/MatterWaterLeakDetector/ci.yml create mode 100644 libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp create mode 100644 libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 4732354aa73..415c1b42c1d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -193,6 +193,7 @@ set(ARDUINO_LIBRARY_Matter_SRCS libraries/Matter/src/MatterEndpoints/MatterTemperatureSensor.cpp libraries/Matter/src/MatterEndpoints/MatterHumiditySensor.cpp libraries/Matter/src/MatterEndpoints/MatterContactSensor.cpp + libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp libraries/Matter/src/MatterEndpoints/MatterPressureSensor.cpp libraries/Matter/src/MatterEndpoints/MatterOccupancySensor.cpp libraries/Matter/src/MatterEndpoints/MatterOnOffPlugin.cpp diff --git a/docs/en/matter/ep_water_leak_detector.rst b/docs/en/matter/ep_water_leak_detector.rst new file mode 100644 index 00000000000..cc0f315f807 --- /dev/null +++ b/docs/en/matter/ep_water_leak_detector.rst @@ -0,0 +1,138 @@ +########################## +MatterWaterLeakDetector +########################## + +About +----- + +The ``MatterWaterLeakDetector`` class provides a water leak detector endpoint for Matter networks. This endpoint implements the Matter water leak detection standard for detecting water leak conditions (detected/not detected states). + +**Features:** +* Water leak detection state reporting (detected/not detected) +* Simple boolean state +* Read-only sensor (no control functionality) +* Automatic state updates +* Integration with Apple HomeKit, Amazon Alexa, and Google Home +* Matter standard compliance + +**Use Cases:** +* Water leak monitoring +* Basement flood detection +* Appliance leak detection +* Smart home automation triggers +* Preventative maintenance systems + +API Reference +------------- + +Constructor +*********** + +MatterWaterLeakDetector +^^^^^^^^^^^^^^^^^^^^^^^^^ + +Creates a new Matter water leak detector endpoint. + +.. code-block:: arduino + + MatterWaterLeakDetector(); + +Initialization +************** + +begin +^^^^^ + +Initializes the Matter water leak detector endpoint with an initial leak detection state. + +.. code-block:: arduino + + bool begin(bool _leakState = false); + +* ``_leakState`` - Initial water leak detection state (``true`` = detected, ``false`` = not detected, default: ``false``) + +This function will return ``true`` if successful, ``false`` otherwise. + +end +^^^ + +Stops processing Matter water leak detector events. + +.. code-block:: arduino + + void end(); + +Water Leak Detection State Control +*********************************** + +setLeak +^^^^^^^^ + +Sets the water leak detection state. + +.. code-block:: arduino + + bool setLeak(bool _leakState); + +* ``_leakState`` - Water leak detection state (``true`` = detected, ``false`` = not detected) + +This function will return ``true`` if successful, ``false`` otherwise. + +getLeak +^^^^^^^ + +Gets the current water leak detection state. + +.. code-block:: arduino + + bool getLeak(); + +This function will return ``true`` if water leak is detected, ``false`` if not detected. + +Operators +********* + +bool operator +^^^^^^^^^^^^^ + +Returns the current water leak detection state. + +.. code-block:: arduino + + operator bool(); + +Example: + +.. code-block:: arduino + + if (myDetector) { + Serial.println("Water leak is detected"); + } else { + Serial.println("Water leak is not detected"); + } + +Assignment operator +^^^^^^^^^^^^^^^^^^^ + +Sets the water leak detection state. + +.. code-block:: arduino + + void operator=(bool _leakState); + +Example: + +.. code-block:: arduino + + myDetector = true; // Set water leak detection to detected + myDetector = false; // Set water leak detection to not detected + +Example +------- + +Water Leak Detector +******************** + +.. literalinclude:: ../../../libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino + :language: arduino + diff --git a/docs/en/matter/matter.rst b/docs/en/matter/matter.rst index 7fd3cc9ee2e..cfb97ccf38a 100644 --- a/docs/en/matter/matter.rst +++ b/docs/en/matter/matter.rst @@ -126,6 +126,7 @@ The library provides specialized endpoint classes for different device types. Ea * ``MatterHumiditySensor``: Humidity sensor (read-only) * ``MatterPressureSensor``: Pressure sensor (read-only) * ``MatterContactSensor``: Contact sensor (open/closed state) +* ``MatterWaterLeakDetector``: Water leak detector (detected/not detected state) * ``MatterOccupancySensor``: Occupancy sensor (occupied/unoccupied state) **Control Endpoints:** diff --git a/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino new file mode 100644 index 00000000000..1f03898c148 --- /dev/null +++ b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino @@ -0,0 +1,162 @@ +// Copyright 2025 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. + +/* + * This example is an example code that will create a Matter Device which can be + * commissioned and controlled from a Matter Environment APP. + * Additionally the ESP32 will send debug messages indicating the Matter activity. + * Turning DEBUG Level ON may be useful to following Matter Accessory and Controller messages. + * + * The example will create a Matter Water Leak Detector Device. + * The Water Leak Detector state can be toggled by pressing the onboard button. + * The Water Leak Detector state will be indicated by the onboard LED. + * The Water Leak Detector state will be simulated to change every 20 seconds. + * + * The onboard button can be kept pressed for 5 seconds to decommission the Matter Node. + * The example will also show the manual commissioning code and QR code to be used in the Matter environment. + * + */ + +// Matter Manager +#include +#if !CONFIG_ENABLE_CHIPOBLE +// if the device can be commissioned using BLE, WiFi is not used - save flash space +#include +#endif + +// List of Matter Endpoints for this Node +// Matter Water Leak Detector Endpoint +MatterWaterLeakDetector WaterLeakDetector; + +// CONFIG_ENABLE_CHIPOBLE is enabled when BLE is used to commission the Matter Network +#if !CONFIG_ENABLE_CHIPOBLE +// WiFi is manually set and started +const char *ssid = "your-ssid"; // Change this to your WiFi SSID +const char *password = "your-password"; // Change this to your WiFi password +#endif + +// LED will be used to indicate the Water Leak Detector state +// set your board RGB LED pin here +#ifdef RGB_BUILTIN +const uint8_t ledPin = RGB_BUILTIN; +#else +const uint8_t ledPin = 2; // Set your pin here if your board has not defined LED_BUILTIN +#warning "Do not forget to set the RGB LED pin" +#endif + +// set your board USER BUTTON pin here - decommissioning and Manual Water Leak Detector toggle button +const uint8_t buttonPin = BOOT_PIN; // Set your pin here. Using BOOT Button. + +// Button control +uint32_t button_time_stamp = 0; // debouncing control +bool button_state = false; // false = released | true = pressed +const uint32_t debouceTime = 250; // button debouncing time (ms) +const uint32_t decommissioningTimeout = 5000; // keep the button pressed for 5s, or longer, to decommission + +void setup() { + // Initialize the USER BUTTON (Boot button) that will be used to decommission the Matter Node + // The button will also be used to manually toggle the Water Leak Detector state + pinMode(buttonPin, INPUT_PULLUP); + // Initialize the LED (light) GPIO and Matter End Point + pinMode(ledPin, OUTPUT); + + Serial.begin(115200); + +// CONFIG_ENABLE_CHIPOBLE is enabled when BLE is used to commission the Matter Network +#if !CONFIG_ENABLE_CHIPOBLE + // Manually connect to WiFi + WiFi.begin(ssid, password); + // Wait for connection + while (WiFi.status() != WL_CONNECTED) { + delay(500); + Serial.print("."); + } + Serial.println(); +#endif + + // set initial water leak detector state as false (default) + WaterLeakDetector.begin(); + digitalWrite(ledPin, LOW); // LED OFF + + // Matter beginning - Last step, after all EndPoints are initialized + Matter.begin(); + + // Check Matter Accessory Commissioning state, which may change during execution of loop() + if (!Matter.isDeviceCommissioned()) { + Serial.println(""); + Serial.println("Matter Node is not commissioned yet."); + Serial.println("Initiate the device discovery in your Matter environment."); + Serial.println("Commission it to your Matter hub with the manual pairing code or QR code"); + Serial.printf("Manual pairing code: %s\r\n", Matter.getManualPairingCode().c_str()); + Serial.printf("QR code URL: %s\r\n", Matter.getOnboardingQRCodeUrl().c_str()); + // waits for Matter Water Leak Detector Commissioning. + uint32_t timeCount = 0; + while (!Matter.isDeviceCommissioned()) { + delay(100); + if ((timeCount++ % 50) == 0) { // 50*100ms = 5 sec + Serial.println("Matter Node not commissioned yet. Waiting for commissioning."); + } + } + Serial.println("Matter Node is commissioned and connected to the network. Ready for use."); + } +} + +bool simulatedHWWaterLeakDetector() { + // Simulated Water Leak Detector + static bool leakState = false; + static uint32_t lastTime = 0; + + // Simulate a Water Leak Detector state change every 20 seconds + if (millis() - lastTime > 20000) { + leakState = !leakState; + lastTime = millis(); + } + return leakState; +} + +void loop() { + // Check if the button has been pressed + if (digitalRead(buttonPin) == LOW && !button_state) { + // deals with button debouncing + button_time_stamp = millis(); // record the time while the button is pressed. + button_state = true; // pressed. + } + + uint32_t time_diff = millis() - button_time_stamp; + if (button_state && time_diff > debouceTime && digitalRead(buttonPin) == HIGH) { + button_state = false; // released + // button is released - toggle Leak State (Not Detected/Detected) + WaterLeakDetector.setLeak(!WaterLeakDetector.getLeak()); // same as WaterLeakDetector = !WaterLeakDetector; + Serial.printf("User button released. Setting the Water Leak Detector to %s.\r\n", WaterLeakDetector ? "Detected" : "Not Detected"); + // LED will indicate the Water Leak Detector state + if (WaterLeakDetector) { + digitalWrite(ledPin, HIGH); // LED ON + } else { + digitalWrite(ledPin, LOW); // LED OFF + } + } + + // Onboard User Button is kept pressed for longer than 5 seconds in order to decommission matter node + if (button_state && time_diff > decommissioningTimeout) { + Serial.println("Decommissioning Water Leak Detector Matter Accessory. It shall be commissioned again."); + Matter.decommission(); + button_time_stamp = millis(); // avoid running decommissining again, reboot takes a second or so + } + + // Simulated Water Leak Detector + WaterLeakDetector.setLeak(simulatedHWWaterLeakDetector()); + + delay(50); +} + diff --git a/libraries/Matter/examples/MatterWaterLeakDetector/README.md b/libraries/Matter/examples/MatterWaterLeakDetector/README.md new file mode 100644 index 00000000000..0c114217b8c --- /dev/null +++ b/libraries/Matter/examples/MatterWaterLeakDetector/README.md @@ -0,0 +1,182 @@ +# Matter Water Leak Detector Example + +This example demonstrates how to create a Matter-compatible water leak detector device using an ESP32 SoC microcontroller.\ +The application showcases Matter commissioning, device control via smart home ecosystems, manual control using a physical button, and automatic simulation of water leak detection state changes. + +## Supported Targets + +| SoC | Wi-Fi | Thread | BLE Commissioning | LED | Status | +| --- | ---- | ------ | ----------------- | --- | ------ | +| ESP32 | ✅ | ❌ | ❌ | Required | Fully supported | +| ESP32-S2 | ✅ | ❌ | ❌ | Required | Fully supported | +| ESP32-S3 | ✅ | ❌ | ✅ | Required | Fully supported | +| ESP32-C3 | ✅ | ❌ | ✅ | Required | Fully supported | +| ESP32-C5 | ✅ | ❌ | ✅ | Required | Fully supported | +| ESP32-C6 | ✅ | ❌ | ✅ | Required | Fully supported | +| ESP32-H2 | ❌ | ✅ | ✅ | Required | Supported (Thread only) | + +### Note on Commissioning: + +- **ESP32 & ESP32-S2** do not support commissioning over Bluetooth LE. For these chips, you must provide Wi-Fi credentials directly in the sketch code so they can connect to your network manually. +- **ESP32-C6** Although it has Thread support, the ESP32 Arduino Matter Library has been pre compiled using Wi-Fi only. In order to configure it for Thread-only operation it is necessary to build the project as an ESP-IDF component and to disable the Matter Wi-Fi station feature. +- **ESP32-C5** Although it has Thread support, the ESP32 Arduino Matter Library has been pre compiled using Wi-Fi only. In order to configure it for Thread-only operation it is necessary to build the project as an ESP-IDF component and to disable the Matter Wi-Fi station feature. + +## Features + +- Matter protocol implementation for a water leak detector device +- Support for both Wi-Fi and Thread(*) connectivity +- Water leak detection state indication using LED (ON = Detected, OFF = Not Detected) +- Automatic simulation of water leak detection state changes every 20 seconds +- Button control for toggling water leak detection state and factory reset +- Matter commissioning via QR code or manual pairing code +- Integration with Apple HomeKit, Amazon Alexa, and Google Home +(*) It is necessary to compile the project using Arduino as IDF Component. + +## Hardware Requirements + +- ESP32 compatible development board (see supported targets table) +- LED connected to GPIO pins (or using built-in LED) to indicate water leak detection state +- User button for manual control (uses BOOT button by default) + +## Pin Configuration + +- **LED**: Uses `RGB_BUILTIN` if defined, otherwise pin 2 +- **Button**: Uses `BOOT_PIN` by default + +## Software Setup + +### Prerequisites + +1. Install the Arduino IDE (2.0 or newer recommended) +2. Install ESP32 Arduino Core with Matter support +3. ESP32 Arduino libraries: + - `Matter` + - `Wi-Fi` (only for ESP32 and ESP32-S2) + +### Configuration + +Before uploading the sketch, configure the following: + +1. **Wi-Fi credentials** (if not using BLE commissioning - mandatory for ESP32 | ESP32-S2): + ```cpp + const char *ssid = "your-ssid"; // Change to your Wi-Fi SSID + const char *password = "your-password"; // Change to your Wi-Fi password + ``` + +2. **LED pin configuration** (if not using built-in LED): + ```cpp + const uint8_t ledPin = 2; // Set your LED pin here + ``` + +3. **Button pin configuration** (optional): + By default, the `BOOT` button (GPIO 0) is used for the Water Leak Detector state toggle and factory reset. You can change this to a different pin if needed. + ```cpp + const uint8_t buttonPin = BOOT_PIN; // Set your button pin here + ``` + +## Building and Flashing + +1. Open the `MatterWaterLeakDetector.ino` sketch in the Arduino IDE. +2. Select your ESP32 board from the **Tools > Board** menu. +3. Connect your ESP32 board to your computer via USB. +4. Click the **Upload** button to compile and flash the sketch. + +## Expected Output + +Once the sketch is running, open the Serial Monitor at a baud rate of **115200**. The Wi-Fi connection messages will be displayed only for ESP32 and ESP32-S2. Other targets will use Matter CHIPoBLE to automatically setup the IP Network. You should see output similar to the following, which provides the necessary information for commissioning: + +``` +Connecting to your-wifi-ssid +....... +Wi-Fi connected +IP address: 192.168.1.100 + +Matter Node is not commissioned yet. +Initiate the device discovery in your Matter environment. +Commission it to your Matter hub with the manual pairing code or QR code +Manual pairing code: 34970112332 +QR code URL: https://project-chip.github.io/connectedhomeip/qrcode.html?data=MT%3A6FCJ142C00KA0648G00 +Matter Node not commissioned yet. Waiting for commissioning. +Matter Node not commissioned yet. Waiting for commissioning. +... +Matter Node is commissioned and connected to the network. Ready for use. +User button released. Setting the Water Leak Detector to Detected. +User button released. Setting the Water Leak Detector to Not Detected. +``` + +## Using the Device + +### Manual Control + +The user button (BOOT button by default) provides manual control: + +- **Short press of the button**: Toggle water leak detector state (Not Detected/Detected) +- **Long press (>5 seconds)**: Factory reset the device (decommission) + +### Automatic Simulation + +The water leak detector state automatically toggles every 20 seconds to simulate a real water leak detector. The LED will reflect the current state: +- **LED ON**: Water leak is Detected +- **LED OFF**: Water leak is Not Detected + +### Smart Home Integration + +Use a Matter-compatible hub (like an Apple HomePod, Google Nest Hub, or Amazon Echo) to commission the device. +Check for Matter Water Leak Detector endpoint support within the Matter Controller developer webpage. +This endpoint is part of the latest Matter supported device list and it may not be fully supported by your Matter environment. +You can also try the Home Assistant Matter feature in order to test it. + +#### Apple Home + +1. Open the Home app on your iOS device +2. Tap the "+" button > Add Accessory +3. Scan the QR code displayed in the Serial Monitor, or +4. Tap "I Don't Have a Code or Cannot Scan" and enter the manual pairing code +5. Follow the prompts to complete setup +6. The device will appear as a water leak detector in your Home app +7. You can monitor the water leak detection state (Detected/Not Detected) and receive notifications when the state changes + +#### Amazon Alexa + +1. Open the Alexa app +2. Tap More > Add Device > Matter +3. Select "Scan QR code" or "Enter code manually" +4. Complete the setup process +5. The water leak detector will appear in your Alexa app +6. You can monitor the water leak detection state and set up routines based on state changes + +#### Google Home + +1. Open the Google Home app +2. Tap "+" > Set up device > New device +3. Choose "Matter device" +4. Scan the QR code or enter the manual pairing code +5. Follow the prompts to complete setup +6. The water leak detector will appear in your Google Home app + +## Code Structure + +The MatterWaterLeakDetector example consists of the following main components: + +1. **`setup()`**: Initializes hardware (button, LED), configures Wi-Fi (if needed), sets up the Matter Water Leak Detector endpoint with initial state (Not Detected), and waits for Matter commissioning. +2. **`loop()`**: Handles button input for toggling water leak detection state and factory reset, and automatically simulates water leak detection state changes every 20 seconds. +3. **`simulatedHWWaterLeakDetector()`**: Simulates a hardware water leak detector by toggling the water leak detection state every 20 seconds. + +## Troubleshooting + +- **Device not visible during commissioning**: Ensure Wi-Fi or Thread connectivity is properly configured +- **LED not responding**: Verify pin configurations and connections +- **Water leak detector state not updating**: Check Serial Monitor output to verify state changes are being processed +- **Failed to commission**: Try factory resetting the device by long-pressing the button. Other option would be to erase the SoC Flash Memory by using `Arduino IDE Menu` -> `Tools` -> `Erase All Flash Before Sketch Upload: "Enabled"` or directly with `esptool.py --port erase_flash` +- **No serial output**: Check baudrate (115200) and USB connection + +## Related Documentation + +- [Matter Overview](https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/matter.html) +- [Matter Endpoint Base Class](https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/matter_ep.html) +- [Matter Water Leak Detector Endpoint](https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_water_leak_detector.html) + +## License + +This example is licensed under the Apache License, Version 2.0. + diff --git a/libraries/Matter/examples/MatterWaterLeakDetector/ci.yml b/libraries/Matter/examples/MatterWaterLeakDetector/ci.yml new file mode 100644 index 00000000000..1cbd404d6ed --- /dev/null +++ b/libraries/Matter/examples/MatterWaterLeakDetector/ci.yml @@ -0,0 +1,5 @@ +fqbn_append: PartitionScheme=huge_app + +requires: + - CONFIG_ESP_MATTER_ENABLE_DATA_MODEL=y + diff --git a/libraries/Matter/keywords.txt b/libraries/Matter/keywords.txt index 6c2e092e417..9880c5caa92 100644 --- a/libraries/Matter/keywords.txt +++ b/libraries/Matter/keywords.txt @@ -21,6 +21,7 @@ FanModeSequence_t KEYWORD1 MatterTemperatureSensor KEYWORD1 MatterHumiditySensor KEYWORD1 MatterContactSensor KEYWORD1 +MatterWaterLeakDetector KEYWORD1 MatterPressureSensor KEYWORD1 MatterOccupancySensor KEYWORD1 MatterOnOffPlugin KEYWORD1 @@ -90,6 +91,8 @@ setHumidity KEYWORD2 getHumidity KEYWORD2 setContact KEYWORD2 getContact KEYWORD2 +setLeak KEYWORD2 +getLeak KEYWORD2 setPressure KEYWORD2 getPressure KEYWORD2 setOccupancy KEYWORD2 diff --git a/libraries/Matter/src/Matter.h b/libraries/Matter/src/Matter.h index 89360e81d4b..efb6b16a822 100644 --- a/libraries/Matter/src/Matter.h +++ b/libraries/Matter/src/Matter.h @@ -29,6 +29,10 @@ #include #include #include +<<<<<<< Updated upstream +======= +#include +>>>>>>> Stashed changes #include #include #include @@ -194,6 +198,10 @@ class ArduinoMatter { friend class MatterTemperatureSensor; friend class MatterHumiditySensor; friend class MatterContactSensor; +<<<<<<< Updated upstream +======= + friend class MatterWaterLeakDetector; +>>>>>>> Stashed changes friend class MatterPressureSensor; friend class MatterOccupancySensor; friend class MatterOnOffPlugin; diff --git a/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp b/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp new file mode 100644 index 00000000000..c02880db92f --- /dev/null +++ b/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp @@ -0,0 +1,105 @@ +// Copyright 2025 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. + +#include +#ifdef CONFIG_ESP_MATTER_ENABLE_DATA_MODEL + +#include +#include +#include + +using namespace esp_matter; +using namespace esp_matter::endpoint; +using namespace chip::app::Clusters; + +bool MatterWaterLeakDetector::attributeChangeCB(uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id, esp_matter_attr_val_t *val) { + bool ret = true; + if (!started) { + log_e("Matter Water Leak Detector device has not begun."); + return false; + } + + log_d("Water Leak Detector Attr update callback: endpoint: %u, cluster: %u, attribute: %u, val: %u", endpoint_id, cluster_id, attribute_id, val->val.u32); + return ret; +} + +MatterWaterLeakDetector::MatterWaterLeakDetector() {} + +MatterWaterLeakDetector::~MatterWaterLeakDetector() { + end(); +} + +bool MatterWaterLeakDetector::begin(bool _leakState) { + ArduinoMatter::_init(); + + if (getEndPointId() != 0) { + log_e("Matter Water Leak Detector with Endpoint Id %d device has already been created.", getEndPointId()); + return false; + } + + water_leak_detector::config_t water_leak_detector_config; + water_leak_detector_config.boolean_state.state_value = _leakState; + + // endpoint handles can be used to add/modify clusters. + endpoint_t *endpoint = water_leak_detector::create(node::get(), &water_leak_detector_config, ENDPOINT_FLAG_NONE, (void *)this); + if (endpoint == nullptr) { + log_e("Failed to create Water Leak Detector endpoint"); + return false; + } + leakState = _leakState; + setEndPointId(endpoint::get_id(endpoint)); + log_i("Water Leak Detector created with endpoint_id %d", getEndPointId()); + + started = true; + return true; +} + +void MatterWaterLeakDetector::end() { + started = false; +} + +bool MatterWaterLeakDetector::setLeak(bool _leakState) { + if (!started) { + log_e("Matter Water Leak Detector device has not begun."); + return false; + } + + // avoid processing if there was no change + if (leakState == _leakState) { + return true; + } + + esp_matter_attr_val_t leakVal = esp_matter_invalid(NULL); + + if (!getAttributeVal(BooleanState::Id, BooleanState::Attributes::StateValue::Id, &leakVal)) { + log_e("Failed to get Water Leak Detector Attribute."); + return false; + } + if (leakVal.val.u8 != _leakState) { + leakVal.val.u8 = _leakState; + bool ret; + ret = updateAttributeVal(BooleanState::Id, BooleanState::Attributes::StateValue::Id, &leakVal); + if (!ret) { + log_e("Failed to update Water Leak Detector Attribute."); + return false; + } + leakState = _leakState; + } + log_v("Water Leak Detector set to %s", _leakState ? "Detected" : "Not Detected"); + + return true; +} + +#endif /* CONFIG_ESP_MATTER_ENABLE_DATA_MODEL */ + diff --git a/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.h b/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.h new file mode 100644 index 00000000000..7d66a245ee7 --- /dev/null +++ b/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.h @@ -0,0 +1,55 @@ +// Copyright 2025 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 +#ifdef CONFIG_ESP_MATTER_ENABLE_DATA_MODEL + +#include +#include + +class MatterWaterLeakDetector : public MatterEndPoint { +public: + MatterWaterLeakDetector(); + ~MatterWaterLeakDetector(); + // begin Matter Water Leak Detector endpoint with initial leak state + bool begin(bool _leakState = false); + // this will just stop processing Water Leak Detector Matter events + void end(); + + // set the leak state + bool setLeak(bool _leakState); + // returns the leak state + bool getLeak() { + return leakState; + } + + // bool conversion operator + void operator=(bool _leakState) { + setLeak(_leakState); + } + // bool conversion operator + operator bool() { + return getLeak(); + } + + // this function is called by Matter internal event processor. It could be overwritten by the application, if necessary. + bool attributeChangeCB(uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id, esp_matter_attr_val_t *val); + +protected: + bool started = false; + bool leakState = false; +}; +#endif /* CONFIG_ESP_MATTER_ENABLE_DATA_MODEL */ + From f999df938f42f6999b8d0bb44a2a2127b5f2e058 Mon Sep 17 00:00:00 2001 From: SuGlider Date: Wed, 3 Dec 2025 17:15:38 -0300 Subject: [PATCH 2/6] feat(matter): fix matter.h conflicts --- libraries/Matter/src/Matter.h | 6 ------ 1 file changed, 6 deletions(-) diff --git a/libraries/Matter/src/Matter.h b/libraries/Matter/src/Matter.h index efb6b16a822..fbace3593b5 100644 --- a/libraries/Matter/src/Matter.h +++ b/libraries/Matter/src/Matter.h @@ -29,10 +29,7 @@ #include #include #include -<<<<<<< Updated upstream -======= #include ->>>>>>> Stashed changes #include #include #include @@ -198,10 +195,7 @@ class ArduinoMatter { friend class MatterTemperatureSensor; friend class MatterHumiditySensor; friend class MatterContactSensor; -<<<<<<< Updated upstream -======= friend class MatterWaterLeakDetector; ->>>>>>> Stashed changes friend class MatterPressureSensor; friend class MatterOccupancySensor; friend class MatterOnOffPlugin; From 90f9cb4cbde16af478b907ff463ae2d489e9e549 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci-lite[bot]" <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> Date: Thu, 4 Dec 2025 12:35:38 +0000 Subject: [PATCH 3/6] ci(pre-commit): Apply automatic fixes --- docs/en/matter/ep_water_leak_detector.rst | 1 - .../examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino | 1 - libraries/Matter/examples/MatterWaterLeakDetector/README.md | 1 - libraries/Matter/examples/MatterWaterLeakDetector/ci.yml | 1 - libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp | 1 - libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.h | 1 - 6 files changed, 6 deletions(-) diff --git a/docs/en/matter/ep_water_leak_detector.rst b/docs/en/matter/ep_water_leak_detector.rst index cc0f315f807..e68d984fe13 100644 --- a/docs/en/matter/ep_water_leak_detector.rst +++ b/docs/en/matter/ep_water_leak_detector.rst @@ -135,4 +135,3 @@ Water Leak Detector .. literalinclude:: ../../../libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino :language: arduino - diff --git a/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino index 1f03898c148..38ae60cb62c 100644 --- a/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino +++ b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino @@ -159,4 +159,3 @@ void loop() { delay(50); } - diff --git a/libraries/Matter/examples/MatterWaterLeakDetector/README.md b/libraries/Matter/examples/MatterWaterLeakDetector/README.md index 0c114217b8c..3dcf2f2e9f7 100644 --- a/libraries/Matter/examples/MatterWaterLeakDetector/README.md +++ b/libraries/Matter/examples/MatterWaterLeakDetector/README.md @@ -179,4 +179,3 @@ The MatterWaterLeakDetector example consists of the following main components: ## License This example is licensed under the Apache License, Version 2.0. - diff --git a/libraries/Matter/examples/MatterWaterLeakDetector/ci.yml b/libraries/Matter/examples/MatterWaterLeakDetector/ci.yml index 1cbd404d6ed..050a80ff543 100644 --- a/libraries/Matter/examples/MatterWaterLeakDetector/ci.yml +++ b/libraries/Matter/examples/MatterWaterLeakDetector/ci.yml @@ -2,4 +2,3 @@ fqbn_append: PartitionScheme=huge_app requires: - CONFIG_ESP_MATTER_ENABLE_DATA_MODEL=y - diff --git a/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp b/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp index c02880db92f..e079807286f 100644 --- a/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp +++ b/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.cpp @@ -102,4 +102,3 @@ bool MatterWaterLeakDetector::setLeak(bool _leakState) { } #endif /* CONFIG_ESP_MATTER_ENABLE_DATA_MODEL */ - diff --git a/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.h b/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.h index 7d66a245ee7..e94dd3eb525 100644 --- a/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.h +++ b/libraries/Matter/src/MatterEndpoints/MatterWaterLeakDetector.h @@ -52,4 +52,3 @@ class MatterWaterLeakDetector : public MatterEndPoint { bool leakState = false; }; #endif /* CONFIG_ESP_MATTER_ENABLE_DATA_MODEL */ - From ec4a5e105b0ff24fd396c2583a04ecd0a4afe798 Mon Sep 17 00:00:00 2001 From: Sugar Glider Date: Thu, 4 Dec 2025 12:10:17 -0300 Subject: [PATCH 4/6] fix(matter): spelling Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../MatterWaterLeakDetector/MatterWaterLeakDetector.ino | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino index 38ae60cb62c..d018dc68f32 100644 --- a/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino +++ b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino @@ -151,7 +151,7 @@ void loop() { if (button_state && time_diff > decommissioningTimeout) { Serial.println("Decommissioning Water Leak Detector Matter Accessory. It shall be commissioned again."); Matter.decommission(); - button_time_stamp = millis(); // avoid running decommissining again, reboot takes a second or so + button_time_stamp = millis(); // avoid running decommissioning again, reboot takes a second or so } // Simulated Water Leak Detector From 99aec0ad4d45f2e3585962ea006f5f0c5c030347 Mon Sep 17 00:00:00 2001 From: Sugar Glider Date: Thu, 4 Dec 2025 12:10:39 -0300 Subject: [PATCH 5/6] fix(matter): formatting Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../MatterWaterLeakDetector/MatterWaterLeakDetector.ino | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino index d018dc68f32..35fe3335681 100644 --- a/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino +++ b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino @@ -61,7 +61,7 @@ const uint8_t buttonPin = BOOT_PIN; // Set your pin here. Using BOOT Button. // Button control uint32_t button_time_stamp = 0; // debouncing control bool button_state = false; // false = released | true = pressed -const uint32_t debouceTime = 250; // button debouncing time (ms) +const uint32_t debounceTime = 250; // button debouncing time (ms) const uint32_t decommissioningTimeout = 5000; // keep the button pressed for 5s, or longer, to decommission void setup() { From 1272d1cd4969f5adee9215eee87874bf5e11a790 Mon Sep 17 00:00:00 2001 From: Sugar Glider Date: Thu, 4 Dec 2025 12:35:12 -0300 Subject: [PATCH 6/6] fix(matter): fix var name - spelling --- .../MatterWaterLeakDetector/MatterWaterLeakDetector.ino | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino index 35fe3335681..8cbbd586f8d 100644 --- a/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino +++ b/libraries/Matter/examples/MatterWaterLeakDetector/MatterWaterLeakDetector.ino @@ -134,7 +134,7 @@ void loop() { } uint32_t time_diff = millis() - button_time_stamp; - if (button_state && time_diff > debouceTime && digitalRead(buttonPin) == HIGH) { + if (button_state && time_diff > debounceTime && digitalRead(buttonPin) == HIGH) { button_state = false; // released // button is released - toggle Leak State (Not Detected/Detected) WaterLeakDetector.setLeak(!WaterLeakDetector.getLeak()); // same as WaterLeakDetector = !WaterLeakDetector;