diff --git a/CMakeLists.txt b/CMakeLists.txt index ed9ae23f83f..f3d889eb4c2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -177,6 +177,7 @@ set(ARDUINO_LIBRARY_Matter_SRCS libraries/Matter/src/MatterEndpoints/MatterFan.cpp libraries/Matter/src/MatterEndpoints/MatterTemperatureSensor.cpp libraries/Matter/src/MatterEndpoints/MatterHumiditySensor.cpp + libraries/Matter/src/MatterEndpoints/MatterContactSensor.cpp libraries/Matter/src/Matter.cpp) set(ARDUINO_LIBRARY_PPP_SRCS diff --git a/libraries/Matter/examples/MatterContactSensor/MatterContactSensor.ino b/libraries/Matter/examples/MatterContactSensor/MatterContactSensor.ino new file mode 100644 index 00000000000..ebea5000536 --- /dev/null +++ b/libraries/Matter/examples/MatterContactSensor/MatterContactSensor.ino @@ -0,0 +1,152 @@ +// Copyright 2024 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 Contact Sensor Device. + * The Contact Sensor state can be toggled by pressing the onboard button. + * The Contact Sensor state will be indicated by the onboard LED. + * The Contact Sensor 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 +#include + +// List of Matter Endpoints for this Node +// Matter Contact Sensor Endpoint +MatterContactSensor ContactSensor; + +// LED will be used to indicate the Contact Sensor 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 Contact Sensor toggle button +const uint8_t buttonPin = BOOT_PIN; // Set your pin here. Using BOOT Button. + +// 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 + +// 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 Contact Sensor state + pinMode(buttonPin, INPUT_PULLUP); + // Initialize the LED (light) GPIO and Matter End Point + pinMode(ledPin, OUTPUT); + + Serial.begin(115200); + + // Manually connect to WiFi + WiFi.begin(ssid, password); + // Wait for connection + while (WiFi.status() != WL_CONNECTED) { + delay(500); + Serial.print("."); + } + Serial.println(); + + // set initial contact sensor state as false (default) + ContactSensor.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 Contact Sensor 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 Wi-Fi. Ready for use."); + } +} + +bool simulatedHWContactSensor() { + // Simulated Contact Sensor + static bool contactState = false; + static uint32_t lastTime = 0; + + // Simulate a Contact Sensor state change every 20 seconds + if (millis() - lastTime > 20000) { + contactState = !contactState; + lastTime = millis(); + } + return contactState; +} + +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 Contact State (Open/Closed) + ContactSensor.setContact(!ContactSensor.getContact()); // same as ContactSensor = !ContactSensor; + Serial.printf("User button released. Setting the Contact Sensor to %s.\r\n", ContactSensor ? "Closed" : "Open"); + // LED will indicate the Contact Sensor state + if (ContactSensor) { + 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 the Generic Switch Matter Accessory. It shall be commissioned again."); + Matter.decommission(); + button_time_stamp = millis(); // avoid running decommissining again, reboot takes a second or so + } + + // Simulated Contact Sensor + ContactSensor.setContact(simulatedHWContactSensor()); + + delay(50); +} diff --git a/libraries/Matter/examples/MatterContactSensor/ci.json b/libraries/Matter/examples/MatterContactSensor/ci.json new file mode 100644 index 00000000000..556a8a9ee6b --- /dev/null +++ b/libraries/Matter/examples/MatterContactSensor/ci.json @@ -0,0 +1,7 @@ +{ + "fqbn_append": "PartitionScheme=huge_app", + "requires": [ + "CONFIG_SOC_WIFI_SUPPORTED=y", + "CONFIG_ESP_MATTER_ENABLE_DATA_MODEL=y" + ] +} diff --git a/libraries/Matter/keywords.txt b/libraries/Matter/keywords.txt index c54b040d94b..5b04d6f91e4 100644 --- a/libraries/Matter/keywords.txt +++ b/libraries/Matter/keywords.txt @@ -20,6 +20,7 @@ FanMode_t KEYWORD1 FanModeSequence_t KEYWORD1 MatterTemperatureSensor KEYWORD1 MatterHumiditySensor KEYWORD1 +MatterContactSensor KEYWORD1 ####################################### # Methods and Functions (KEYWORD2) @@ -68,6 +69,8 @@ setTemperature KEYWORD2 getTemperature KEYWORD2 setHumidity KEYWORD2 getHumidity KEYWORD2 +setContact KEYWORD2 +getContact KEYWORD2 ####################################### # Constants (LITERAL1) diff --git a/libraries/Matter/src/Matter.h b/libraries/Matter/src/Matter.h index 4b7804d61df..65483abb583 100644 --- a/libraries/Matter/src/Matter.h +++ b/libraries/Matter/src/Matter.h @@ -28,6 +28,7 @@ #include #include #include +#include using namespace esp_matter; @@ -62,6 +63,7 @@ class ArduinoMatter { friend class MatterFan; friend class MatterTemperatureSensor; friend class MatterHumiditySensor; + friend class MatterContactSensor; protected: static void _init(); diff --git a/libraries/Matter/src/MatterEndpoints/MatterContactSensor.cpp b/libraries/Matter/src/MatterEndpoints/MatterContactSensor.cpp new file mode 100644 index 00000000000..24266c82c95 --- /dev/null +++ b/libraries/Matter/src/MatterEndpoints/MatterContactSensor.cpp @@ -0,0 +1,98 @@ +// Copyright 2024 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 MatterContactSensor::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 Contact Sensor device has not begun."); + return false; + } + + log_d("Contact Sensor Attr update callback: endpoint: %u, cluster: %u, attribute: %u, val: %u", endpoint_id, cluster_id, attribute_id, val->val.u32); + return ret; +} + +MatterContactSensor::MatterContactSensor() {} + +MatterContactSensor::~MatterContactSensor() { + end(); +} + +bool MatterContactSensor::begin(bool _contactState) { + ArduinoMatter::_init(); + + contact_sensor::config_t contact_sensor_config; + contact_sensor_config.boolean_state.state_value = _contactState; + + // endpoint handles can be used to add/modify clusters. + endpoint_t *endpoint = contact_sensor::create(node::get(), &contact_sensor_config, ENDPOINT_FLAG_NONE, (void *)this); + if (endpoint == nullptr) { + log_e("Failed to create Contact Sensor endpoint"); + return false; + } + contactState = _contactState; + setEndPointId(endpoint::get_id(endpoint)); + log_i("Contact Sensor created with endpoint_id %d", getEndPointId()); + started = true; + return true; +} + +void MatterContactSensor::end() { + started = false; +} + +bool MatterContactSensor::setContact(bool _contactState) { + if (!started) { + log_e("Matter Contact Sensor device has not begun."); + return false; + } + + // avoid processing the a "no-change" + if (contactState == _contactState) { + return true; + } + + esp_matter_attr_val_t contactVal = esp_matter_invalid(NULL); + + if (!getAttributeVal(BooleanState::Id, BooleanState::Attributes::StateValue::Id, &contactVal)) { + log_e("Failed to get Contact Sensor Attribute."); + return false; + } + if (contactVal.val.u8 != _contactState) { + contactVal.val.u8 = _contactState; + bool ret; + ret = updateAttributeVal(BooleanState::Id, BooleanState::Attributes::StateValue::Id, &contactVal); + if (!ret) { + log_e("Failed to update Contact Sensor Attribute."); + return false; + } + contactState = _contactState; + } + log_v("Contact Sensor set to %s", _contactState ? "Closed" : "Open"); + + return true; +} + +#endif /* CONFIG_ESP_MATTER_ENABLE_DATA_MODEL */ diff --git a/libraries/Matter/src/MatterEndpoints/MatterContactSensor.h b/libraries/Matter/src/MatterEndpoints/MatterContactSensor.h new file mode 100644 index 00000000000..257da785e53 --- /dev/null +++ b/libraries/Matter/src/MatterEndpoints/MatterContactSensor.h @@ -0,0 +1,54 @@ +// Copyright 2024 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 MatterContactSensor : public MatterEndPoint { +public: + MatterContactSensor(); + ~MatterContactSensor(); + // begin Matter Contact Sensor endpoint with initial contact state + bool begin(bool _contactState = false); + // this will just stop processing Contact Sensor Matter events + void end(); + + // set the contact state + bool setContact(bool _contactState); + // returns the contact state + bool getContact() { + return contactState; + } + + // bool conversion operator + void operator=(bool _contactState) { + setContact(_contactState); + } + // bool conversion operator + operator bool() { + return getContact(); + } + + // 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 contactState = false; +}; +#endif /* CONFIG_ESP_MATTER_ENABLE_DATA_MODEL */