composition.c

Go to the documentation of this file.

 
#include "meshx_common.h"
#include "meshx.h"
#include "interface/ble_mesh/server/meshx_ble_mesh_prov_srv.h"
 
#if CONFIG_RELAY_SERVER_COUNT
#include "meshx_relay_server_element.h"
#endif /* CONFIG_RELAY_SERVER_COUNT */
 
#if CONFIG_RELAY_CLIENT_COUNT
#include "meshx_relay_client_element.h"
#endif /* CONFIG_RELAY_CLIENT_COUNT */
 
#if CONFIG_LIGHT_CWWW_SRV_COUNT
#include "meshx_cwww_server_element.h"
#endif /* CONFIG_LIGHT_CWWW_SRV_COUNT */
 
#if CONFIG_LIGHT_CWWW_CLIENT_COUNT
#include "meshx_light_cwww_client_element.h"
#endif /* CONFIG_LIGHT_CWWW_CLIENT_COUNT */
 
#if CONFIG_SECTION_ENABLE_ELEMENT_TABLE
#define MESHX_ELEMENT_COMP_TABLE_START  _element_table_start
#define MESHX_ELEMENT_COMP_TABLE_STOP   _element_table_end
 
extern element_comp_table_t MESHX_ELEMENT_COMP_TABLE_START;
extern element_comp_table_t MESHX_ELEMENT_COMP_TABLE_STOP;
 
#else
 
element_comp_fn_t element_comp_fn [MESHX_ELEMENT_TYPE_MAX] = {
#if CONFIG_RELAY_SERVER_COUNT
    [MESHX_ELEMENT_TYPE_RELAY_SERVER]       = &meshx_create_relay_elements,
#endif /* CONFIG_RELAY_SERVER_COUNT */
#if CONFIG_RELAY_CLIENT_COUNT
    [MESHX_ELEMENT_TYPE_RELAY_CLIENT]       = &create_relay_client_elements,
#endif /* CONFIG_RELAY_CLIENT_COUNT */
#if CONFIG_LIGHT_CWWW_SRV_COUNT
    [MESHX_ELEMENT_TYPE_LIGHT_CWWW_SERVER]  = &meshx_create_cwww_elements,
#endif /* CONFIG_LIGHT_CWWW_CLIENT_COUNT */
#if CONFIG_LIGHT_CWWW_CLIENT_COUNT
    [MESHX_ELEMENT_TYPE_LIGHT_CWWW_CLIENT]  = &create_cwww_client_elements,
#endif /* CONFIG_LIGHT_CWWW_SRV_COUNT */
};
 
#endif /* CONFIG_SECTION_ENABLE_ELEMENT_TABLE */

static MESHX_MODEL *meshx_sig_root_model_arr = NULL;
static MESHX_MODEL *meshx_ven_root_model_arr = NULL;
 
typedef meshx_err_t (*root_model_getfn_t)(void* p_model);
 
/* This table registers the functions that returns the root models */
static root_model_getfn_t meshx_sig_root_model_getfn[] = {
#if CONFIG_ENABLE_CONFIG_SERVER
    meshx_get_config_srv_model,
#endif /* CONFIG_ENABLE_CONFIG_SERVER */
#if CONFIG_ENABLE_LIGHT_CTL_SERVER
    meshx_get_ctl_setup_srv_model,
#endif /* CONFIG_ENABLE_LIGHT_CTL_SERVER */
};
 
static root_model_getfn_t meshx_ven_root_model_getfn[] = {};
 
static uint16_t meshx_sig_root_model_arr_len = MESHX_ARRAY_SIZE(meshx_sig_root_model_getfn);
static uint16_t meshx_ven_root_model_arr_len = MESHX_ARRAY_SIZE(meshx_ven_root_model_getfn);

MESHX_MODEL * get_root_sig_models(void)
{
    meshx_err_t err;
    static MESHX_MODEL temp_model;
    if(meshx_sig_root_model_arr == NULL && meshx_sig_root_model_arr_len)
    {
        meshx_sig_root_model_arr = (MESHX_MODEL *) MESHX_MALLOC(sizeof(MESHX_MODEL) * meshx_sig_root_model_arr_len);
        if(meshx_sig_root_model_arr == NULL)
        {
            MESHX_LOGE(MODULE_ID_COMMON, "Failed to allocate memory for root models");
            return NULL;
        }
        memset(meshx_sig_root_model_arr, 0, sizeof(MESHX_MODEL) * meshx_sig_root_model_arr_len);
 
        for(uint16_t i = 0; i < meshx_sig_root_model_arr_len; i++)
        {
            if(meshx_sig_root_model_getfn[i] == NULL)
            {
                continue;
            }
            err = meshx_sig_root_model_getfn[i]((void**)&temp_model);
            if (err != MESHX_SUCCESS)
            {
                MESHX_LOGE(MODULE_ID_COMMON, "Failed to get root model (%p) (%d)", meshx_sig_root_model_getfn[i], err);
                return NULL;
            }
            memcpy(&meshx_sig_root_model_arr[i], &temp_model, sizeof(MESHX_MODEL));
        }
    }
    return meshx_sig_root_model_arr;
}

MESHX_MODEL * get_root_ven_models(void)
{
    static MESHX_MODEL temp_model;
    if(meshx_ven_root_model_arr == NULL && meshx_ven_root_model_arr_len)
    {
        meshx_ven_root_model_arr = (MESHX_MODEL *) MESHX_MALLOC(sizeof(MESHX_MODEL) * meshx_ven_root_model_arr_len);
        if(meshx_ven_root_model_arr == NULL)
        {
            MESHX_LOGE(MODULE_ID_COMMON, "Failed to allocate memory for root models");
            return NULL;
        }
        memset(meshx_ven_root_model_arr, 0, sizeof(MESHX_MODEL) * meshx_ven_root_model_arr_len);
 
        for(uint16_t i = 0; i < meshx_ven_root_model_arr_len; i++)
        {
            if(meshx_ven_root_model_getfn[i] == NULL)
            {
                continue;
            }
            meshx_ven_root_model_getfn[i]((void**)&temp_model);
            memcpy(&meshx_ven_root_model_arr[i], &temp_model, sizeof(MESHX_MODEL));
        }
    }
    return meshx_ven_root_model_arr;
}

size_t get_root_sig_models_count(void)
{
    return meshx_sig_root_model_arr_len;
}

size_t get_root_ven_models_count(void)
{
    return meshx_ven_root_model_arr_len;
}

meshx_err_t meshx_create_element_composition(dev_struct_t *p_dev, meshx_config_t const *config)
{
#if CONFIG_MAX_ELEMENT_COUNT > 0
    meshx_err_t err;
#if CONFIG_SECTION_ENABLE_ELEMENT_TABLE
    element_comp_table_t *element_comp_table;
#endif /* CONFIG_SECTION_ENABLE_ELEMENT_TABLE */
    if(!p_dev || !config || !config->element_comp_arr_len || !config->element_comp_arr)
        return MESHX_INVALID_ARG;
 
    err = meshx_init_config_server();
    MESHX_ERR_PRINT_RET("Failed to initialize config server", err);
    for(uint16_t element_id = 0; element_id < config->element_comp_arr_len; element_id++)
    {
#if !CONFIG_SECTION_ENABLE_ELEMENT_TABLE
        if(config->element_comp_arr[element_id].element_cnt != 0
        && element_comp_fn[config->element_comp_arr[element_id].type] != NULL)
        {
            err = element_comp_fn[config->element_comp_arr[element_id].type](p_dev, config->element_comp_arr[element_id].element_cnt);
            if(err)
            {
                MESHX_LOGE(MODULE_ID_COMMON, "Element composition failed: (%d)", err);
                return err;
            }
        }
#else
        element_comp_table = &MESHX_ELEMENT_COMP_TABLE_START;
        while(element_comp_table < &MESHX_ELEMENT_COMP_TABLE_STOP)
        {
            if(element_comp_table->idx == element_id && config->element_comp_arr[element_id].element_cnt != 0)
            {
                err = element_comp_table->element_comp_fn(p_dev, config->element_comp_arr[element_id].element_cnt);
                if(err)
                {
                    MESHX_LOGE(MODULE_ID_COMMON, "Element composition failed: (%d)", err);
                    return err;
                }
            }
            element_comp_table++;
        }
#endif /* CONFIG_SECTION_ENABLE_ELEMENT_TABLE */
    }
#endif /* CONFIG_MAX_ELEMENT_COUNT */
    return err;
}