meshx.c

Go to the documentation of this file.

#include "meshx.h"

#define ROOT_ELEMENT_IDX 0

#define FRESHBOOT_TIMEOUT_MS 1500
 

static const char meshX_banner[] = {
"*********************************************************************************************************************\n"
"* MMMMMMMM               MMMMMMMM                                     hhhhhhh                 XXXXXXX       XXXXXXX *\n"
"* M:::::::M             M:::::::M                                     h:::::h                 X:::::X       X:::::X *\n"
"* M::::::::M           M::::::::M                                     h:::::h                 X:::::X       X:::::X *\n"
"* M:::::::::M         M:::::::::M                                     h:::::h                 X::::::X      X:::::X *\n"
"* M::::::::::M       M::::::::::M    eeeeeeeeeeee        ssssssssss   h:::: hhhhhh            XX:::::X     X:::::XX *\n"
"* M:::::::::::M     M:::::::::::M  ee::::::::::::ee    ss::::::::::s  h::::::::::hhh            X:::::X   X:::::X   *\n"
"* M:::::::M::::M   M::::M:::::::M e::::::eeeee:::::eess:::::::::::::s h::::::::::::::hh           X:::::X:::::X     *\n"
"* M::::::M M::::M M::::M M::::::Me::::::e     e:::::es::::::ssss:::::sh:::::::hhh::::::h           X:::::::::X      *\n"
"* M::::::M  M::::M::::M  M::::::Me:::::::eeeee::::::e s:::::s  ssssss h::::::h   h::::::h          X:::::::::X      *\n"
"* M::::::M   M:::::::M   M::::::Me:::::::::::::::::e    s::::::s      h:::::h     h:::::h         X:::::X:::::X     *\n"
"* M::::::M    M:::::M    M::::::Me::::::eeeeeeeeeee        s::::::s   h:::::h     h:::::h        X:::::X X:::::X    *\n"
"* M::::::M     MMMMM     M::::::Me:::::::e           ssssss   s:::::s h:::::h     h:::::h     XXX:::::X   X:::::XXX *\n"
"* M::::::M               M::::::Me::::::::e          s:::::ssss::::::sh:::::h     h:::::h     X::::::X     X::::::X *\n"
"* M::::::M               M::::::M e::::::::eeeeeeee  s::::::::::::::s h:::::h     h:::::h     X:::::X       X:::::X *\n"
"* M::::::M               M::::::M  ee:::::::::::::e   s:::::::::::ss  h:::::h     h:::::h     X:::::X       X:::::X *\n"
"* MMMMMMMM               MMMMMMMM    eeeeeeeeeeeeee    sssssssssss    hhhhhhh     hhhhhhh     XXXXXXX       XXXXXXX *\n"
"*********************************************************************************************************************\n"
};
 
static dev_struct_t g_dev;
 
static meshx_config_t g_config;
 
meshx_prov_params_t g_prov_cfg = {
    .uuid = MESHX_UUID_EMPTY,  
    .node_name = NULL           
};
 
extern size_t get_root_sig_models_count(void);
extern size_t get_root_ven_models_count(void);
extern meshx_ptr_t get_root_sig_models(void);
extern meshx_ptr_t get_root_ven_models(void);
extern meshx_err_t meshx_create_element_composition(dev_struct_t *p_dev, meshx_config_t const *config);

static meshx_err_t meshx_element_init(dev_struct_t *p_dev, meshx_config_t const *config)
{
    if (!p_dev)
        return MESHX_INVALID_STATE;
 
    meshx_err_t err = MESHX_SUCCESS;
    meshx_ptr_t meshx_sig_root_model_arr = NULL;
    meshx_ptr_t meshx_ven_root_model_arr = NULL;
 
    err = meshx_create_plat_composition(&p_dev->composition);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Failed to create platform composition: (%d)", err);
        return err;
    }
 
    /* Start with element index 1 as 0 is root element */
    p_dev->element_idx = 1;
 
    err = meshx_create_element_composition(p_dev, config);
    if(err)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Failed to create BLE Mesh Element Composition: (%d)", err);
        return err;
    }
    err = meshx_plat_composition_init(
        p_dev->composition,
        p_dev->elements,
        config->cid,
        config->pid,
        (uint16_t)p_dev->element_idx
    );
    if(err)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Failed to initialise MeshX Composition: (%d)", err);
        return err;
    }
 
    meshx_sig_root_model_arr = get_root_sig_models();
    if(meshx_sig_root_model_arr == NULL)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Failed to get root SIG models");
        return MESHX_FAIL;
    }

    err = meshx_plat_add_element_to_composition(
        ROOT_ELEMENT_IDX,
        p_dev->elements,
        meshx_sig_root_model_arr,
        meshx_ven_root_model_arr,
        (uint8_t) get_root_sig_models_count(),
        (uint8_t) get_root_ven_models_count()
    );
    if(err)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Failed to add element to composition: (%d)", err);
        return err;
    }
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_tasks_init(dev_struct_t * pdev)
{
    meshx_err_t err;
 
    err = create_control_task(pdev);
    MESHX_ERR_PRINT_RET("Failed to create control task", err);
 
#if CONFIG_TXCM_ENABLE
    err = meshx_txcm_init(pdev);
    MESHX_ERR_PRINT_RET("Failed to create Tx Control Module", err);
#endif /* CONFIG_TXCM_ENABLE */
    return err;
}

static meshx_err_t meshx_dev_restore(dev_struct_t *pdev, meshx_config_t const *config)
{
    meshx_err_t err = MESHX_SUCCESS;
 
    err = meshx_nvs_open(config->cid, config->pid, config->meshx_nvs_save_period);
    MESHX_ERR_PRINT_RET("MeshX NVS Open failed", err);
 
    err = meshx_nvs_get(MESHX_NVS_STORE, &pdev->meshx_store, sizeof(meshx_app_store_t));
        MESHX_ERR_PRINT_RET("Failed to restore meshx device state", err);
 
    return err;
}

static meshx_err_t meshx_ble_mesh_init(meshx_config_t *config)
{
    if(config == NULL || config->product_name == NULL)
        return MESHX_INVALID_ARG;
 
    meshx_err_t err;
    g_prov_cfg.node_name = (uint8_t *)config->product_name;
 
    err = meshx_platform_bt_init(config->meshx_uuid_addr);
    MESHX_ERR_PRINT_RET("Platform BT init failed", err);
 
    g_prov_cfg.uuid = config->meshx_uuid_addr;
    g_prov_cfg.freshboot_timeout_ms = FRESHBOOT_TIMEOUT_MS;
 
    meshx_dev_restore(&g_dev, config);
 
    err = meshx_element_init(&g_dev, config);
    MESHX_ERR_PRINT_RET("Failed to initialize BLE Elements", err);
 
    err = meshx_init_prov(&g_dev, &g_prov_cfg);
    MESHX_ERR_PRINT_RET("Failed to initialize provisioning", err);
 
    err = meshx_plat_ble_mesh_init(&g_prov_cfg, g_dev.composition);
    MESHX_ERR_PRINT_RET("Failed to initialize BLE Mesh stack", err);
 
    return MESHX_SUCCESS;
}

meshx_err_t meshx_init(meshx_config_t const *config)
{
    /* Check if the configuration is valid */
    if(!config)
        return MESHX_INVALID_ARG;
 
    meshx_err_t err = MESHX_SUCCESS;
 
    /* Copy the configuration to the global config structure */
    memcpy(&g_config, config, sizeof(meshx_config_t));
 
    meshx_logging_t logging_cfg;
 
    logging_cfg.def_log_level = config->meshx_log_level == MESHX_LOG_VERBOSE ?
        CONFIG_MESHX_DEFAULT_LOG_LEVEL : config->meshx_log_level;
 
    err = meshx_logging_init(&logging_cfg);
    MESHX_ERR_PRINT_RET("Logging init failed", err);
 
    /* Initialise Platform deps */
    err = meshx_platform_init();
    MESHX_ERR_PRINT_RET("Platform init failed", err);
 
    /* Initialize OS timer */
    err = meshx_os_timer_init();
    MESHX_ERR_PRINT_RET("OS Timer Init failed", err);
 
    /* Initialize MeshX NVS */
    err = meshx_nvs_init();
    MESHX_ERR_PRINT_RET("MeshX NVS Init failed", err);
 
    /* Initialize application tasks */
    err = meshx_tasks_init(&g_dev);
    MESHX_ERR_PRINT_RET("Tasks initialization failed", err);
 
    /* Register application element callback */
    err = meshx_app_reg_element_callback(g_config.app_element_cb);
    MESHX_ERR_PRINT_RET("Failed to register app element callback", err);
 
    /* Register application control callback */
    err = meshx_app_reg_system_events_callback(g_config.app_ctrl_cb);
    MESHX_ERR_PRINT_RET("Failed to register app control callback", err);
 
    /* Initialize the Bluetooth Mesh Subsystem */
    err = meshx_ble_mesh_init(&g_config);
    MESHX_ERR_PRINT_RET("Bluetooth mesh init failed", err);
 
    /* Print the MeshX banner */
    CONFIG_MESHX_LOG_PRINTF(LOG_ANSI_COLOR_REGULAR(LOG_ANSI_COLOR_CYAN) "%s" LOG_ANSI_COLOR_RESET, meshX_banner);
 
#if CONFIG_ENABLE_UNIT_TEST
    /* Register unit test command */
    err = register_ut_command();
    MESHX_ERR_PRINT_RET("Failed to register unit test command", err);
 
    /* Initialize unit test console */
    err = init_unit_test_console();
    MESHX_ERR_PRINT_RET("Failed to initialize production console", err);
#endif /* CONFIG_ENABLE_UNIT_TEST */
 
    return err;
}