feat(matter): creates a matter contact sensor endpoint

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

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 <Matter.h>
+#include <WiFi.h>
+
+// 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);
+}

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"
+  ]
+}

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)

libraries/Matter/src/Matter.h

@@ -28,6 +28,7 @@
 #include <MatterEndpoints/MatterFan.h>
 #include <MatterEndpoints/MatterTemperatureSensor.h>
 #include <MatterEndpoints/MatterHumiditySensor.h>
+#include <MatterEndpoints/MatterContactSensor.h>
 
 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();

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 <sdkconfig.h>
+#ifdef CONFIG_ESP_MATTER_ENABLE_DATA_MODEL
+
+#include <Matter.h>
+#include <app/server/Server.h>
+#include <MatterEndpoints/MatterContactSensor.h>
+
+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 */

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 <sdkconfig.h>
+#ifdef CONFIG_ESP_MATTER_ENABLE_DATA_MODEL
+
+#include <Matter.h>
+#include <MatterEndPoint.h>
+
+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 */