espressif/esp-matter
1
0
Fork 0
mirror of https://github.com/espressif/esp-matter.git synced 2026-04-27 19:13:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'update_submodule/matter_1.4.2' into 'main'

Browse Source 
connectedhomeip: Update the submodule to latest v1.4.2-branch.

See merge request app-frameworks/esp-matter!1223
This commit is contained in:
Hrishikesh Dhayagude
2025-08-22 13:36:21 +08:00
parent d4bfc446ac 4500815659
commit ca3df4f11f
167 changed files with 549 additions and 3318 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitlab-ci.yml
+1 -1
View File
@@ -28,7 +28,7 @@ variables:
IDF_CHECKOUT_REF: "v5.4.1"
# This variable represents the short hash of the connectedhomeip submodule.
# Note: Do change this short hash on submodule update MRs.
CHIP_SHORT_HASH: "d144bbbaae"
CHIP_SHORT_HASH: "320b9a6f6c"
DOCKER_IMAGE_NAME: "espressif/chip-idf"
.add_gitlab_ssh_key: &add_gitlab_ssh_key |
README.md
+1 -1
View File
@@ -28,7 +28,7 @@ section in the ESP-Matter Programming Guide.
## Supported ESP-IDF and connectedhomeip versions
- This SDK currently works with commit [d144bbbaae] (https://github.com/project-chip/connectedhomeip/tree/d144bbbaae) of connectedhomeip.
- This SDK currently works with commit [320b9a6f6c] (https://github.com/project-chip/connectedhomeip/tree/320b9a6f66) of connectedhomeip.
- For Matter projects development with this SDK, it is recommended to utilize ESP-IDF [v5.4.1](https://github.com/espressif/esp-idf/tree/v5.4.1).
- For ESP32C5, it is recommended to utilize ESP-IDF [98cd765953](https://github.com/espressif/esp-idf/commit/98cd765953dfe0e7bb1c5df8367e1b54bd966cce).
components/esp_matter/CMakeLists.txt
+11
View File
@@ -11,6 +11,7 @@ set(INCLUDE_DIRS_LIST "."
# TODO: This file has compilation errors
set(EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/closure-control-server/closure-control-server.cpp")
list(APPEND EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/general-commissioning-server/TemporaryTestCoupling.cpp")
if (CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER)
list(APPEND SRC_DIRS_LIST "${MATTER_SDK_PATH}/src/app/server"
@@ -36,6 +37,14 @@ if (CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER)
"private")
list(APPEND INCLUDE_DIRS_LIST "zap_common"
"data_model")
list(APPEND EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/software-diagnostics-server/CodegenIntegration.cpp")
list(APPEND EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/administrator-commissioning-server/CodegenIntegration.cpp")
list(APPEND EXCLUDE_SRCS_LIST "${MATTER_SDK_PATH}/src/app/clusters/ota-provider/CodegenIntegration.cpp")
if(NOT CONFIG_SUPPORT_SOFTWARE_DIAGNOSTICS_CLUSTER)
list(APPEND EXCLUDE_SRCS_LIST "data_model/software_diagnostics_codegen_integration.cpp")
endif()
endif(CONFIG_ESP_MATTER_ENABLE_DATA_MODEL)
else()
list(APPEND EXCLUDE_SRCS_LIST "esp_matter_identify.cpp"
@@ -43,6 +52,8 @@ else()
"esp_matter_attribute_utils.cpp")
endif(CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER)
set(REQUIRES_LIST chip bt esp_matter_console nvs_flash app_update esp_secure_cert_mgr mbedtls esp_system openthread json)
idf_component_register( SRC_DIRS ${SRC_DIRS_LIST}
components/esp_matter/data_model/administrator_commissioning_codegen_integration.cpp
+79
View File
@@ -0,0 +1,79 @@
// 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 <app/clusters/administrator-commissioning-server/AdministratorCommissioningCluster.h>
#include <data-model-providers/codegen/CodegenDataModelProvider.h>
#include <app-common/zap-generated/attributes/Accessors.h>
#include <app/util/attribute-storage.h>
using namespace chip;
using namespace chip::app;
using namespace chip::app::Clusters;
using namespace chip::app::Clusters::AdministratorCommissioning::Attributes;
using chip::Protocols::InteractionModel::Status;
namespace {
// AdministratorCommissioningCluster implementation is specifically implemented
// only for the root endpoint (endpoint 0)
// So either:
// - we have a fixed config and it is endpoint 0 OR
// - we have a fully dynamic config
static constexpr size_t kAdministratorCommissioningFixedClusterCount = 0;
using ClusterImpl = AdministratorCommissioningWithBasicCommissioningWindowCluster;
LazyRegisteredServerCluster<ClusterImpl> gServer;
} // namespace
void emberAfAdministratorCommissioningClusterInitCallback(EndpointId endpointId)
{
if (endpointId != kRootEndpointId)
{
return;
}
uint32_t rawFeatureMap;
if (FeatureMap::Get(endpointId, &rawFeatureMap) != Status::Success)
{
ChipLogError(AppServer, "Failed to get feature map for endpoint %u", endpointId);
rawFeatureMap = 0;
}
gServer.Create(endpointId, BitFlags<AdministratorCommissioning::Feature>(rawFeatureMap));
CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Register(gServer.Registration());
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Admin Commissioning register error: endpoint %u, %" CHIP_ERROR_FORMAT, endpointId, err.Format());
}
}
void emberAfAdministratorCommissioningClusterShutdownCallback(EndpointId endpointId)
{
if (endpointId != kRootEndpointId)
{
return;
}
CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Unregister(&gServer.Cluster());
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Admin Commissioning unregister error: endpoint %u, %" CHIP_ERROR_FORMAT, endpointId, err.Format());
}
gServer.Destroy();
}
void MatterAdministratorCommissioningPluginServerInitCallback() {}
void MatterAdministratorCommissioningPluginServerShutdownCallback() {}
components/esp_matter/data_model/esp_matter_attribute.cpp
+22 -2
View File
@@ -297,6 +297,13 @@ attribute_t *create_max_paths_per_invoke(cluster_t *cluster, uint16_t value)
esp_matter_uint16(value));
}
attribute_t *create_configuration_version(cluster_t *cluster, uint32_t value)
{
return esp_matter::attribute::create(cluster, BasicInformation::Attributes::ConfigurationVersion::Id,
ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_uint32(value));
}
} /* attribute */
} /* basic_information */
@@ -958,7 +965,7 @@ attribute_t *create_detached_role_count(cluster_t *cluster, uint16_t value)
ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_uint16(value));
}
attribute_t *create_chlid_role_count(cluster_t *cluster, uint16_t value)
attribute_t *create_child_role_count(cluster_t *cluster, uint16_t value)
{
return esp_matter::attribute::create(cluster, ThreadNetworkDiagnostics::Attributes::ChildRoleCount::Id,
ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_uint16(value));
@@ -1388,6 +1395,12 @@ attribute_t *create_product_appearance(cluster_t *cluster, uint8_t *value, uint1
ATTRIBUTE_FLAG_NONE, esp_matter_array(value, length, count));
}
attribute_t *create_configuration_version(cluster_t *cluster, uint32_t value)
{
return esp_matter::attribute::create(cluster, BridgedDeviceBasicInformation::Attributes::ConfigurationVersion::Id,
ATTRIBUTE_FLAG_MANAGED_INTERNALLY, esp_matter_uint32(value));
}
} /* attribute */
} /* bridged_device_basic_information */
@@ -2758,7 +2771,7 @@ attribute_t *create_auto_relock_time(cluster_t *cluster, uint32_t value)
esp_matter_uint32(value));
}
attribute_t *create_sound_valume(cluster_t *cluster, uint8_t value)
attribute_t *create_sound_volume(cluster_t *cluster, uint8_t value)
{
return esp_matter::attribute::create(cluster, DoorLock::Attributes::SoundVolume::Id, ATTRIBUTE_FLAG_WRITABLE,
esp_matter_enum8(value));
@@ -3333,6 +3346,13 @@ attribute_t *create_temperature_unit(cluster_t *cluster, uint8_t value)
ATTRIBUTE_FLAG_WRITABLE | ATTRIBUTE_FLAG_NONVOLATILE,
esp_matter_enum8(value));
}
attribute_t *create_supported_temperature_units(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count)
{
return esp_matter::attribute::create(cluster, UnitLocalization::Attributes::SupportedTemperatureUnits::Id, ATTRIBUTE_FLAG_MANAGED_INTERNALLY,
esp_matter_array(value, length, count));
}
} /* attribute */
} /* unit_localization */
components/esp_matter/data_model/esp_matter_attribute.h
+7 -2
View File
@@ -86,6 +86,7 @@ attribute_t *create_unique_id(cluster_t *cluster, char *value, uint16_t length);
attribute_t *create_capability_minima(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count);
attribute_t *create_specification_version(cluster_t *cluster, uint32_t value);
attribute_t *create_max_paths_per_invoke(cluster_t *cluster, uint16_t value);
attribute_t *create_configuration_version(cluster_t *cluster, uint32_t value);
/** These attributes are optional for the cluster, but when added to this cluster, the value is maintained internally.
* If the attributes are added in some other cluster, then the value is not maintained internally.
@@ -259,7 +260,7 @@ attribute_t *create_ext_address(cluster_t *cluster, nullable<uint64_t> value);
attribute_t *create_rloc16(cluster_t *cluster, nullable<uint16_t> value);
attribute_t *create_overrun_count(cluster_t *cluster, uint64_t value);
attribute_t *create_detached_role_count(cluster_t *cluster, uint16_t value);
attribute_t *create_chlid_role_count(cluster_t *cluster, uint16_t value);
attribute_t *create_child_role_count(cluster_t *cluster, uint16_t value);
attribute_t *create_router_role_count(cluster_t *cluster, uint16_t value);
attribute_t *create_leader_role_count(cluster_t *cluster, uint16_t value);
attribute_t *create_attach_attempt_count(cluster_t *cluster, uint16_t value);
@@ -355,6 +356,8 @@ attribute_t *create_serial_number(cluster_t *cluster, char *value, uint16_t leng
attribute_t *create_reachable(cluster_t *cluster, bool value);
attribute_t *create_unique_id(cluster_t *cluster, char *value, uint16_t length);
attribute_t *create_product_appearance(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count);
attribute_t *create_configuration_version(cluster_t *cluster, uint32_t *value);
} /* attribute */
} /* bridged_device_basic_information */
@@ -667,7 +670,7 @@ attribute_t *create_number_of_credentials_supported_per_user(cluster_t *cluster,
attribute_t *create_language(cluster_t *cluster, const char * value, uint16_t length);
attribute_t *create_led_settings(cluster_t *cluster, uint8_t value);
attribute_t *create_auto_relock_time(cluster_t *cluster, uint32_t value);
attribute_t *create_sound_valume(cluster_t *cluster, uint8_t value);
attribute_t *create_sound_volume(cluster_t *cluster, uint8_t value);
attribute_t *create_operating_mode(cluster_t *cluster, uint8_t value, uint8_t min, uint8_t max);
attribute_t *create_supported_operating_modes(cluster_t *cluster, const uint16_t value);
attribute_t *create_default_configuration_register(cluster_t *cluster, uint16_t value);
@@ -830,6 +833,8 @@ attribute_t *create_supported_locales(cluster_t *cluster, uint8_t *value, uint16
namespace unit_localization {
namespace attribute {
attribute_t *create_temperature_unit(cluster_t *cluster, uint8_t value);
attribute_t *create_supported_temperature_units(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count);
} /* attribute */
} /* unit_localization */
components/esp_matter/data_model/esp_matter_cluster.cpp
+1
View File
@@ -240,6 +240,7 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
attribute::create_capability_minima(cluster, NULL, 0, 0);
attribute::create_specification_version(cluster, 0);
attribute::create_max_paths_per_invoke(cluster, 0);
attribute::create_configuration_version(cluster, 0);
/* Attributes not managed internally */
global::attribute::create_cluster_revision(cluster, cluster_revision);
components/esp_matter/data_model/esp_matter_command.cpp
+49 -17
View File
@@ -94,7 +94,9 @@ static esp_err_t esp_matter_command_callback_key_set_write(const ConcreteCommand
void *opaque_ptr)
{
chip::app::Clusters::GroupKeyManagement::Commands::KeySetWrite::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupKeyManagementClusterKeySetWriteCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -105,7 +107,9 @@ static esp_err_t esp_matter_command_callback_key_set_read(const ConcreteCommandP
void *opaque_ptr)
{
chip::app::Clusters::GroupKeyManagement::Commands::KeySetRead::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupKeyManagementClusterKeySetReadCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -116,7 +120,9 @@ static esp_err_t esp_matter_command_callback_key_set_remove(const ConcreteComman
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::GroupKeyManagement::Commands::KeySetRemove::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupKeyManagementClusterKeySetRemoveCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -127,7 +133,9 @@ static esp_err_t esp_matter_command_callback_key_set_read_all_indices(const Conc
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndices::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupKeyManagementClusterKeySetReadAllIndicesCallback((CommandHandler *)opaque_ptr, command_path,
command_data);
@@ -186,7 +194,9 @@ static esp_err_t esp_matter_command_callback_update_noc(const ConcreteCommandPat
void *opaque_ptr)
{
chip::app::Clusters::OperationalCredentials::Commands::UpdateNOC::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfOperationalCredentialsClusterUpdateNOCCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -197,7 +207,9 @@ static esp_err_t esp_matter_command_callback_update_fabric_label(const ConcreteC
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::OperationalCredentials::Commands::UpdateFabricLabel::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfOperationalCredentialsClusterUpdateFabricLabelCallback((CommandHandler *)opaque_ptr, command_path,
command_data);
@@ -234,7 +246,9 @@ static esp_err_t esp_matter_command_callback_set_vid_verification_statement(cons
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::OperationalCredentials::Commands::SetVIDVerificationStatement::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfOperationalCredentialsClusterSetVIDVerificationStatementCallback((CommandHandler *)opaque_ptr,
command_path, command_data);
@@ -294,7 +308,9 @@ static esp_err_t esp_matter_command_callback_add_group(const ConcreteCommandPath
void *opaque_ptr)
{
chip::app::Clusters::Groups::Commands::AddGroup::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupsClusterAddGroupCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -305,7 +321,9 @@ static esp_err_t esp_matter_command_callback_view_group(const ConcreteCommandPat
void *opaque_ptr)
{
chip::app::Clusters::Groups::Commands::ViewGroup::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupsClusterViewGroupCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -316,7 +334,9 @@ static esp_err_t esp_matter_command_callback_get_group_membership(const Concrete
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::Groups::Commands::GetGroupMembership::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupsClusterGetGroupMembershipCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -327,7 +347,9 @@ static esp_err_t esp_matter_command_callback_remove_group(const ConcreteCommandP
void *opaque_ptr)
{
chip::app::Clusters::Groups::Commands::RemoveGroup::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupsClusterRemoveGroupCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -338,7 +360,9 @@ static esp_err_t esp_matter_command_callback_remove_all_groups(const ConcreteCom
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::Groups::Commands::RemoveAllGroups::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupsClusterRemoveAllGroupsCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -349,7 +373,9 @@ static esp_err_t esp_matter_command_callback_add_group_if_identifying(const Conc
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::Groups::Commands::AddGroupIfIdentifying::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfGroupsClusterAddGroupIfIdentifyingCallback((CommandHandler *)opaque_ptr, command_path, command_data);
}
@@ -360,7 +386,9 @@ static esp_err_t esp_matter_command_callback_register_client(const ConcreteComma
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::IcdManagement::Commands::RegisterClient::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
#if CONFIG_ENABLE_ICD_SERVER
emberAfIcdManagementClusterRegisterClientCallback((CommandHandler *)opaque_ptr, command_path, command_data);
@@ -373,7 +401,9 @@ static esp_err_t esp_matter_command_callback_unregister_client(const ConcreteCom
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::IcdManagement::Commands::UnregisterClient::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
#if CONFIG_ENABLE_ICD_SERVER
emberAfIcdManagementClusterUnregisterClientCallback((CommandHandler *)opaque_ptr, command_path, command_data);
@@ -1426,7 +1456,9 @@ static esp_err_t esp_matter_command_callback_set_trusted_time_source(const Concr
TLVReader &tlv_data, void *opaque_ptr)
{
chip::app::Clusters::TimeSynchronization::Commands::SetTrustedTimeSource::DecodableType command_data;
CHIP_ERROR error = Decode(tlv_data, command_data);
chip::app::CommandHandler *command_obj = (chip::app::CommandHandler *)opaque_ptr;
CHIP_ERROR error = command_data.Decode(tlv_data, command_obj->GetAccessingFabricIndex());
if (error == CHIP_NO_ERROR) {
emberAfTimeSynchronizationClusterSetTrustedTimeSourceCallback((CommandHandler *)opaque_ptr, command_path,
command_data);
@@ -2836,7 +2868,7 @@ command_t *create_reset_condition(cluster_t *cluster)
namespace mode_base {
namespace command {
// command response is null because of InvokeCommandHandler is overriden in srs/app/clusters/mode-base
// command response is null because of InvokeCommandHandler is overridden in srs/app/clusters/mode-base
command_t *create_change_to_mode(cluster_t *cluster)
{
return esp_matter::command::create(cluster, ModeBase::Commands::ChangeToMode::Id, COMMAND_FLAG_ACCEPTED, NULL);
components/esp_matter/data_model/esp_matter_endpoint.cpp
+3 -2
View File
@@ -330,6 +330,7 @@ esp_err_t add(endpoint_t *endpoint, config_t *config)
cluster_t *identify_cluster = identify::create(endpoint, &(config->identify), CLUSTER_FLAG_SERVER);
identify::command::create_trigger_effect(identify_cluster);
groups::create(endpoint, &(config->groups), CLUSTER_FLAG_SERVER);
scenes_management::create(endpoint, &(config->scenes_management), CLUSTER_FLAG_SERVER);
cluster_t *on_off_cluster = on_off::create(endpoint, &(config->on_off), CLUSTER_FLAG_SERVER);
on_off::feature::lighting::add(on_off_cluster, &(config->on_off_lighting));
on_off::command::create_on(on_off_cluster);
@@ -1343,12 +1344,12 @@ namespace robotic_vacuum_cleaner {
uint32_t get_device_type_id()
{
return ESP_MATTER_ROBOTIC_VACCUM_CLEANER_DEVICE_TYPE_ID;
return ESP_MATTER_ROBOTIC_VACUUM_CLEANER_DEVICE_TYPE_ID;
}
uint8_t get_device_type_version()
{
return ESP_MATTER_ROBOTIC_VACCUM_CLEANER_DEVICE_TYPE_VERSION;
return ESP_MATTER_ROBOTIC_VACUUM_CLEANER_DEVICE_TYPE_VERSION;
}
endpoint_t *create(node_t *node, config_t *config, uint8_t flags, void *priv_data)
components/esp_matter/data_model/esp_matter_endpoint.h
+4 -2
View File
@@ -111,8 +111,8 @@
#define ESP_MATTER_PUMP_CONTROLLER_DEVICE_TYPE_VERSION 4
#define ESP_MATTER_MODE_SELECT_DEVICE_TYPE_ID 0x0027
#define ESP_MATTER_MODE_SELECT_DEVICE_TYPE_VERSION 1
#define ESP_MATTER_ROBOTIC_VACCUM_CLEANER_DEVICE_TYPE_ID 0x0074
#define ESP_MATTER_ROBOTIC_VACCUM_CLEANER_DEVICE_TYPE_VERSION 3
#define ESP_MATTER_ROBOTIC_VACUUM_CLEANER_DEVICE_TYPE_ID 0x0074
#define ESP_MATTER_ROBOTIC_VACUUM_CLEANER_DEVICE_TYPE_VERSION 3
#define ESP_MATTER_WATER_LEAK_DETECTOR_DEVICE_TYPE_ID 0x0043
#define ESP_MATTER_WATER_LEAK_DETECTOR_DEVICE_TYPE_VERSION 1
#define ESP_MATTER_RAIN_SENSOR_DEVICE_TYPE_ID 0x0044
@@ -293,9 +293,11 @@ esp_err_t add(endpoint_t *endpoint, config_t *config);
namespace extended_color_light {
typedef struct config : dimmable_light::config_t {
cluster::color_control::config_t color_control;
cluster::scenes_management::config_t scenes_management;
cluster::color_control::feature::color_temperature::config_t color_control_color_temperature;
cluster::color_control::feature::xy::config_t color_control_xy;
uint16_t color_control_remaining_time;
config() : color_control_remaining_time(0) {}
} config_t;
components/esp_matter/data_model/esp_matter_feature.cpp
+6 -5
View File
@@ -369,8 +369,8 @@ uint32_t get_id()
esp_err_t add(cluster_t *cluster)
{
VerifyOrReturnError(cluster, ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Cluster cannot be NULL"));
uint32_t lits_feature_map = feature::long_idle_time_support::get_id();
VerifyOrReturnError((get_feature_map_value(cluster) & lits_feature_map) == lits_feature_map, ESP_ERR_INVALID_STATE, ESP_LOGE(TAG, "Long Idle Time Support feature should be added to this cluster"));
uint32_t long_idle_time_support_feature_map = feature::long_idle_time_support::get_id();
VerifyOrReturnError((get_feature_map_value(cluster) & long_idle_time_support_feature_map) == long_idle_time_support_feature_map, ESP_ERR_INVALID_STATE, ESP_LOGE(TAG, "Long Idle Time Support feature should be added to this cluster"));
update_feature_map(cluster, get_id());
@@ -399,8 +399,8 @@ uint32_t get_id()
esp_err_t add(cluster_t *cluster, config_t *config)
{
VerifyOrReturnError((cluster && config), ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Cluster and config cannot be NULL"));
uint32_t lits_feature_map = feature::long_idle_time_support::get_id();
VerifyOrReturnError((get_feature_map_value(cluster) & lits_feature_map) == lits_feature_map, ESP_ERR_INVALID_STATE, ESP_LOGE(TAG, "Long Idle Time Support feature should be added to this cluster"));
uint32_t long_idle_time_support_feature_map = feature::long_idle_time_support::get_id();
VerifyOrReturnError((get_feature_map_value(cluster) & long_idle_time_support_feature_map) == long_idle_time_support_feature_map, ESP_ERR_INVALID_STATE, ESP_LOGE(TAG, "Long Idle Time Support feature should be added to this cluster"));
update_feature_map(cluster, get_id());
@@ -1801,6 +1801,7 @@ esp_err_t add(cluster_t *cluster, config_t *config)
/* Attributes not managed internally */
attribute::create_temperature_unit(cluster, config->temperature_unit);
attribute::create_supported_temperature_units(cluster, NULL, 0, 0);
return ESP_OK;
}
@@ -3348,7 +3349,7 @@ uint32_t get_id()
esp_err_t add(cluster_t *cluster)
{
VerifyOrReturnError(cluster, ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Cluster connot be NULL"));
VerifyOrReturnError(cluster, ESP_ERR_INVALID_ARG, ESP_LOGE(TAG, "Cluster cannot be NULL"));
update_feature_map(cluster, get_id());
/* attribute */
nullable<uint64_t> timestamp;
components/esp_matter/data_model/ota_provider_integration.cpp
+102
View File
@@ -0,0 +1,102 @@
// 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 <app/clusters/ota-provider/ota-provider-cluster.h>
#include <app/util/attribute-storage.h>
#include <data-model-providers/codegen/CodegenDataModelProvider.h>
#include <cstdint>
using namespace chip;
using namespace chip::app;
using namespace chip::app::Clusters;
namespace {
static constexpr size_t kOtaProviderFixedClusterCount = 0;
static constexpr size_t kOtaProviderMaxClusterCount = kOtaProviderFixedClusterCount + CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT;
LazyRegisteredServerCluster<OtaProviderServer> gServers[kOtaProviderMaxClusterCount];
// Find the 0-based array index corresponding to the given endpoint id.
// Log an error if not found.
bool findEndpointWithLog(EndpointId endpointId, uint16_t & outArrayIndex)
{
uint16_t arrayIndex =
emberAfGetClusterServerEndpointIndex(endpointId, OtaSoftwareUpdateProvider::Id, kOtaProviderFixedClusterCount);
if (arrayIndex >= kOtaProviderMaxClusterCount)
{
ChipLogError(AppServer, "Could not find endpoint index for endpoint %u", endpointId);
return false;
}
return true;
}
} // namespace
void emberAfOtaSoftwareUpdateProviderClusterInitCallback(EndpointId endpointId)
{
uint16_t arrayIndex = 0;
if (!findEndpointWithLog(endpointId, arrayIndex))
{
return;
}
gServers[arrayIndex].Create(endpointId);
CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Register(gServers[arrayIndex].Registration());
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Failed to register OTA on endpoint %u: %" CHIP_ERROR_FORMAT, endpointId, err.Format());
}
}
void emberAfOtaSoftwareUpdateProviderClusterShutdownCallback(EndpointId endpointId)
{
uint16_t arrayIndex = 0;
if (!findEndpointWithLog(endpointId, arrayIndex))
{
return;
}
CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Unregister(&gServers[arrayIndex].Cluster());
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Failed to unregister OTA on endpoint %u: %" CHIP_ERROR_FORMAT, endpointId, err.Format());
}
gServers[arrayIndex].Destroy();
}
void MatterOtaSoftwareUpdateProviderPluginServerInitCallback() {}
void MatterOtaSoftwareUpdateProviderPluginServerShutdownCallback() {}
namespace chip {
namespace app {
namespace Clusters {
namespace OTAProvider {
void SetDelegate(EndpointId endpointId, OTAProviderDelegate * delegate)
{
uint16_t arrayIndex = 0;
if (!findEndpointWithLog(endpointId, arrayIndex))
{
return;
}
gServers[arrayIndex].Cluster().SetDelegate(delegate);
}
} // namespace OTAProvider
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/data_model/software_diagnostics_codegen_integration.cpp
+74
View File
@@ -0,0 +1,74 @@
// 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 "esp_matter_core.h"
#include <app/clusters/software-diagnostics-server/software-diagnostics-cluster.h>
#include <app/clusters/software-diagnostics-server/software-diagnostics-logic.h>
#include <app/util/attribute-storage.h>
#include <data-model-providers/codegen/CodegenDataModelProvider.h>
#include "clusters/SoftwareDiagnostics/AttributeIds.h"
#include "clusters/SoftwareDiagnostics/ClusterId.h"
#include <data_model/esp_matter_data_model.h>
using namespace chip;
using namespace chip::app;
using namespace chip::app::Clusters;
using namespace chip::app::Clusters::SoftwareDiagnostics;
namespace {
LazyRegisteredServerCluster<SoftwareDiagnosticsServerCluster<DeviceLayerSoftwareDiagnosticsLogic>> gServer;
}
bool isAttributeEnabled(uint16_t endpoint_id, uint32_t cluster_id, uint32_t attribute_id)
{
esp_matter::attribute_t *attr = esp_matter::attribute::get(endpoint_id, cluster_id, attribute_id);
printf("attr %ld enabled %d", attribute_id, attr != nullptr);
return attr != nullptr;
}
void emberAfSoftwareDiagnosticsClusterInitCallback(chip::EndpointId endpointId)
{
VerifyOrReturn(endpointId == chip::kRootEndpointId);
SoftwareDiagnosticsEnabledAttributes enabledAttributes{
.enableThreadMetrics = isAttributeEnabled(endpointId, Id, Attributes::ThreadMetrics::Id),
.enableCurrentHeapFree = isAttributeEnabled(endpointId, Id, Attributes::CurrentHeapFree::Id),
.enableCurrentHeapUsed = isAttributeEnabled(endpointId, Id, Attributes::CurrentHeapUsed::Id),
.enableCurrentWatermarks = isAttributeEnabled(endpointId, Id, Attributes::CurrentHeapHighWatermark::Id),
};
gServer.Create(enabledAttributes);
CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Register(gServer.Registration());
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Failed to register SoftwareDiagnostics on endpoint %u: %" CHIP_ERROR_FORMAT, endpointId,
err.Format());
}
}
void emberAfSoftwareDiagnosticsClusterShutdownCallback(EndpointId endpointId)
{
VerifyOrReturn(endpointId == kRootEndpointId);
CHIP_ERROR err = CodegenDataModelProvider::Instance().Registry().Unregister(&gServer.Cluster());
if (err != CHIP_NO_ERROR)
{
ChipLogError(AppServer, "Failed to unregister SoftwareDiagnostics on endpoint %u: %" CHIP_ERROR_FORMAT, endpointId,
err.Format());
}
gServer.Destroy();
}
void MatterSoftwareDiagnosticsPluginServerInitCallback() {}
void MatterSoftwareDiagnosticsPluginServerShutdownCallback() {}
components/esp_matter/esp_matter_core.cpp
+5 -1
View File
@@ -20,6 +20,8 @@
#include <esp_matter_test_event_trigger.h>
#include <nvs.h>
#include <app/clusters/general-diagnostics-server/general-diagnostics-server.h>
#include <app/clusters/identify-server/identify-server.h>
#include <app/server/Dnssd.h>
#ifdef CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER
#include <app/clusters/general-diagnostics-server/general-diagnostics-server.h>
@@ -223,6 +225,8 @@ static void esp_matter_chip_init_task(intptr_t context)
ESP_LOGE(TAG, "Failed to add fabric delegate, err:%" CHIP_ERROR_FORMAT, ret.Format());
}
chip::Server::GetInstance().Init(initParams);
network_commissioning_instance_init();
#ifdef CONFIG_ESP_MATTER_ENABLE_DATA_MODEL
if (endpoint::enable_all() != ESP_OK) {
ESP_LOGE(TAG, "Enable all endpoints failure");
@@ -231,7 +235,7 @@ static void esp_matter_chip_init_task(intptr_t context)
// TODO: Find a better way to record the events which should be recorded in matter server init
// Record start up event in basic information cluster.
PlatformMgr().HandleServerStarted();
// Record boot reason evnet in general diagnostics cluster.
// Record boot reason event in general diagnostics cluster.
chip::app::Clusters::GeneralDiagnostics::BootReasonEnum bootReason;
if (GetDiagnosticDataProvider().GetBootReason(bootReason) == CHIP_NO_ERROR) {
chip::app::Clusters::GeneralDiagnosticsServer::Instance().OnDeviceReboot(bootReason);
components/esp_matter/esp_matter_core.h
+11 -2
View File
@@ -38,7 +38,7 @@ namespace esp_matter {
/** TODO: Change this */
typedef void (*event_callback_t)(const ChipDeviceEvent *event, intptr_t arg);
/** Return whether the Matter is intialized and started
/** Return whether the Matter is initialized and started
*
* @return true if Matter is started
* @return false if Matter is not started
@@ -57,7 +57,7 @@ bool is_started();
*/
esp_err_t start(event_callback_t callback, intptr_t callback_arg = static_cast<intptr_t>(NULL));
/** Return whether the Matter is intialized and started
/** Return whether the Matter is initialized and started
*
* @return true if Matter is started
* @return false if Matter is not started
@@ -73,6 +73,15 @@ bool is_started();
*/
esp_err_t factory_reset();
#ifdef CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER
/**
*
* Initialize WiFi, Ethernet, and Thread network commissioning instances.
* This function is called internally during Matter initialization.
*/
void network_commissioning_instance_init();
#endif // CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER
namespace lock {
/** Lock status */
components/esp_matter/network_commissioning_instance.cpp
+50
View File
@@ -0,0 +1,50 @@
// 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 <esp_matter_core.h>
#ifdef CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER
#include <app/clusters/network-commissioning/CodegenInstance.h>
#include <platform/ESP32/NetworkCommissioningDriver.h>
#if CHIP_DEVICE_CONFIG_ENABLE_THREAD && CONFIG_THREAD_NETWORK_COMMISSIONING_DRIVER
#include <platform/OpenThread/GenericNetworkCommissioningThreadDriver.h>
#endif
namespace esp_matter {
void network_commissioning_instance_init()
{
#if CHIP_DEVICE_CONFIG_ENABLE_WIFI && CHIP_DEVICE_CONFIG_WIFI_NETWORK_DRIVER
static chip::app::Clusters::NetworkCommissioning::Instance sWiFiNetworkCommissioningInstance(CONFIG_WIFI_NETWORK_ENDPOINT_ID /* Endpoint Id */,
&(chip::DeviceLayer::NetworkCommissioning::ESPWiFiDriver::GetInstance()));
sWiFiNetworkCommissioningInstance.Init();
#endif // CHIP_DEVICE_CONFIG_WIFI_NETWORK_DRIVER
#if CHIP_DEVICE_CONFIG_ENABLE_ETHERNET && CHIP_DEVICE_CONFIG_ETHERNET_NETWORK_DRIVER
static chip::app::Clusters::NetworkCommissioning::Instance sEthernetNetworkCommissioningInstance(CONFIG_ETHERNET_NETWORK_ENDPOINT_ID /* Endpoint Id */,
&(chip::DeviceLayer::NetworkCommissioning::ESPEthernetDriver::GetInstance()));
sEthernetNetworkCommissioningInstance.Init();
#endif // CHIP_DEVICE_CONFIG_ETHERNET_NETWORK_DRIVER
#if CHIP_DEVICE_CONFIG_ENABLE_THREAD && CONFIG_THREAD_NETWORK_COMMISSIONING_DRIVER
static chip::app::Clusters::NetworkCommissioning::InstanceAndDriver<chip::DeviceLayer::NetworkCommissioning::GenericThreadDriver> sThreadNetworkDriver(CONFIG_THREAD_NETWORK_ENDPOINT_ID);
sThreadNetworkDriver.Init();
#endif
}
} // namespace esp_matter
#endif // CONFIG_ESP_MATTER_ENABLE_MATTER_SERVER
components/esp_matter/private/esp_matter_cluster_revisions.h
+4 -4
View File
@@ -96,11 +96,11 @@ constexpr uint16_t cluster_revision = 2;
} // namespace time_synchronization
namespace unit_localization {
constexpr uint16_t cluster_revision = 1;
constexpr uint16_t cluster_revision = 2;
} // namespace unit_localization
namespace bridged_device_basic_information {
constexpr uint16_t cluster_revision = 4;
constexpr uint16_t cluster_revision = 5;
} // namespace bridged_device_basic_information
namespace power_source {
@@ -108,7 +108,7 @@ constexpr uint16_t cluster_revision = 3;
} // namespace power_source
namespace icd_management {
constexpr uint16_t cluster_revision = 2;
constexpr uint16_t cluster_revision = 3;
} // namespace icd_management
namespace user_label {
@@ -120,7 +120,7 @@ constexpr uint16_t cluster_revision = 1;
} // namespace fixed_label
namespace identify {
constexpr uint16_t cluster_revision = 5;
constexpr uint16_t cluster_revision = 6;
} // namespace identify
namespace groups {
components/esp_matter/utils/cluster_select/Kconfig.in
+4
View File
@@ -385,6 +385,10 @@ config SUPPORT_SOFTWARE_DIAGNOSTICS_CLUSTER
bool "Support SOFTWARE_DIAGNOSTICS_CLUSTER"
default y
config SUPPORT_SOIL_MEASUREMENT_CLUSTER
bool "Support SOIL_MEASUREMENT_CLUSTER"
default y
config SUPPORT_SWITCH_CLUSTER
bool "Support SWITCH_CLUSTER"
default y
components/esp_matter/utils/cluster_select/cluster_dir.cmake
+3
View File
@@ -291,6 +291,9 @@ function(get_supported_cluster_dirs source_dirs)
if(CONFIG_SUPPORT_SOFTWARE_DIAGNOSTICS_CLUSTER)
list(APPEND temp_list "${MATTER_SDK_PATH}/src/app/clusters/software-diagnostics-server")
endif()
if(CONFIG_SUPPORT_SOIL_MEASUREMENT_CLUSTER)
list(APPEND temp_list "${MATTER_SDK_PATH}/src/app/clusters/soil-measurement-server")
endif()
if(CONFIG_SUPPORT_SWITCH_CLUSTER)
list(APPEND temp_list "${MATTER_SDK_PATH}/src/app/clusters/switch-server")
endif()
components/esp_matter/zap_common/app/static-cluster-config/AccessControl.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Access Control based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace AccessControl {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace AccessControl
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/AccountLogin.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Account Login based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace AccountLogin {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace AccountLogin
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/Actions.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Actions based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace Actions {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace Actions
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ActivatedCarbonFilterMonitoring.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Activated Carbon Filter Monitoring based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ActivatedCarbonFilterMonitoring {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ActivatedCarbonFilterMonitoring
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/AdministratorCommissioning.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Administrator Commissioning based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace AdministratorCommissioning {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace AdministratorCommissioning
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/AirQuality.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Air Quality based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace AirQuality {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace AirQuality
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ApplicationBasic.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Application Basic based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ApplicationBasic {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ApplicationBasic
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ApplicationLauncher.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Application Launcher based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ApplicationLauncher {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ApplicationLauncher
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/AudioOutput.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Audio Output based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace AudioOutput {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace AudioOutput
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/BallastConfiguration.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Ballast Configuration based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace BallastConfiguration {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace BallastConfiguration
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/BasicInformation.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Basic Information based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace BasicInformation {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace BasicInformation
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/Binding.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Binding based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace Binding {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace Binding
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/BooleanState.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Boolean State based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace BooleanState {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace BooleanState
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/BooleanStateConfiguration.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Boolean State Configuration based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace BooleanStateConfiguration {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace BooleanStateConfiguration
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/BridgedDeviceBasicInformation.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Bridged Device Basic Information based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace BridgedDeviceBasicInformation {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace BridgedDeviceBasicInformation
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/CameraAvSettingsUserLevelManagement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Camera AV Settings User Level Management based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace CameraAvSettingsUserLevelManagement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace CameraAvSettingsUserLevelManagement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/CameraAvStreamManagement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Camera AV Stream Management based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace CameraAvStreamManagement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace CameraAvStreamManagement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/CarbonDioxideConcentrationMeasurement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Carbon Dioxide Concentration Measurement based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace CarbonDioxideConcentrationMeasurement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace CarbonDioxideConcentrationMeasurement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/CarbonMonoxideConcentrationMeasurement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Carbon Monoxide Concentration Measurement based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace CarbonMonoxideConcentrationMeasurement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace CarbonMonoxideConcentrationMeasurement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/Channel.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Channel based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace Channel {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace Channel
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/Chime.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Chime based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace Chime {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace Chime
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ClosureControl.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Closure Control based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ClosureControl {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ClosureControl
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ClosureDimension.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Closure Dimension based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ClosureDimension {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ClosureDimension
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ColorControl.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Color Control based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ColorControl {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ColorControl
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/CommissionerControl.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Commissioner Control based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace CommissionerControl {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace CommissionerControl
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/CommodityMetering.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Commodity Metering based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace CommodityMetering {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace CommodityMetering
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/CommodityPrice.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Commodity Price based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace CommodityPrice {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace CommodityPrice
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/CommodityTariff.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Commodity Tariff based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace CommodityTariff {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace CommodityTariff
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ContentAppObserver.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Content App Observer based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ContentAppObserver {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ContentAppObserver
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ContentControl.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Content Control based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ContentControl {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ContentControl
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ContentLauncher.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Content Launcher based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ContentLauncher {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ContentLauncher
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/Descriptor.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Descriptor based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace Descriptor {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace Descriptor
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/DeviceEnergyManagement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Device Energy Management based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace DeviceEnergyManagement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace DeviceEnergyManagement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/DeviceEnergyManagementMode.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Device Energy Management Mode based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace DeviceEnergyManagementMode {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace DeviceEnergyManagementMode
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/DiagnosticLogs.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Diagnostic Logs based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace DiagnosticLogs {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace DiagnosticLogs
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/DishwasherAlarm.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Dishwasher Alarm based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace DishwasherAlarm {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace DishwasherAlarm
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/DishwasherMode.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Dishwasher Mode based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace DishwasherMode {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace DishwasherMode
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/DoorLock.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Door Lock based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace DoorLock {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace DoorLock
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/EcosystemInformation.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Ecosystem Information based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace EcosystemInformation {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace EcosystemInformation
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ElectricalEnergyMeasurement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Electrical Energy Measurement based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ElectricalEnergyMeasurement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ElectricalEnergyMeasurement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ElectricalGridConditions.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Electrical Grid Conditions based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ElectricalGridConditions {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ElectricalGridConditions
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ElectricalPowerMeasurement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Electrical Power Measurement based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ElectricalPowerMeasurement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ElectricalPowerMeasurement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/EnergyEvse.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Energy EVSE based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace EnergyEvse {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace EnergyEvse
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/EnergyEvseMode.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Energy EVSE Mode based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace EnergyEvseMode {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace EnergyEvseMode
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/EnergyPreference.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Energy Preference based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace EnergyPreference {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace EnergyPreference
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/EthernetNetworkDiagnostics.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Ethernet Network Diagnostics based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace EthernetNetworkDiagnostics {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace EthernetNetworkDiagnostics
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/FanControl.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Fan Control based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace FanControl {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace FanControl
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/FaultInjection.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Fault Injection based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace FaultInjection {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace FaultInjection
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/FixedLabel.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Fixed Label based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace FixedLabel {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace FixedLabel
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/FlowMeasurement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Flow Measurement based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace FlowMeasurement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace FlowMeasurement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/FormaldehydeConcentrationMeasurement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Formaldehyde Concentration Measurement based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace FormaldehydeConcentrationMeasurement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace FormaldehydeConcentrationMeasurement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/GeneralCommissioning.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for General Commissioning based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace GeneralCommissioning {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace GeneralCommissioning
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/GeneralDiagnostics.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for General Diagnostics based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace GeneralDiagnostics {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace GeneralDiagnostics
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/GroupKeyManagement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Group Key Management based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace GroupKeyManagement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace GroupKeyManagement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/Groups.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Groups based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace Groups {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace Groups
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/HepaFilterMonitoring.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for HEPA Filter Monitoring based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace HepaFilterMonitoring {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace HepaFilterMonitoring
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/IcdManagement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for ICD Management based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace IcdManagement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace IcdManagement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/Identify.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Identify based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace Identify {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace Identify
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/IlluminanceMeasurement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Illuminance Measurement based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace IlluminanceMeasurement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace IlluminanceMeasurement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/JointFabricAdministrator.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Joint Fabric Administrator based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace JointFabricAdministrator {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace JointFabricAdministrator
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/JointFabricDatastore.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Joint Fabric Datastore based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace JointFabricDatastore {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace JointFabricDatastore
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/KeypadInput.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Keypad Input based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace KeypadInput {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace KeypadInput
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/LaundryDryerControls.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Laundry Dryer Controls based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace LaundryDryerControls {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace LaundryDryerControls
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/LaundryWasherControls.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Laundry Washer Controls based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace LaundryWasherControls {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace LaundryWasherControls
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/LaundryWasherMode.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Laundry Washer Mode based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace LaundryWasherMode {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace LaundryWasherMode
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/LevelControl.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Level Control based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace LevelControl {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace LevelControl
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/LocalizationConfiguration.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Localization Configuration based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace LocalizationConfiguration {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace LocalizationConfiguration
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/LowPower.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Low Power based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace LowPower {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace LowPower
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/MediaInput.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Media Input based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace MediaInput {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace MediaInput
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/MediaPlayback.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Media Playback based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace MediaPlayback {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace MediaPlayback
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/Messages.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Messages based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace Messages {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace Messages
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/MeterIdentification.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Meter Identification based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace MeterIdentification {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace MeterIdentification
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/MicrowaveOvenControl.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Microwave Oven Control based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace MicrowaveOvenControl {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace MicrowaveOvenControl
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/MicrowaveOvenMode.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Microwave Oven Mode based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace MicrowaveOvenMode {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace MicrowaveOvenMode
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/ModeSelect.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Mode Select based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace ModeSelect {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace ModeSelect
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/NetworkCommissioning.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Network Commissioning based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace NetworkCommissioning {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace NetworkCommissioning
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/NitrogenDioxideConcentrationMeasurement.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Nitrogen Dioxide Concentration Measurement based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace NitrogenDioxideConcentrationMeasurement {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace NitrogenDioxideConcentrationMeasurement
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/OccupancySensing.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Occupancy Sensing based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace OccupancySensing {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace OccupancySensing
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/OnOff.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for On/Off based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace OnOff {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace OnOff
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/OperationalCredentials.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Operational Credentials based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace OperationalCredentials {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace OperationalCredentials
} // namespace Clusters
} // namespace app
} // namespace chip
components/esp_matter/zap_common/app/static-cluster-config/OperationalState.h
-23
View File
@@ -1,23 +0,0 @@
// Application configuration for Operational State based on EMBER configuration
#pragma once
#include <app-common/zap-generated/cluster-enums.h>
#include <app/util/cluster-config.h>
#include <array>
namespace chip {
namespace app {
namespace Clusters {
namespace OperationalState {
namespace StaticApplicationConfig {
using FeatureBitmapType = Clusters::StaticApplicationConfig::NoFeatureFlagsDefined;
inline constexpr std::array<Clusters::StaticApplicationConfig::ClusterConfiguration<FeatureBitmapType>, 0> kFixedClusterConfig = { };
} // namespace StaticApplicationConfig
} // namespace OperationalState
} // namespace Clusters
} // namespace app
} // namespace chip

Some files were not shown because too many files have changed in this diff Show More