applications: Matter Bridge: added BLE environmental sensor support

* Added implementation of the BLE data provider which supports
  subscription to the humidity and temperature characteristics.
* implemented one provider to many Matter devices relation
* updated README

Signed-off-by: Marcin Kajor <marcin.kajor@nordicsemi.no>

applications/matter_bridge/CMakeLists.txt

@@ -44,7 +44,7 @@ target_sources(app PRIVATE
     src/main.cpp
     src/bridge_shell.cpp
     ${COMMON_ROOT}/src/bridge/bridge_manager.cpp
-    ${COMMON_ROOT}/src/bridge/bridged_device.cpp
+    ${COMMON_ROOT}/src/bridge/matter_bridged_device.cpp
     ${COMMON_ROOT}/src/bridge/bridge_storage_manager.cpp
     ${COMMON_ROOT}/src/bridge/bridged_device_data_provider.cpp
     src/zap-generated/IMClusterCommandHandler.cpp
@@ -63,6 +63,25 @@ if(CONFIG_BRIDGE_ONOFF_LIGHT_BRIDGED_DEVICE)
     )
 endif() # CONFIG_BRIDGE_ONOFF_LIGHT_BRIDGED_DEVICE
 
+if(CONFIG_BRIDGE_HUMIDITY_SENSOR_BRIDGED_DEVICE)
+    target_sources(app PRIVATE
+        src/bridged_device_types/humidity_sensor.cpp
+    )
+endif() # CONFIG_BRIDGE_HUMIDITY_SENSOR_BRIDGED_DEVICE
+
+if(CONFIG_BRIDGE_TEMPERATURE_SENSOR_BRIDGED_DEVICE)
+    target_sources(app PRIVATE
+        src/bridged_device_types/temperature_sensor.cpp
+    )
+endif() # CONFIG_BRIDGE_TEMPERATURE_SENSOR_BRIDGED_DEVICE
+
+# Assume it makes no sense to support BLE environmental sensor without all Matter counterparts
+if(CONFIG_BRIDGE_TEMPERATURE_SENSOR_BRIDGED_DEVICE AND CONFIG_BRIDGE_HUMIDITY_SENSOR_BRIDGED_DEVICE)
+    target_sources(app PRIVATE
+        src/bridged_device_types/ble_environmental_data_provider.cpp
+    )
+endif() # CONFIG_BRIDGE_TEMPERATURE_SENSOR_BRIDGED_DEVICE AND CONFIG_BRIDGE_HUMIDITY_SENSOR_BRIDGED_DEVICE
+
 else()
 if(CONFIG_BRIDGE_ONOFF_LIGHT_BRIDGED_DEVICE)
     target_sources(app PRIVATE

applications/matter_bridge/Kconfig

@@ -11,11 +11,11 @@ config BRIDGE_ONOFF_LIGHT_BRIDGED_DEVICE
 
 config BRIDGE_TEMPERATURE_SENSOR_BRIDGED_DEVICE
 	bool "Support for Temperature Sensor bridged device"
-	default y if BRIDGED_DEVICE_SIMULATED
+	default y
 
 config BRIDGE_HUMIDITY_SENSOR_BRIDGED_DEVICE
 	bool "Support for Humidity Sensor bridged device"
-	default y if BRIDGED_DEVICE_SIMULATED
+	default y
 
 choice BRIDGED_DEVICE_IMPLEMENTATION
 	prompt "Bridged Device implementation"
@@ -53,14 +53,18 @@ config BT_SCAN_FILTER_ENABLE
 
 # Configure how many Bluetooth LE service UUIDs the Matter bridge can scan.
 config BT_SCAN_UUID_CNT
-	default 1
+	default 2
 
 config BT_GATT_CLIENT
 	default y
 
 config BT_GATT_DM
 	default y
 
+config BRIDGE_BLE_DEVICE_POLLING_INTERVAL
+	int "BLE humidity measurement readout polling interval in ms"
+	default 3000
+
 endif
 
 if BRIDGE_TEMPERATURE_SENSOR_BRIDGED_DEVICE

applications/matter_bridge/README.rst

@@ -23,8 +23,12 @@ The application supports the following development kits:
 
 To test the Matter bridge application with the :ref:`Bluetooth LE bridged device <matter_bridge_app_bridged_support>`, you also need the following:
 
-* An additional development kit compatible with the :ref:`peripheral_lbs` sample.
-* A micro USB cable to connect the development kit to the PC.
+* An additional development kit compatible with one of the following Bluetooth LE samples:
+
+  * :ref:`peripheral_lbs`
+  * :ref:`peripheral_esp`
+
+* A micro-USB cable to connect the development kit to the PC.
 
 To commission the Matter bridge device and control it remotely through a Wi-Fi network, you also need a Matter controller device :ref:`configured on PC or smartphone <ug_matter_configuring>`.
 This requires additional hardware depending on your setup.
@@ -182,6 +186,7 @@ Adding a Bluetooth LE bridged device to the Matter bridge
      The argument is mandatory and accepts the following values:
 
      * ``256`` - On/Off Light.
+     * ``291`` - Environmental Sensor (a combination of Temperature Sensor and Humidity Sensor).
 
    * *<ble_device_index>* is the Bluetooth LE device index on the list returned by the ``scan`` command.
      The argument is mandatory and accepts only the values returned by the ``scan`` command.
@@ -329,8 +334,12 @@ After building the sample and programming it to your development kit, complete t
 
       .. group-tab:: Testing with Bluetooth LE bridged devices
 
-         a. Build and program the :ref:`peripheral_lbs` sample to an additional development kit compatible with the sample.
-         #. Connect the development kit that is running the :ref:`peripheral_lbs` sample to the PC.
+         a. Build and program the one of the following Bluetooth LE samples to an additional development kit compatible with the sample:
+
+            * :ref:`peripheral_lbs`
+            * :ref:`peripheral_esp`
+
+         #. Connect the development kit that is running the Bluetooth LE sample to the PC.
          #. Using the terminal emulator connected to the bridge, run the following :ref:`Matter CLI command <matter_bridge_cli>` to scan for available Bluetooth LE devices:
 
             .. code-block:: console
@@ -373,6 +382,8 @@ After building the sample and programming it to your development kit, complete t
                I: Adding OnOff Light bridged device
                I: Added device to dynamic endpoint 3 (index=0)
 
+            For the Environmental Sensor, two endpoints are created: one implements the Temperature Sensor, and the other implements the Humidity Sensor.
+
          #. Write down the value for the bridged device dynamic endpoint ID.
             This is going to be used in the next steps (*<bridged_device_endpoint_ID>*).
          #. Use the :doc:`CHIP Tool <matter:chip_tool_guide>` to read the value of an attribute from the bridged device endpoint.
@@ -383,6 +394,22 @@ After building the sample and programming it to your development kit, complete t
 
                ./chip-tool onoff read on-off *<bridge_node_ID>* *<bridged_device_endpoint_ID>*
 
+            In case of the Environmental Sensor, the current temperature and humidity measurements forwarded by the Bluetooth LE Environmental Sensor can be read as follows:
+
+              * temperature:
+
+                .. parsed-literal::
+                   :class: highlight
+
+                   ./chip-tool temperaturemeasurement read measured-value *<bridge_node_ID>* *<bridged_device_endpoint_ID>*
+
+              * humidity:
+
+                .. parsed-literal::
+                   :class: highlight
+
+                    ./chip-tool relativehumiditymeasurement read measured-value *<bridge_node_ID>* *<bridged_device_endpoint_ID>*
+
 Enabling remote control
 =======================
 

applications/matter_bridge/src/app_task.cpp

@@ -61,7 +61,8 @@ bool sHaveBLEConnections = false;
 
 #ifdef CONFIG_BRIDGED_DEVICE_BT
 static bt_uuid *sUuidLbs = BT_UUID_LBS;
-static bt_uuid *sUuidServices[] = { sUuidLbs };
+static bt_uuid *sUuidEs = BT_UUID_ESS;
+static bt_uuid *sUuidServices[] = { sUuidLbs, sUuidEs };
 static constexpr uint8_t kUuidServicesNumber = ARRAY_SIZE(sUuidServices);
 #endif /* CONFIG_BRIDGED_DEVICE_BT */
 

applications/matter_bridge/src/bridge_shell.cpp

@@ -21,44 +21,66 @@ LOG_MODULE_DECLARE(app, CONFIG_CHIP_APP_LOG_LEVEL);
 static BridgedDeviceDataProvider *CreateSimulatedProvider(int deviceType)
 {
 	return BridgeFactory::GetSimulatedDataProviderFactory().Create(
-		static_cast<BridgedDevice::DeviceType>(deviceType), BridgeManager::HandleUpdate);
+		static_cast<MatterBridgedDevice::DeviceType>(deviceType), BridgeManager::HandleUpdate);
 }
 #endif /* CONFIG_BRIDGED_DEVICE_SIMULATED */
 
 #ifdef CONFIG_BRIDGED_DEVICE_BT
 
 static BridgedDeviceDataProvider *CreateBleProvider(int deviceType)
 {
-	return BridgeFactory::GetBleDataProviderFactory().Create(static_cast<BridgedDevice::DeviceType>(deviceType),
-								 BridgeManager::HandleUpdate);
+	return BridgeFactory::GetBleDataProviderFactory().Create(
+		static_cast<MatterBridgedDevice::DeviceType>(deviceType), BridgeManager::HandleUpdate);
 }
 
 struct BluetoothConnectionContext {
 	const struct shell *shell;
 	int deviceType;
-	char nodeLabel[BridgedDevice::kNodeLabelSize];
+	char nodeLabel[MatterBridgedDevice::kNodeLabelSize];
 	BLEBridgedDeviceProvider *provider;
 };
 #endif /* CONFIG_BRIDGED_DEVICE_BT */
 
 static void AddDevice(const struct shell *shell, int deviceType, const char *nodeLabel,
 		      BridgedDeviceDataProvider *provider)
 {
-	VerifyOrReturn(provider != nullptr,
-		       shell_fprintf(shell, SHELL_INFO, "Cannot allocate data provider of given type\n"));
+	VerifyOrReturn(provider != nullptr, shell_fprintf(shell, SHELL_INFO, "No valid data provider!\n"));
 
-	auto *newBridgedDevice = BridgeFactory::GetBridgedDeviceFactory().Create(
-		static_cast<BridgedDevice::DeviceType>(deviceType), nodeLabel);
+	CHIP_ERROR err;
+	if (deviceType == MatterBridgedDevice::DeviceType::EnvironmentalSensor) {
+		/* Handle special case for environmental sensor */
+		auto *temperatureBridgedDevice = BridgeFactory::GetBridgedDeviceFactory().Create(
+			MatterBridgedDevice::DeviceType::TemperatureSensor, nodeLabel);
 
-	VerifyOrReturn(newBridgedDevice != nullptr, delete provider,
-		       shell_fprintf(shell, SHELL_INFO, "Cannot allocate Matter device of given type\n"));
+		VerifyOrReturn(temperatureBridgedDevice != nullptr, delete provider,
+			       shell_fprintf(shell, SHELL_INFO, "Cannot allocate Matter device of given type\n"));
+
+		auto *humidityBridgedDevice = BridgeFactory::GetBridgedDeviceFactory().Create(
+			MatterBridgedDevice::DeviceType::HumiditySensor, nodeLabel);
+
+		VerifyOrReturn(humidityBridgedDevice != nullptr, delete provider, delete temperatureBridgedDevice,
+			       shell_fprintf(shell, SHELL_INFO, "Cannot allocate Matter device of given type\n"));
+
+		MatterBridgedDevice *newBridgedDevices[] = { temperatureBridgedDevice, humidityBridgedDevice };
+		err = BridgeManager::Instance().AddBridgedDevices(newBridgedDevices, provider,
+								  ARRAY_SIZE(newBridgedDevices));
+
+	} else {
+		auto *newBridgedDevice = BridgeFactory::GetBridgedDeviceFactory().Create(
+			static_cast<MatterBridgedDevice::DeviceType>(deviceType), nodeLabel);
+
+		MatterBridgedDevice *newBridgedDevices[] = { newBridgedDevice };
+		VerifyOrReturn(newBridgedDevice != nullptr, delete provider,
+			       shell_fprintf(shell, SHELL_INFO, "Cannot allocate Matter device of given type\n"));
+		err = BridgeManager::Instance().AddBridgedDevices(newBridgedDevices, provider,
+								  ARRAY_SIZE(newBridgedDevices));
+	}
 
-	CHIP_ERROR err = BridgeManager::Instance().AddBridgedDevices(newBridgedDevice, provider);
 	if (err == CHIP_NO_ERROR) {
 		shell_fprintf(shell, SHELL_INFO, "Done\n");
 	} else if (err == CHIP_ERROR_INVALID_STRING_LENGTH) {
 		shell_fprintf(shell, SHELL_ERROR, "Error: too long node label (max %d)\n",
-			      BridgedDevice::kNodeLabelSize);
+			      MatterBridgedDevice::kNodeLabelSize);
 	} else if (err == CHIP_ERROR_NO_MEMORY) {
 		shell_fprintf(shell, SHELL_ERROR, "Error: no memory\n");
 	} else if (err == CHIP_ERROR_INVALID_ARGUMENT) {
@@ -119,6 +141,7 @@ static int AddBridgedDeviceHandler(const struct shell *shell, size_t argc, char
 	BridgedDeviceDataProvider *provider = CreateBleProvider(contextPtr->deviceType);
 
 	if (!provider) {
+		shell_fprintf(shell, SHELL_INFO, "Cannot allocate data provider of given type\n");
 		return -ENOMEM;
 	}
 
@@ -193,13 +216,14 @@ static int ScanBridgedDeviceHandler(const struct shell *shell, size_t argc, char
 SHELL_STATIC_SUBCMD_SET_CREATE(
 	sub_matter_bridge,
 #ifdef CONFIG_BRIDGED_DEVICE_BT
-	SHELL_CMD_ARG(add, NULL,
-		      "Adds bridged device. \n"
-		      "Usage: add <bridged_device_type> <ble_device_index> [node_label]\n"
-		      "* bridged_device_type - the bridged device's type, e.g. 256 - OnOff Light\n"
-		      "* ble_device_index - the Bluetooth LE device's index on the list returned by the scan command\n"
-		      "* node_label - the optional bridged device's node label\n",
-		      AddBridgedDeviceHandler, 3, 1),
+	SHELL_CMD_ARG(
+		add, NULL,
+		"Adds bridged device. \n"
+		"Usage: add <bridged_device_type> <ble_device_index> [node_label]\n"
+		"* bridged_device_type - the bridged device's type, e.g. 256 - OnOff Light, 291 - EnvironmentalSensor\n"
+		"* ble_device_index - the Bluetooth LE device's index on the list returned by the scan command\n"
+		"* node_label - the optional bridged device's node label\n",
+		AddBridgedDeviceHandler, 3, 1),
 #else
 	SHELL_CMD_ARG(
 		add, NULL,

applications/matter_bridge/src/bridged_device_factory.h

@@ -7,8 +7,8 @@
 #pragma once
 
 #include "bridge_util.h"
-#include "bridged_device.h"
 #include "bridged_device_data_provider.h"
+#include "matter_bridged_device.h"
 #include <lib/support/CHIPMem.h>
 
 #ifdef CONFIG_BRIDGE_HUMIDITY_SENSOR_BRIDGED_DEVICE
@@ -35,11 +35,17 @@
 #endif
 #endif
 
+#ifdef CONFIG_BRIDGED_DEVICE_BT
+#if defined(CONFIG_BRIDGE_HUMIDITY_SENSOR_BRIDGED_DEVICE) && defined(CONFIG_BRIDGE_TEMPERATURE_SENSOR_BRIDGED_DEVICE)
+#include "ble_environmental_data_provider.h"
+#endif
+#endif
+
 namespace BridgeFactory
 {
 using UpdateAttributeCallback = BridgedDeviceDataProvider::UpdateAttributeCallback;
-using DeviceType = BridgedDevice::DeviceType;
-using BridgedDeviceFactory = DeviceFactory<BridgedDevice, const char *>;
+using DeviceType = MatterBridgedDevice::DeviceType;
+using BridgedDeviceFactory = DeviceFactory<MatterBridgedDevice, const char *>;
 
 #ifdef CONFIG_BRIDGED_DEVICE_SIMULATED
 using SimulatedDataProviderFactory = DeviceFactory<BridgedDeviceDataProvider, UpdateAttributeCallback>;
@@ -51,7 +57,7 @@ using BleDataProviderFactory = DeviceFactory<BridgedDeviceDataProvider, UpdateAt
 
 auto checkLabel = [](const char *nodeLabel) {
 	/* If node label is provided it must fit the maximum defined length */
-	if (!nodeLabel || (nodeLabel && (strlen(nodeLabel) < BridgedDevice::kNodeLabelSize))) {
+	if (!nodeLabel || (nodeLabel && (strlen(nodeLabel) < MatterBridgedDevice::kNodeLabelSize))) {
 		return true;
 	}
 	return false;
@@ -62,7 +68,7 @@ inline BridgedDeviceFactory &GetBridgedDeviceFactory()
 	static BridgedDeviceFactory sBridgedDeviceFactory{
 #ifdef CONFIG_BRIDGE_HUMIDITY_SENSOR_BRIDGED_DEVICE
 		{ DeviceType::HumiditySensor,
-		  [](const char *nodeLabel) -> BridgedDevice * {
+		  [](const char *nodeLabel) -> MatterBridgedDevice * {
 			  if (!checkLabel(nodeLabel)) {
 				  return nullptr;
 			  }
@@ -71,16 +77,16 @@ inline BridgedDeviceFactory &GetBridgedDeviceFactory()
 #endif
 #ifdef CONFIG_BRIDGE_ONOFF_LIGHT_BRIDGED_DEVICE
 		{ DeviceType::OnOffLight,
-		  [](const char *nodeLabel) -> BridgedDevice * {
+		  [](const char *nodeLabel) -> MatterBridgedDevice * {
 			  if (!checkLabel(nodeLabel)) {
 				  return nullptr;
 			  }
 			  return chip::Platform::New<OnOffLightDevice>(nodeLabel);
 		  } },
 #endif
 #ifdef CONFIG_BRIDGE_TEMPERATURE_SENSOR_BRIDGED_DEVICE
-		{ BridgedDevice::DeviceType::TemperatureSensor,
-		  [](const char *nodeLabel) -> BridgedDevice * {
+		{ MatterBridgedDevice::DeviceType::TemperatureSensor,
+		  [](const char *nodeLabel) -> MatterBridgedDevice * {
 			  if (!checkLabel(nodeLabel)) {
 				  return nullptr;
 			  }
@@ -121,10 +127,16 @@ inline SimulatedDataProviderFactory &GetSimulatedDataProviderFactory()
 #ifdef CONFIG_BRIDGED_DEVICE_BT
 inline BleDataProviderFactory &GetBleDataProviderFactory()
 {
-	static BleDataProviderFactory sDeviceDataProvider{
+	static BleDataProviderFactory sDeviceDataProvider
+	{
 #ifdef CONFIG_BRIDGE_ONOFF_LIGHT_BRIDGED_DEVICE
 		{ DeviceType::OnOffLight,
 		  [](UpdateAttributeCallback clb) { return chip::Platform::New<BleOnOffLightDataProvider>(clb); } },
+#endif
+#if defined(CONFIG_BRIDGE_TEMPERATURE_SENSOR_BRIDGED_DEVICE) && defined(CONFIG_BRIDGE_HUMIDITY_SENSOR_BRIDGED_DEVICE)
+			{ DeviceType::EnvironmentalSensor, [](UpdateAttributeCallback clb) {
+				 return chip::Platform::New<BleEnvironmentalDataProvider>(clb);
+			 } },
 #endif
 	};
 	return sDeviceDataProvider;