SImplify commission configuration with aggregator

[Genewolf]

Hello esp-matter community,

I'm an intern developer and still quite inexperienced with the Matter environment. I've been learning for a few months now, and I currently have a device that interacts with a LED (dimmable_light endpoint) and a potentiometer (temperature_sensor endpoint).

I'm doing the commissioning process using an Amazon Echo Pop as the Thread border router, scanning the default CHIP QR code from the 'light' example in the Alexa app.
Everything works fine, even though I sometimes see some errors in the logs.
However, one thing is pretty annoying: I have to configure each endpoint individually by assigning it a name and a group (room). I also seem to have a third endpoint, which is probably the root node endpoint, detected as a hub.

I looked into ways to simplify this, and the only possible solution I found was to use an aggregator endpoint that could group all the child endpoints into a single device to configure. I'm not sure if this would do exactly what I want, but it's the only lead I've found so far.

The best documentation I have is the Device Library Specification PDF from CHIP, which includes a clear diagram showing an aggregator endpoint managing other endpoints using the PartsList attribute from the Descriptor cluster and the EndpointLists attribute from the Actions cluster:
app_main.cpp:
`extern "C" void app_main()
{
esp_err_t err = ESP_OK;

nvs_flash_erase();  // Effacer la mémoire flash NVS
nvs_flash_init();   // Initialiser de nouveau le NVS

// Création du noeud contenant tous les endpoints et du endpoint 0 obligatoire
node::config_t node_config;
node_t *node = node::create(&node_config, app_attribute_update_cb, app_identification_cb);
ABORT_APP_ON_FAILURE(node != nullptr, ESP_LOGE(TAG, "Failed to create Matter node"));

// Endpoint agrégateur à endpoint 0 (bridge pour les endpoints enfants)
// Config
aggregator::config_t aggregator_config;
// Endpoint
endpoint_t *aggregator_endpoint = aggregator::create(node, &aggregator_config, ENDPOINT_FLAG_NONE, nullptr);
ABORT_APP_ON_FAILURE(aggregator_endpoint != nullptr, ESP_LOGE(TAG, "Failed to create aggregator endpoint"));
aggregator_endpoint_id = endpoint::get_id(aggregator_endpoint);
ESP_LOGI(TAG, "Aggregator created with endpoint_id %d", aggregator_endpoint_id);

// Endpoint pour la LED
// Driver
app_driver_handle_t light_handle = app_driver_light_init();
// Config
dimmable_light::config_t light_config;
light_config.on_off.on_off = DEFAULT_POWER;
light_config.on_off.lighting.start_up_on_off = nullptr;
light_config.level_control.current_level = DEFAULT_BRIGHTNESS;
light_config.level_control.on_level = DEFAULT_BRIGHTNESS;
light_config.level_control.lighting.start_up_current_level = DEFAULT_BRIGHTNESS;
// Endpoint
endpoint_t *light_endpoint = dimmable_light::create(node, &light_config, ENDPOINT_FLAG_BRIDGE, light_handle);
ABORT_APP_ON_FAILURE(light_endpoint != nullptr, ESP_LOGE(TAG, "Création de la LED échouée"));
// Sauvegarde de l'ID de l'endpoint
light_endpoint_id = endpoint::get_id(light_endpoint);
ESP_LOGI(TAG, "Light created with endpoint_id %d", light_endpoint_id);
// Associer cet endpoint à l'aggregator
endpoint::set_parent_endpoint(aggregator_endpoint, light_endpoint);

// Endpoint pour le potentiomètre
// Driver
app_driver_handle_t temp_handle = app_driver_potent_init();
// Config
temperature_sensor::config_t temp_config;
temp_config.temperature_measurement.measured_value = DEFAULT_TEMPERATURE;
// Endpoint
endpoint_t *temp_endpoint = temperature_sensor::create(node, &temp_config, ENDPOINT_FLAG_BRIDGE, temp_handle);
ABORT_APP_ON_FAILURE(temp_endpoint != nullptr, ESP_LOGE(TAG, "Création du thermomètre échouée"));
// Sauvegarde de l'ID de l'endpoint
temperature_sensor_endpoint_id = endpoint::get_id(temp_endpoint);
ESP_LOGI(TAG, "Temp sensor created with endpoint_id %d", temperature_sensor_endpoint_id);
// Associer cet endpoint à l'aggregator
endpoint::set_parent_endpoint(aggregator_endpoint, temp_endpoint);

// SIMPLIFIER LA CONFIGURATION DES ENDPOINTS

// PARTSLIST    
// Vérifier que les attributs PartsList de la racine et de l'aggregator existent bien, puis les mettre à jour
attribute_t *root_attribute = attribute::get(0, Descriptor::Id, Descriptor::Attributes::PartsList::Id);
attribute_t *aggregator_attribute = attribute::get(aggregator_endpoint_id, Descriptor::Id, Descriptor::Attributes::PartsList::Id);
if (root_attribute == nullptr || aggregator_attribute == nullptr) {
    ESP_LOGE(TAG, "Failed to get node or aggregator attribute");
    return;
}
ESP_LOGI(TAG, "Node and aggregator attribute successfully obtained");
// Mettre à jour l'attribut PartsList du noeud racine
esp_matter_attr_val_t parts_list1[3];
parts_list1[0].val.u16 = aggregator_endpoint_id;
parts_list1[0].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
parts_list1[1].val.u16 = light_endpoint_id;
parts_list1[1].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
parts_list1[2].val.u16 = temperature_sensor_endpoint_id;
parts_list1[2].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
attribute::update(0, Descriptor::Id, Descriptor::Attributes::PartsList::Id, parts_list1);
// Mettre à jour l'attribut PartsList de l'aggregator
esp_matter_attr_val_t parts_list2[2];
parts_list2[0].val.u16 = light_endpoint_id;
parts_list2[0].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
parts_list2[1].val.u16 = temperature_sensor_endpoint_id;
parts_list2[1].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
attribute::update(aggregator_endpoint_id, Descriptor::Id, Descriptor::Attributes::PartsList::Id, parts_list2);
ESP_LOGI(TAG, "Attributes updated successfully");

// ENDPOINTLIST
ESP_LOGI(TAG, "Mise en place de l'endpointlist");
// Ajouter le cluster Actions à l'aggregator endpoint
cluster::actions::config_t actions_config = {};
cluster_t *actions_cluster = cluster::actions::create(aggregator_endpoint, &actions_config, CLUSTER_FLAG_SERVER);
ABORT_APP_ON_FAILURE(actions_cluster != nullptr, ESP_LOGE(TAG, "Failed to create Actions cluster"));

// Créer l'attribut EndpointLists
esp_matter_attr_val_t default_endpoint_list = esp_matter_invalid(NULL);
attribute_t *endpoint_lists_attribute = attribute::create(actions_cluster, Actions::Attributes::EndpointLists::Id, ATTRIBUTE_FLAG_NONE, default_endpoint_list);
ABORT_APP_ON_FAILURE(endpoint_lists_attribute != nullptr, ESP_LOGE(TAG, "Failed to create EndpointLists attribute"));

// Créer le groupe "piscine" et ajouter les endpoints
uint16_t endpoints[] = {light_endpoint_id, temperature_sensor_endpoint_id};
add_endpoints_to_group(aggregator_endpoint_id, "piscine", endpoints, sizeof(endpoints) / sizeof(endpoints[0]));
[...]`

App_driver.cpp:
`void add_endpoints_to_group(uint16_t endpoint_id, const char *group_name, uint16_t *endpoints, size_t endpoint_count)
{
// Créer une liste d'endpoints pour le groupe
esp_matter_attr_val_t endpoint_list[endpoint_count];
for (size_t i = 0; i < endpoint_count; i++) {
endpoint_list[i].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
endpoint_list[i].val.u16 = endpoints[i];
}

// Mettre à jour l'attribut EndpointLists du cluster Actions
attribute_t *actions_attribute = attribute::get(endpoint_id, Actions::Id, Actions::Attributes::EndpointLists::Id);
if (actions_attribute == nullptr) {
    ESP_LOGE(TAG, "Failed to get Actions::EndpointLists attribute");
    return;
}
attribute::update(endpoint_id, Actions::Id, Actions::Attributes::EndpointLists::Id, endpoint_list);
// PAS BON: il ne faut pas directement ListID, mais [ [0xE001, "group_name", room(0x01), [ListID] ]

// Ajouter un nom au groupe (facultatif, pour des fins de documentation)
ESP_LOGI(TAG, "Group '%s' created with %d endpoints", group_name, endpoint_count);

}

// not used because of errors, but with the exact formatting from the doc
void configure_endpoint_lists(uint16_t aggregator_endpoint_id)
{
// Définir les endpoints du groupe
uint16_t group1_endpoints[] = {light_endpoint_id, temperature_sensor_endpoint_id};

// Allouer de la mémoire pour le tableau principal (4 éléments)
esp_matter_attr_val_t group1_array[4];

// Initialiser l'ID du groupe
group1_array[0].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
group1_array[0].val.u16 = 0xE001;

// Initialiser le nom du groupe (en tant que tableau d'octets)
const char *group_name = "piscine";
size_t group_name_len = strlen(group_name);
uint8_t *group_name_bytes = (uint8_t *)malloc(group_name_len);
if (group_name_bytes == NULL) {
    ESP_LOGE(TAG, "Failed to allocate memory for group name");
    free(group1_array);
    return;
}
memcpy(group_name_bytes, group_name, group_name_len);

group1_array[1].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_CHAR_STRING;
group1_array[1].val.b = group_name_bytes; // Utiliser val.b pour stocker le tableau d'octets

// Initialiser le type du groupe
group1_array[2].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_ENUM8;
group1_array[2].val.u8 = 0x01; // Type "room"

// Initialiser la liste des endpoints
group1_array[3].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_ARRAY;
esp_matter_attr_val_t group1_array_3[2];

// Initialiser chaque endpoint dans la liste
for (size_t i = 0; i < 2; i++) {
    group1_array_3[i].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
    group1_array_3[i].val.u16 = group1_endpoints[i];
}
group1_array[3].val.a = group1_array_3;

// Mettre à jour l'attribut EndpointLists
attribute_t *endpoint_lists_attribute = attribute::get(aggregator_endpoint_id, Actions::Id, Actions::Attributes::EndpointLists::Id);
if (endpoint_lists_attribute == NULL) {
    ESP_LOGE(TAG, "Failed to get Actions::EndpointLists attribute");
    return;
}

esp_matter_attr_val_t group1 = esp_matter_invalid(NULL);
group1.type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_ARRAY;
group1.val.a = group1_array;
attribute::update(aggregator_endpoint_id, Actions::Id, Actions::Attributes::EndpointLists::Id, &group1);

ESP_LOGI(TAG, "EndpointLists configured successfully");

}`

If any of you have a lead or have done something similar before, I'm all ears.

PS: I'm aware that my code is obviously mostly wrote by IA, and I know that some of it don't make much sense (like using array to change val.a values or using constant parameters etc...) but I'm completely lost after trying a lot of thing, and I believed chatGPT could produce something better than me (I was wrong)

[Genewolf]

Ignore the previous code part about PartsList and EndpointLists, I didn't checked it well and it has a lot of incoherences that I can correct.
Here's the code I have now, completely fonctional, but without any true modification after de commissionning, I really don't know why at this point.
app_main.cpp:

[Create node, light and potentiometer]
// SIMPLIFY COMMISSIONNING CONFIGURATION

// PARTSLIST    
// Check that the PartsList attributes of the root and aggregator exist, then update them
attribute_t *root_attribute = attribute::get(0, Descriptor::Id, Descriptor::Attributes::PartsList::Id);
attribute_t *aggregator_attribute = attribute::get(aggregator_endpoint_id, Descriptor::Id, Descriptor::Attributes::PartsList::Id);
if (root_attribute == nullptr || aggregator_attribute == nullptr) {
    ESP_LOGE(TAG, "Failed to get node or aggregator attribute");
    return;
}
ESP_LOGI(TAG, "Node and aggregator attribute successfully obtained");
// Update the PartsList attribute of the root node
esp_matter_attr_val_t parts_list1[3];
parts_list1[0].val.u16 = aggregator_endpoint_id;
parts_list1[0].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
parts_list1[1].val.u16 = light_endpoint_id;
parts_list1[1].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
parts_list1[2].val.u16 = temperature_sensor_endpoint_id;
parts_list1[2].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
attribute::update(0, Descriptor::Id, Descriptor::Attributes::PartsList::Id, parts_list1);
// Update the PartsList attribute of the aggregator
esp_matter_attr_val_t parts_list2[2];
parts_list2[0].val.u16 = light_endpoint_id;
parts_list2[0].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
parts_list2[1].val.u16 = temperature_sensor_endpoint_id;
parts_list2[1].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
attribute::update(aggregator_endpoint_id, Descriptor::Id, Descriptor::Attributes::PartsList::Id, parts_list2);
ESP_LOGI(TAG, "Attributes updated successfully");

// ENDPOINTLIST
ESP_LOGI(TAG, "Mise en place de l'endpointlist");
// Add the Actions cluster to the aggregator endpoint
cluster::actions::config_t actions_config = {};
cluster_t *actions_cluster = cluster::actions::create(aggregator_endpoint, &actions_config, CLUSTER_FLAG_SERVER);
ABORT_APP_ON_FAILURE(actions_cluster != nullptr, ESP_LOGE(TAG, "Failed to create Actions cluster"));

// Create the EndpointLists attribute
esp_matter_attr_val_t default_endpoint_list = esp_matter_invalid(NULL);
attribute_t *endpoint_lists_attribute = attribute::create(actions_cluster, Actions::Attributes::EndpointLists::Id, ATTRIBUTE_FLAG_NONE, default_endpoint_list);
ABORT_APP_ON_FAILURE(endpoint_lists_attribute != nullptr, ESP_LOGE(TAG, "Failed to create EndpointLists attribute"));
// Create the "piscine" group, add the endpoints and update it in EndpointLists attribute
configure_endpoint_lists(aggregator_endpoint_id);

// Set deferred persistence for attributes that can change quickly
ESP_LOGI(TAG, "deffered persistence");
attribute_t *current_level_attribute = attribute::get(light_endpoint_id, LevelControl::Id, LevelControl::Attributes::CurrentLevel::Id);
attribute::set_deferred_persistence(current_level_attribute);

app_driver.cpp:

void configure_endpoint_lists(uint16_t aggregator_endpoint_id)
{
    esp_matter_attr_val_t group1_array[4];

    // Initialize the group ID
    group1_array[0].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
    group1_array[0].val.u16 = 0xE001;

    // tialize the group name
    const char  group_name[] = "piscine";
    size_t name_len = strlen(group_name);

    group1_array[1].type = ESP_MATTER_VAL_TYPE_CHAR_STRING;
    group1_array[1].val.a.b = (uint8_t *)group_name;
    group1_array[1].val.a.s = 1;             // size of one element (char)
    group1_array[1].val.a.n = name_len;      // number of elements
    group1_array[1].val.a.t = name_len + 1;  // +1 if null-terminated (optional)

    // Initialize the group type
    group1_array[2].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_ENUM8;
    group1_array[2].val.u8 = 0x01; // Type "room"

    // Initialize the list of endpoints and their values
    esp_matter_attr_val_t group1_array_3[2];
    uint16_t group1_endpoints[2] = {light_endpoint_id, temperature_sensor_endpoint_id};

    // Initialize each endpoint in the list
    for (size_t i = 0; i < 2; i++) {
        group1_array_3[i].type = esp_matter_val_type_t::ESP_MATTER_VAL_TYPE_UINT16;
        group1_array_3[i].val.u16 = group1_endpoints[i];
    }
    
    group1_array[3].type = ESP_MATTER_VAL_TYPE_ARRAY;
    group1_array[3].val.a.b = (uint8_t *)group1_array_3;
    group1_array[3].val.a.s = sizeof(esp_matter_attr_val_t);  // size of one element
    group1_array[3].val.a.n = 2;                              // number of elements
    group1_array[3].val.a.t = sizeof(group1_array_3);         // total size

    // Create the main object containing the array
    esp_matter_attr_val_t group1;
    group1.type = ESP_MATTER_VAL_TYPE_ARRAY;
    group1.val.a.b = (uint8_t *)group1_array;
    group1.val.a.s = sizeof(esp_matter_attr_val_t); // size of one element
    group1.val.a.n = 4;                              // number of elements
    group1.val.a.t = sizeof(group1_array);           // total size

    // Update the EndpointLists attribute
    attribute_t *endpoint_lists_attribute = attribute::get(aggregator_endpoint_id, Actions::Id, Actions::Attributes::EndpointLists::Id);
    if (endpoint_lists_attribute == NULL) {
        ESP_LOGE(TAG, "Failed to get Actions::EndpointLists attribute");
        return;
    }

    attribute::update(aggregator_endpoint_id, Actions::Id, Actions::Attributes::EndpointLists::Id, &group1);
    ESP_LOGI(TAG, "EndpointLists configured successfully");
}

For what I understand, I did the same model as the exemple from the chip documentation (I think), so I'm not sure why it doesn't work yet

[Genewolf]

After some times, I realised that the aggregator endpoint is just not supported by hubs like Alexa, so maybe my configuration is correct but it just can't work the way I want it with the current Matter situation. Don't mind this discussions, sorry for that, I wasn't informed enough.