meshx_light_ctl_srv.c

Go to the documentation of this file.

 
#include <meshx_light_ctl_srv.h>
 
#define MESHX_SERVER_INIT_MAGIC_NO 0x2483
 
#if CONFIG_ENABLE_LIGHT_CTL_SERVER

typedef struct meshx_light_ctl_setup_server
{
    uint16_t ctl_setup_server_init;
    MESHX_MODEL ctl_setup_srv_model;
    meshx_ctl_setup_server_model_t *meshx_srv_model;
}meshx_light_ctl_setup_server_t;

static struct
{
    uint16_t ctl_lighting_server_init;
    uint16_t ctl_lighting_server_created;
    meshx_light_ctl_setup_server_t ctl_setup_server;
}g_meshx_light_ctl_srv = {
    .ctl_setup_server = {
        .ctl_setup_server_init = 0,
        .meshx_srv_model = NULL,
    },
    .ctl_lighting_server_init = 0,
    .ctl_lighting_server_created = 0,
};

static meshx_err_t meshx_state_change_notify(meshx_lighting_server_cb_param_t *param)
{
    meshx_light_ctl_srv_t ctl_srv_params = {
        .model = param->model};
 
    if (MESHX_ADDR_IS_UNICAST(param->ctx.dst_addr) || (MESHX_ADDR_BROADCAST(param->ctx.dst_addr)) || (MESHX_ADDR_IS_GROUP(param->ctx.dst_addr) && (MESHX_SUCCESS == meshx_is_group_subscribed(param->model.p_model, param->ctx.dst_addr))))
    {
        switch (param->ctx.opcode)
        {
        case MESHX_MODEL_OP_LIGHT_CTL_SET:
        case MESHX_MODEL_OP_LIGHT_CTL_SET_UNACK:
            ctl_srv_params.state.delta_uv = param->state_change.ctl_set.delta_uv;
            ctl_srv_params.state.lightness = param->state_change.ctl_set.lightness;
            ctl_srv_params.state.temperature = param->state_change.ctl_set.temperature;
            break;
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_GET:
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_SET:
            ctl_srv_params.state.delta_uv = param->state_change.ctl_temp_set.delta_uv;
            ctl_srv_params.state.temperature = param->state_change.ctl_temp_set.temperature;
            break;
        default:
            return MESHX_NOT_SUPPORTED;
        }
        /* Send msg for hw manipulation */
        MESHX_LOGD(MODULE_ID_MODEL_SERVER, "HW change requested, Element_id: 0x%x",
                   param->model.el_id);
 
        meshx_err_t err = control_task_msg_publish(
            CONTROL_TASK_MSG_CODE_EL_STATE_CH,
            CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_CTL,
            &ctl_srv_params,
            sizeof(meshx_light_ctl_srv_t));
        return err;
    }
    return MESHX_NOT_SUPPORTED;
}

static meshx_err_t meshx_handle_light_ctl_msg(const dev_struct_t *pdev,
                                              const control_task_msg_evt_t evt,
                                              meshx_lighting_server_cb_param_t *param)
{
    if (!pdev || (evt != MESHX_MODEL_ID_LIGHT_CTL_SRV && evt != MESHX_MODEL_ID_LIGHT_CTL_SETUP_SRV))
        return MESHX_INVALID_ARG;
    meshx_err_t err = MESHX_SUCCESS;
 
    bool send_reply_to_src = false;
    bool state_change_notify = false;
    uint32_t op_code = param->ctx.opcode;
    uint32_t status_op = 0;
    switch (op_code)
    {
        case MESHX_MODEL_OP_LIGHT_CTL_STATUS:
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_STATUS:
        case MESHX_MODEL_OP_LIGHT_CTL_DEFAULT_STATUS:
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_STATUS:
            /* Ignore, as these are status messages */
            break;
        case MESHX_MODEL_OP_LIGHT_CTL_GET:
        case MESHX_MODEL_OP_LIGHT_CTL_SET:
        case MESHX_MODEL_OP_LIGHT_CTL_SET_UNACK:
            status_op = MESHX_MODEL_OP_LIGHT_CTL_STATUS;
            if (op_code != MESHX_MODEL_OP_LIGHT_CTL_GET)
                state_change_notify = true;
 
            if (op_code != MESHX_MODEL_OP_LIGHT_CTL_SET_UNACK)
                send_reply_to_src = true;
 
            break;
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_GET:
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_SET:
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_SET_UNACK:
            status_op = MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_STATUS;
            if (op_code != MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_GET)
                state_change_notify = true;
 
            if (op_code != MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_SET_UNACK)
                send_reply_to_src = true;
            break;
        case MESHX_MODEL_OP_LIGHT_CTL_DEFAULT_SET:
        case MESHX_MODEL_OP_LIGHT_CTL_DEFAULT_GET:
        case MESHX_MODEL_OP_LIGHT_CTL_DEFAULT_SET_UNACK:
            status_op = MESHX_MODEL_OP_LIGHT_CTL_DEFAULT_STATUS;
            if (op_code != MESHX_MODEL_OP_LIGHT_CTL_DEFAULT_GET)
                MESHX_DO_NOTHING;
 
            if (op_code != MESHX_MODEL_OP_LIGHT_CTL_DEFAULT_SET_UNACK)
                send_reply_to_src = true;
 
            break;
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_SET:
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_GET:
        case MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_SET_UNACK:
            status_op = MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_STATUS;
            if (op_code != MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_GET)
                MESHX_DO_NOTHING;
 
            if (op_code != MESHX_MODEL_OP_LIGHT_CTL_TEMPERATURE_RANGE_SET_UNACK)
                send_reply_to_src = true;
 
            break;
        default:
            MESHX_LOGW(MODULE_ID_MODEL_SERVER, "CTL Unhandled Event %p", (void *)param->ctx.opcode);
            break;
    }
    if (state_change_notify)
    {
        err = meshx_state_change_notify(param);
        if (err)
            return err;
    }
    if (send_reply_to_src
        /* This is meant to notify the respective publish client */
        || param->ctx.src_addr != param->model.pub_addr)
    {
        /* Here the message was received from unregistered source and mention the state to the respective client */
        MESHX_LOGD(MODULE_ID_MODEL_SERVER, "PUB: src|pub %x|%x", param->ctx.src_addr, param->model.pub_addr);
        param->ctx.opcode = (uint16_t)status_op;
        param->ctx.dst_addr = param->model.pub_addr;
 
        err = meshx_gen_light_srv_send_msg_to_ble(
            CONTROL_TASK_MSG_EVT_TO_BLE_SET_CTL_SRV,
            param
        );
    }
 
    return err;
}

static meshx_err_t meshx_light_ctl_setup_server_delete(void)
{
    if (g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model != NULL)
    {
        MESHX_FREE(g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model);
        g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model = NULL;
 
        meshx_plat_light_srv_delete(
            &(g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model->meshx_pub),
            &(g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model->meshx_gen)
        );
 
        g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model = NULL;
    }
 
    g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model = 0;
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_light_ctl_setup_server_create(void)
{
    meshx_err_t err = MESHX_SUCCESS;
    if  (   g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model != NULL
        ||  g_meshx_light_ctl_srv.ctl_setup_server.ctl_setup_server_init == MESHX_SERVER_INIT_MAGIC_NO)
        return MESHX_SUCCESS;
 
    g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model =
        (meshx_ctl_setup_server_model_t *)MESHX_CALOC(1, sizeof(meshx_ctl_setup_server_model_t));
    if (NULL == g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model)
    {
        return MESHX_NO_MEM;
    }
 
    err = meshx_plat_light_ctl_setup_srv_create(
        &g_meshx_light_ctl_srv.ctl_setup_server.ctl_setup_srv_model,
        &g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model->meshx_pub,
        &g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model->meshx_gen);
    if(err != MESHX_SUCCESS)
    {
        /* Tops down deinit for CTL setup server model */
        meshx_light_ctl_setup_server_delete();
        return err;
    }
    else
    {
        g_meshx_light_ctl_srv.ctl_lighting_server_init++;
    }
 
    return err;
}

meshx_err_t meshx_get_ctl_setup_srv_model(meshx_ptr_t p_model)
{
    if (!p_model)
        return MESHX_INVALID_ARG;
 
    if (g_meshx_light_ctl_srv.ctl_setup_server.meshx_srv_model == NULL)
        return MESHX_FAIL;
 
    memcpy(p_model, &g_meshx_light_ctl_srv.ctl_setup_server.ctl_setup_srv_model, sizeof(MESHX_MODEL));
    return MESHX_SUCCESS;
}

meshx_err_t meshx_light_ctl_server_init(void)
{
    meshx_err_t err = MESHX_SUCCESS;
 
    if (g_meshx_light_ctl_srv.ctl_setup_server.ctl_setup_server_init == MESHX_SERVER_INIT_MAGIC_NO)
        return MESHX_SUCCESS;
 
    g_meshx_light_ctl_srv.ctl_setup_server.ctl_setup_server_init = MESHX_SERVER_INIT_MAGIC_NO;
 
    err = meshx_lighting_srv_init();
    if (err)
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to initialize prod server");
 
    err = meshx_lighting_reg_cb(
        MESHX_MODEL_ID_LIGHT_CTL_SRV,
        (meshx_lighting_server_cb)&meshx_handle_light_ctl_msg
    );
    if (err)
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to initialize meshx_gen_srv_reg_cb (Err: %d)", err);
 
    err = meshx_lighting_reg_cb(
        MESHX_MODEL_ID_LIGHT_CTL_SETUP_SRV,
        (meshx_lighting_server_cb)&meshx_handle_light_ctl_msg
    );
    if (err)
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to initialize meshx_gen_srv_reg_cb (Err: %d)", err);
 
    return err;
}

meshx_err_t meshx_light_ctl_server_create(meshx_ctl_server_model_t **p_model, meshx_ptr_t p_sig_model)
{
    meshx_err_t err = MESHX_SUCCESS;
    if (!p_model || !p_sig_model)
    {
        return MESHX_INVALID_ARG;
    }
 
    *p_model = (meshx_ctl_server_model_t *)MESHX_CALOC(1, sizeof(meshx_ctl_server_model_t));
    if (!*p_model)
    {
        return MESHX_NO_MEM;
    }
 
    err = meshx_plat_light_ctl_srv_create(
        p_sig_model,
        &((*p_model)->meshx_pub),
        &((*p_model)->meshx_gen));
    if(err != MESHX_SUCCESS)
    {
        /* Tops down deinit for CTL server model */
        meshx_light_ctl_server_delete(p_model);
        return err;
    }
 
    if(     g_meshx_light_ctl_srv.ctl_lighting_server_created == 0
        &&  g_meshx_light_ctl_srv.ctl_setup_server.ctl_setup_server_init == 0)
    {
        MESHX_LOGI(MODULE_ID_MODEL_SERVER, "Creating CTL setup server model");
        /* Create CTL setup server */
        err = meshx_light_ctl_setup_server_create();
        if(err != MESHX_SUCCESS)
        {
            /* Tops down deinit for CTL server model */
            meshx_light_ctl_setup_server_delete();
            /* The code execution below is only possible if this is the very first model being created */
            meshx_light_ctl_server_delete(p_model);
            return err;
        }
        g_meshx_light_ctl_srv.ctl_setup_server.ctl_setup_server_init = MESHX_SERVER_INIT_MAGIC_NO;
    }
    else
    {
        g_meshx_light_ctl_srv.ctl_lighting_server_created++;
    }
 
    (*p_model)->meshx_sig = p_sig_model;
 
    return err;
}

meshx_err_t meshx_light_ctl_server_delete(meshx_ctl_server_model_t **p_model)
{
    if (p_model == NULL || *p_model == NULL)
    {
        return MESHX_INVALID_ARG;
    }
 
    meshx_plat_light_srv_delete(
        &((*p_model)->meshx_pub),
        &((*p_model)->meshx_gen));
 
    MESHX_FREE(*p_model);
    *p_model = NULL;
    if (g_meshx_light_ctl_srv.ctl_lighting_server_created == 0)
    {
        MESHX_LOGW(MODULE_ID_MODEL_SERVER, "Deleting CTL setup server model");
        /* Delete CTL setup server */
    }
    else
    {
        g_meshx_light_ctl_srv.ctl_lighting_server_created--;
    }
    return MESHX_SUCCESS;
}

meshx_err_t meshx_light_ctl_srv_state_restore(meshx_ctl_server_model_t *p_model, meshx_light_ctl_srv_state_t ctl_state)
{
    if (!p_model)
        return MESHX_INVALID_STATE;
 
    return meshx_plat_light_ctl_srv_restore(p_model->meshx_sig,
                                            ctl_state.delta_uv,
                                            ctl_state.lightness,
                                            ctl_state.temperature,
                                            ctl_state.temperature_range_max,
                                            ctl_state.temperature_range_min);
}

meshx_err_t meshx_light_ctl_srv_status_send( meshx_model_t *p_model,
                                             meshx_ctx_t *ctx,
                                             int16_t  delta_uv,
                                             uint16_t lightness,
                                             uint16_t temperature)
{
    if (!p_model)
    {
        return MESHX_INVALID_ARG;
    }
 
    meshx_lighting_server_state_change_t state_change = {
        .ctl_set = {
            .delta_uv = delta_uv,
            .lightness = lightness,
            .temperature = temperature
        }
    };
 
    meshx_err_t err = meshx_gen_light_srv_status_send(
        p_model,
        ctx,
        &state_change
    );
 
    if (err != MESHX_SUCCESS)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to send Light CTL status: %d", err);
    }
 
    return err;
}

meshx_err_t meshx_light_ctl_srv_send_pack_create(
    meshx_ptr_t p_model,
    uint16_t element_id,
    uint16_t net_idx,
    uint16_t app_idx,
    uint16_t pub_addr,
    meshx_light_ctl_srv_state_t ctl_state,
    meshx_lighting_server_cb_param_t *light_srv_send)
{
    if (!p_model || !light_srv_send)
    {
        return MESHX_INVALID_ARG;
    }
 
    memset(light_srv_send, 0, sizeof(meshx_lighting_server_cb_param_t));
    light_srv_send->ctx.net_idx = net_idx;
    light_srv_send->ctx.app_idx = app_idx;
    light_srv_send->ctx.src_addr = element_id;
    light_srv_send->ctx.dst_addr = pub_addr;
    light_srv_send->ctx.opcode = MESHX_MODEL_OP_LIGHT_CTL_STATUS;
    light_srv_send->ctx.p_ctx = NULL;
 
    light_srv_send->model.el_id = element_id;
    light_srv_send->model.p_model = p_model;
 
    light_srv_send->state_change.ctl_set.delta_uv = ctl_state.delta_uv;
    light_srv_send->state_change.ctl_set.lightness = ctl_state.lightness;
    light_srv_send->state_change.ctl_set.temperature = ctl_state.temperature;
 
    return MESHX_SUCCESS;
}
 
#endif /* CONFIG_ENABLE_LIGHT_CTL_SERVER */