meshx_cwww_server.c

Go to the documentation of this file.

 
#include <meshx_cwww_server_element.h>
#include <meshx_nvs.h>
#include <meshx_api.h>
 
#if CONFIG_LIGHT_CWWW_SRV_COUNT > 0
 
#if CONFIG_ENABLE_CONFIG_SERVER
#include "meshx_config_server.h"

#define CONFIG_SERVER_CB_MASK    \
    CONTROL_TASK_MSG_EVT_PUB_ADD \
    | CONTROL_TASK_MSG_EVT_SUB_ADD | CONTROL_TASK_MSG_EVT_APP_KEY_BIND
#endif /* CONFIG_ENABLE_CONFIG_SERVER */
 
#define CONTROL_TASK_EVT_MASK                   \
    CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF \
    | CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_CTL
 
#define CONTROL_TASK_MSG_EVT_TO_BLE_GEN_SRV_MASK \
    CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF_SRV   \
    | CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL_SRV
 
#define GET_RELATIVE_EL_IDX(_element_id) _element_id - cwww_element_init_ctrl.element_id_start
#define IS_EL_IN_RANGE(_element_id) (_element_id >= cwww_element_init_ctrl.element_id_start && _element_id < cwww_element_init_ctrl.element_id_end)
#define CWWW_SRV_EL(_el_id)          cwww_element_init_ctrl.el_list[_el_id]
 
#define CWWW_TEMP_MIN 2700
#define CWWW_TEMP_MAX 6500
 
static meshx_cwww_elements_ctrl_t cwww_element_init_ctrl;
 
#if CONFIG_ENABLE_CONFIG_SERVER
static meshx_err_t cwww_server_config_srv_cb(
    const dev_struct_t *pdev,
    control_task_msg_evt_t evt,
    const meshx_config_srv_cb_param_t *params)
{
    MESHX_UNUSED(pdev);
    meshx_cwww_server_ctx_t *el_ctx = NULL;
    size_t rel_el_id = 0;
    uint16_t element_id = 0;
    bool nvs_save = false;
    uint16_t base_el_id = 0;
    meshx_get_base_element_id(&base_el_id);
 
    switch (evt)
    {
    case CONTROL_TASK_MSG_EVT_APP_KEY_BIND:
        element_id = params->state_change.mod_app_bind.element_addr - base_el_id;
        if (!IS_EL_IN_RANGE(element_id))
            break;
        rel_el_id = GET_RELATIVE_EL_IDX(element_id);
        el_ctx = CWWW_SRV_EL(rel_el_id).srv_ctx;
        el_ctx->app_id = params->state_change.appkey_add.app_idx;
        nvs_save = true;
 
        break;
    case CONTROL_TASK_MSG_EVT_PUB_ADD:
    case CONTROL_TASK_MSG_EVT_PUB_DEL:
        element_id = params->state_change.mod_pub_set.element_addr - base_el_id;
        if (!IS_EL_IN_RANGE(element_id))
            break;
        rel_el_id = GET_RELATIVE_EL_IDX(element_id);
        el_ctx = CWWW_SRV_EL(rel_el_id).srv_ctx;
        el_ctx->pub_addr = evt == CONTROL_TASK_MSG_EVT_PUB_ADD ? params->state_change.mod_pub_set.pub_addr
                                                               : MESHX_ADDR_UNASSIGNED;
        el_ctx->app_id = params->state_change.mod_pub_set.app_idx;
        nvs_save = true;
        MESHX_LOGI(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "PUB_ADD: %d, %d, 0x%X, 0x%X", element_id, rel_el_id, el_ctx->pub_addr, el_ctx->app_id);
        break;
    default:
        break;
    }
    if (nvs_save)
    {
        meshx_err_t err = meshx_nvs_element_ctx_set(element_id, el_ctx, sizeof(meshx_cwww_server_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to set cwww server element context: (%d)", err);
        }
    }
    return MESHX_SUCCESS;
}
#endif /* CONFIG_ENABLE_CONFIG_SERVER */

static meshx_err_t meshx_element_struct_init(uint16_t n_max)
{
    if (!n_max)
        return MESHX_INVALID_ARG;
 
    if (cwww_element_init_ctrl.el_list)
    {
        MESHX_LOGW(MODULE_ID_MODEL_SERVER, "CWWW element list already initialized");
        return MESHX_INVALID_STATE;
    }
    meshx_err_t err = MESHX_SUCCESS;
 
    cwww_element_init_ctrl.element_cnt = n_max;
    cwww_element_init_ctrl.element_id_end = 0;
    cwww_element_init_ctrl.element_id_start = 0;
 
    cwww_element_init_ctrl.el_list =
        (meshx_cwww_element_t *)MESHX_CALOC(cwww_element_init_ctrl.element_cnt, sizeof(meshx_cwww_element_t));
 
    if (!cwww_element_init_ctrl.el_list)
        return MESHX_NO_MEM;
 
    for (size_t i = 0; i < cwww_element_init_ctrl.element_cnt; i++)
    {
        CWWW_SRV_EL(i).srv_ctx =
            (meshx_cwww_server_ctx_t *)MESHX_CALOC(1, sizeof(meshx_cwww_server_ctx_t));
 
        if (!CWWW_SRV_EL(i).srv_ctx)
            return MESHX_NO_MEM;
 
        err = meshx_on_off_server_create(&CWWW_SRV_EL(i).onoff_srv_model,
                                         &CWWW_SRV_EL(i).cwww_srv_model_list[CWWW_SIG_ONOFF_MODEL_ID]);
        if (err)
        {
            MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Meshx On Off Server create failed (Err : 0x%x)", err);
            return err;
        }
        err = meshx_light_ctl_server_create(&CWWW_SRV_EL(i).ctl_srv_model,
                                            &CWWW_SRV_EL(i).cwww_srv_model_list[CWWW_SIG_L_CTL_MODEL_ID]);
        if (err)
        {
            MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Meshx CTL Server create failed (Err : 0x%x)", err);
            return err;
        }
        CWWW_SRV_EL(i).onoff_srv_model->meshx_sig = &CWWW_SRV_EL(i).cwww_srv_model_list[CWWW_SIG_ONOFF_MODEL_ID];
        CWWW_SRV_EL(i).ctl_srv_model->meshx_sig = &CWWW_SRV_EL(i).cwww_srv_model_list[CWWW_SIG_L_CTL_MODEL_ID];
    }
    return MESHX_SUCCESS;
}

 
static meshx_err_t meshx_element_struct_deinit()
{
    if (!cwww_element_init_ctrl.element_cnt || !cwww_element_init_ctrl.el_list)
        return MESHX_INVALID_STATE;
 
    meshx_err_t err = MESHX_SUCCESS;
 
    for (size_t i = 0; i < cwww_element_init_ctrl.element_cnt; i++)
    {
        if (CWWW_SRV_EL(i).srv_ctx)
        {
            MESHX_FREE(CWWW_SRV_EL(i).srv_ctx);
            CWWW_SRV_EL(i).srv_ctx = NULL;
        }
 
        err = meshx_on_off_server_delete(&CWWW_SRV_EL(i).onoff_srv_model);
        if (err)
        {
            MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Meshx On Off Server create failed (Err : 0x%x)", err);
            return err;
        }
 
        err = meshx_light_ctl_server_delete(&CWWW_SRV_EL(i).ctl_srv_model);
        if (err)
        {
            MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Meshx CTL Server create failed (Err : 0x%x)", err);
            return err;
        }
    }
 
    MESHX_FREE(cwww_element_init_ctrl.el_list);
    cwww_element_init_ctrl.el_list = NULL;
 
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_dev_create_cwww_model_space(uint16_t n_max)
{
    meshx_err_t err = meshx_element_struct_init(n_max);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to initialize cwww element structures: (%d)", err);
        meshx_element_struct_deinit();
        return err;
    }
    return err;
}

static meshx_err_t meshx_restore_model_states(uint16_t element_id)
{
    meshx_err_t err = MESHX_SUCCESS;
    meshx_cwww_server_ctx_t const *el_ctx = CWWW_SRV_EL(element_id).srv_ctx;
 
    for (size_t i = 0; i < CWWW_SRV_MODEL_SIG_CNT; i++)
    {
        if (i == CWWW_SIG_ONOFF_MODEL_ID)
        {
            err = meshx_gen_on_off_srv_state_restore(CWWW_SRV_EL(element_id).onoff_srv_model->meshx_sig,
                                                     el_ctx->prev_state);
            if (err)
            {
                MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to restore on-off server state (err: 0x%x)", err);
                return err;
            }
        }
        else if (i == CWWW_SIG_L_CTL_MODEL_ID)
        {
            err = meshx_light_ctl_srv_state_restore(CWWW_SRV_EL(element_id).ctl_srv_model,
                                                    el_ctx->prev_ctl_state);
            if (err)
            {
                MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to restore on-off server state (err: 0x%x)", err);
                return err;
            }
        }
        else
        {
            MESHX_DO_NOTHING;
        }
    }
    return err;
}

static meshx_err_t meshx_add_cwww_srv_model_to_element_list(dev_struct_t *pdev, uint16_t *start_idx, uint16_t n_max)
{
    if (!pdev)
        return MESHX_INVALID_STATE;
 
    if (!start_idx || (n_max + *start_idx) > CONFIG_MAX_ELEMENT_COUNT)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "No of elements limit reached");
        return MESHX_NO_MEM;
    }
    meshx_err_t err = MESHX_SUCCESS;
    cwww_element_init_ctrl.element_id_start = *start_idx;
 
    for (uint16_t i = *start_idx; i < (n_max + *start_idx); i++)
    {
        if (i == 0)
            continue;
 
        err = meshx_plat_add_element_to_composition(
            i,
            pdev->elements,
            CWWW_SRV_EL(i - *start_idx).cwww_srv_model_list,
            NULL,
            CWWW_SRV_MODEL_SIG_CNT,
            CWWW_SRV_MODEL_VEN_CNT);
        if (err)
        {
            MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to add element to composition: (%d)", err);
            return err;
        }
 
        err = meshx_nvs_element_ctx_get(
            i,
            CWWW_SRV_EL(i - *start_idx).srv_ctx,
            sizeof(meshx_cwww_server_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGW(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to get cwww element context: (0x%x)", err);
        }
        else
        {
            err = meshx_restore_model_states(i - *start_idx);
            if (err != MESHX_SUCCESS)
            {
                MESHX_LOGW(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to restore cwww model states: (0x%x)", err);
            }
        }
    }
    /* Increment the index for further registrations */
    cwww_element_init_ctrl.element_id_end = *start_idx += n_max;
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_api_control_task_handler(const dev_struct_t *pdev, const control_task_msg_evt_t evt, const void *params)
{
    MESHX_UNUSED(pdev);
    meshx_err_t err = MESHX_SUCCESS;
    uint16_t element_id = 0;
    size_t rel_el_id;
    meshx_cwww_server_ctx_t *el_ctx = NULL;
    meshx_api_light_cwww_server_evt_t app_msg;
    cwww_sig_id_t sig_func = CWWW_SIG_ONOFF_MODEL_ID;
 
    switch (evt)
    {
    case CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF:
    {
        const meshx_on_off_srv_el_msg_t *p_onoff_srv = (const meshx_on_off_srv_el_msg_t *)params;
        element_id = p_onoff_srv->model.el_id;
        if (!IS_EL_IN_RANGE(element_id))
            goto el_ctrl_task_hndlr_exit;
 
        rel_el_id = GET_RELATIVE_EL_IDX(element_id);
        el_ctx = CWWW_SRV_EL(rel_el_id).srv_ctx;
        if (el_ctx->prev_state.on_off == p_onoff_srv->on_off_state)
            goto el_ctrl_task_hndlr_exit;
 
        sig_func = CWWW_SIG_ONOFF_MODEL_ID;
        el_ctx->prev_state.on_off = p_onoff_srv->on_off_state;
        app_msg.state_change.on_off.state = el_ctx->prev_state.on_off;
        break;
    }
 
    case CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_CTL:
    {
        const meshx_light_ctl_srv_t *p_ctl_srv = (const meshx_light_ctl_srv_t *)params;
        element_id = p_ctl_srv->model.el_id;
        if (!IS_EL_IN_RANGE(element_id))
            goto el_ctrl_task_hndlr_exit;
 
        rel_el_id = GET_RELATIVE_EL_IDX(element_id);
        el_ctx = CWWW_SRV_EL(rel_el_id).srv_ctx;
 
        if (memcmp(&el_ctx->prev_ctl_state, &p_ctl_srv->state, sizeof(meshx_light_ctl_srv_state_t)) == 0)
            goto el_ctrl_task_hndlr_exit;
 
        el_ctx->prev_ctl_state.delta_uv              = p_ctl_srv->state.delta_uv;
        el_ctx->prev_ctl_state.lightness             = p_ctl_srv->state.lightness;
        el_ctx->prev_ctl_state.temperature           = p_ctl_srv->state.temperature;
        el_ctx->prev_ctl_state.temperature_range_min = p_ctl_srv->state.temperature_range_min;
        el_ctx->prev_ctl_state.temperature_range_max = p_ctl_srv->state.temperature_range_max;
 
        sig_func = CWWW_SIG_L_CTL_MODEL_ID;
        app_msg.state_change.ctl.delta_uv            = el_ctx->prev_ctl_state.delta_uv;
        app_msg.state_change.ctl.lightness           = el_ctx->prev_ctl_state.lightness;
        app_msg.state_change.ctl.temperature         = el_ctx->prev_ctl_state.temperature;
        app_msg.state_change.ctl.temp_range_min      = el_ctx->prev_ctl_state.temperature_range_min;
        app_msg.state_change.ctl.temp_range_max      = el_ctx->prev_ctl_state.temperature_range_max;
        break;
    }
    default:
        break;
    }
 
    err = meshx_nvs_element_ctx_set(element_id, el_ctx, sizeof(meshx_cwww_server_ctx_t));
    if (err != MESHX_SUCCESS)
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to set relay element context: (%d)", err);
 
    err = meshx_send_msg_to_app(element_id,
                                MESHX_ELEMENT_TYPE_LIGHT_CWWW_SERVER,
                                (uint16_t)sig_func,
                                sizeof(meshx_api_light_cwww_server_evt_t),
                                &app_msg);
 
    if (err != MESHX_SUCCESS)
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to send relay state change message: (%d)", err);
 
el_ctrl_task_hndlr_exit:
    return MESHX_SUCCESS;
}

static meshx_err_t cwww_prov_control_task_handler(dev_struct_t const *pdev, control_task_msg_evt_t evt, void const *params)
{
    MESHX_UNUSED(params);
 
    size_t rel_el_id = 0;
    meshx_err_t err = MESHX_SUCCESS;
    meshx_gen_srv_cb_param_t gen_srv_send;
    meshx_lighting_server_cb_param_t light_srv_send;
 
    switch(evt)
    {
        case CONTROL_TASK_MSG_EVT_EN_NODE_PROV:
            for (size_t el_id = cwww_element_init_ctrl.element_id_start; el_id < cwww_element_init_ctrl.element_id_end; el_id++)
            {
                rel_el_id = GET_RELATIVE_EL_IDX(el_id);
 
                err = meshx_gen_on_off_srv_send_pack_create(
                        CWWW_SRV_EL(rel_el_id).onoff_srv_model->meshx_sig,
                        (uint16_t)el_id,
                        pdev->meshx_store.net_key_id,
                        CWWW_SRV_EL(rel_el_id).srv_ctx->app_id,
                        CWWW_SRV_EL(rel_el_id).srv_ctx->pub_addr,
                        CWWW_SRV_EL(rel_el_id).srv_ctx->prev_state.on_off,
                        &gen_srv_send
                    );
 
                if ((err != MESHX_SUCCESS)
                || (gen_srv_send.ctx.dst_addr == MESHX_ADDR_UNASSIGNED)
                || (gen_srv_send.ctx.app_idx == MESHX_KEY_UNUSED))
                    continue;
 
                err = meshx_gen_srv_send_msg_to_ble(
                    CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF_SRV,
                    &gen_srv_send
                );
 
                if (err)
                {
                    MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to send ONOFF status message (Err: %x)", err);
                    return err;
                }
 
                err = meshx_light_ctl_srv_send_pack_create(
                        CWWW_SRV_EL(rel_el_id).ctl_srv_model->meshx_sig,
                        (uint16_t)el_id,
                        pdev->meshx_store.net_key_id,
                        CWWW_SRV_EL(rel_el_id).srv_ctx->app_id,
                        CWWW_SRV_EL(rel_el_id).srv_ctx->pub_addr,
                        CWWW_SRV_EL(rel_el_id).srv_ctx->prev_ctl_state,
                        &light_srv_send
                    );
 
                if ((err != MESHX_SUCCESS)
                || (light_srv_send.ctx.dst_addr == MESHX_ADDR_UNASSIGNED)
                || (light_srv_send.ctx.app_idx == MESHX_KEY_UNUSED))
                    continue;
 
                err = meshx_gen_light_srv_send_msg_to_ble(
                    CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL_SRV,
                    &light_srv_send
                );
                if (err)
                {
                    MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to send CTL status message (Err: %x)", err);
                    return err;
                }
            }
            break;
        default:
            MESHX_LOGW(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Unhandled event: %d", evt);
            err = MESHX_INVALID_STATE;
            break;
    }
 
    return err;
}

static meshx_err_t meshx_cwww_srv_msg_send_handler(
                    const dev_struct_t *pdev,
                    control_task_msg_evt_to_ble_t evt,
                    void *params)
{
    MESHX_UNUSED(pdev);
    if((evt & (CONTROL_TASK_MSG_EVT_TO_BLE_GEN_SRV_MASK)) == 0)
        return MESHX_SUCCESS;
    uint16_t element_id = 0;
    meshx_err_t err = MESHX_SUCCESS;
    static meshx_gen_srv_cb_param_t *gen_srv_send = NULL;
    static meshx_lighting_server_cb_param_t *light_srv_send = NULL;
    switch (evt)
    {
        case CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF_SRV:
        {
            gen_srv_send = (meshx_gen_srv_cb_param_t *)params;
            element_id = gen_srv_send->model.el_id;
            if (!IS_EL_IN_RANGE(element_id))
                goto cwww_srv_msg_handler_exit;
            err = meshx_gen_on_off_srv_status_send(
                &gen_srv_send->model,
                &gen_srv_send->ctx,
                gen_srv_send->state_change.onoff_set.onoff
            );
            if (err)
            {
                MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to send ONOFF status message (Err: %x)", err);
                return err;
            }
        }
        break;
        case CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL_SRV:
        {
            light_srv_send = (meshx_lighting_server_cb_param_t *)params;
            element_id = light_srv_send->model.el_id;
            if (!IS_EL_IN_RANGE(element_id))
                goto cwww_srv_msg_handler_exit;
            err = meshx_light_ctl_srv_status_send(
                &light_srv_send->model,
                &light_srv_send->ctx,
                light_srv_send->state_change.ctl_set.delta_uv,
                light_srv_send->state_change.ctl_set.lightness,
                light_srv_send->state_change.ctl_set.temperature
            );
            if (err)
            {
                MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to send CTL status message (Err: %x)", err);
                return err;
            }
        }
        break;
        default:
            MESHX_LOGW(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Unhandled event: %d", evt);
            err = MESHX_INVALID_STATE;
        }
cwww_srv_msg_handler_exit:
    return err;
}

meshx_err_t meshx_create_cwww_elements(dev_struct_t *pdev, uint16_t element_cnt)
{
    meshx_err_t err;
    err = meshx_dev_create_cwww_model_space(element_cnt);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "CWWW Model create failed: (%d)", err);
        return err;
    }
    err = meshx_add_cwww_srv_model_to_element_list(pdev, (uint16_t *)&pdev->element_idx, element_cnt);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "CWWW Model create failed: (%d)", err);
        return err;
    }
#if CONFIG_ENABLE_CONFIG_SERVER
    err = meshx_config_server_cb_reg(
        (config_srv_cb_t)&cwww_server_config_srv_cb, CONFIG_SERVER_CB_MASK);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Relay Model configserver callback reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_CONFIG_SERVER */
    err = control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_EL_STATE_CH,
        CONTROL_TASK_EVT_MASK,
        (control_task_msg_handle_t)&meshx_api_control_task_handler);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to register control task callback: (%d)", err);
        return err;
    }
 
    err = meshx_prov_srv_reg_el_server_cb((prov_srv_cb_t)&cwww_prov_control_task_handler);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to register control task callback: (%d)", err);
        return err;
    }
    err = control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        CONTROL_TASK_MSG_EVT_TO_BLE_GEN_SRV_MASK,
        (control_task_msg_handle_t)&meshx_cwww_srv_msg_send_handler);
    if (err)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "Failed to register control task callback: (%d)", err);
        return err;
    }
    err = meshx_on_off_server_init();
    if (err)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "meshx_on_off_server_init failed: (%d)", err);
        return err;
    }
    err = meshx_light_ctl_server_init();
    if (err)
    {
        MESHX_LOGE(MODULE_ID_ELEMENT_SWITCH_RELAY_SERVER, "meshx_light_ctl_server_init failed: (%d)", err);
        return err;
    }
    return MESHX_SUCCESS;
}
 
REG_MESHX_ELEMENT_FN(cwww_srv_el, MESHX_ELEMENT_TYPE_LIGHT_CWWW_SERVER, meshx_create_cwww_elements);
 
#endif /* CONFIG_LIGHT_CWWW_SRV_COUNT > 0*/