meshx_onoff_server.c

Go to the documentation of this file.

#include "meshx_onoff_server.h"
 
#if CONFIG_ENABLE_GEN_ONOFF_SERVER
static meshx_err_t meshx_state_change_notify(meshx_gen_srv_cb_param_t *param)
{
    if (!param)
        return MESHX_INVALID_ARG;
 
    meshx_on_off_srv_el_msg_t srv_onoff_param = {
        .model = param->model,
        .on_off_state = param->state_change.onoff_set.onoff};
 
    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))))
    {
        meshx_err_t err = control_task_msg_publish(
            CONTROL_TASK_MSG_CODE_EL_STATE_CH,
            CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF,
            &srv_onoff_param,
            sizeof(meshx_on_off_srv_el_msg_t));
        return err ? err : MESHX_SUCCESS;
    }
    return MESHX_NOT_SUPPORTED;
}

static meshx_err_t meshx_handle_gen_onoff_msg(const dev_struct_t *pdev, control_task_msg_evt_t model_id, meshx_gen_srv_cb_param_t *param)
{
    MESHX_UNUSED(pdev);
    MESHX_LOGD(MODULE_ID_MODEL_SERVER, "op|src|dst:%04" PRIx32 "|%04x|%04x",
               param->ctx.opcode, param->ctx.src_addr, param->ctx.dst_addr);
    if (model_id != MESHX_MODEL_ID_GEN_ONOFF_SRV)
        return MESHX_INVALID_ARG;
 
    bool send_reply = (param->ctx.opcode != MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK);
    switch (param->ctx.opcode)
    {
    case MESHX_MODEL_OP_GEN_ONOFF_GET:
        break;
    case MESHX_MODEL_OP_GEN_ONOFF_SET:
    case MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK:
        meshx_state_change_notify(param);
        break;
    default:
        break;
    }
    if (send_reply
        /* 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 = MESHX_MODEL_OP_GEN_ONOFF_STATUS;
        param->ctx.dst_addr = param->model.pub_addr;
 
        return meshx_gen_srv_send_msg_to_ble(
            CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF_SRV,
            param);
    }
    return MESHX_SUCCESS;
}

meshx_err_t meshx_gen_on_off_srv_status_send(
    meshx_model_t *model,
    meshx_ctx_t *ctx,
    uint8_t on_off_state
)
{
    if (!model || !ctx)
    {
        return MESHX_INVALID_ARG;
    }
    ctx->opcode = MESHX_MODEL_OP_GEN_ONOFF_STATUS;
    meshx_gen_srv_state_change_t state_change = {
        .onoff_set = {
            .onoff = on_off_state
        }
    };
    return meshx_gen_srv_status_send(
            model,
            ctx,
            state_change,
            sizeof(meshx_state_change_gen_onoff_set_t)
    );
}
meshx_err_t meshx_on_off_server_init(void)
{
    meshx_err_t err = MESHX_SUCCESS;
#if CONFIG_ENABLE_SERVER_COMMON
    err = meshx_gen_srv_init();
    if (err)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to initialize meshx server");
    }
#endif /* CONFIG_ENABLE_SERVER_COMMON */
    err = meshx_gen_srv_reg_cb(
            MESHX_MODEL_ID_GEN_ONOFF_SRV,
            (meshx_server_cb)&meshx_handle_gen_onoff_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_on_off_server_create(meshx_onoff_server_model_t **p_model, void *p_sig_model)
{
    if (!p_model || !p_sig_model)
    {
        return MESHX_INVALID_ARG;
    }
 
    *p_model = (meshx_onoff_server_model_t *)MESHX_CALOC(1, sizeof(meshx_onoff_server_model_t));
    if (!*p_model)
    {
        return MESHX_NO_MEM;
    }
 
    return meshx_plat_on_off_gen_srv_create(
        p_sig_model,
        &((*p_model)->meshx_pub),
        &((*p_model)->meshx_gen));
}

meshx_err_t meshx_on_off_server_delete(meshx_onoff_server_model_t **p_model)
{
    if (p_model == NULL || *p_model == NULL)
    {
        return MESHX_INVALID_ARG;
    }
 
    meshx_plat_gen_srv_delete(
        &((*p_model)->meshx_pub),
        &((*p_model)->meshx_gen)
    );
 
    MESHX_FREE(*p_model);
    *p_model = NULL;
 
    return MESHX_SUCCESS;
}

meshx_err_t meshx_gen_on_off_srv_state_restore(meshx_ptr_t p_model, meshx_on_off_srv_el_state_t onoff_state)
{
    if(!p_model)
        return MESHX_INVALID_STATE;
 
    return meshx_plat_gen_on_off_srv_restore(p_model, onoff_state.on_off);
}

meshx_err_t meshx_gen_on_off_srv_send_pack_create(
    meshx_ptr_t p_model,
    uint16_t element_id,
    uint8_t key_id,
    uint8_t app_id,
    uint16_t addr,
    uint8_t state,
    meshx_gen_srv_cb_param_t *p_send_pack
)
{
    if (!p_model || !p_send_pack)
    {
        return MESHX_INVALID_ARG;
    }
 
    memset(p_send_pack, 0, sizeof(meshx_gen_srv_cb_param_t));
 
    p_send_pack->ctx.net_idx    = key_id;
    p_send_pack->ctx.app_idx    = app_id;
    p_send_pack->ctx.dst_addr   = addr;
    p_send_pack->ctx.opcode     = MESHX_MODEL_OP_GEN_ONOFF_STATUS;
    p_send_pack->model.el_id    = element_id;
    p_send_pack->model.p_model  = p_model;
 
    p_send_pack->state_change.onoff_set.onoff = state;
 
    return MESHX_SUCCESS;
}
 
#endif /* CONFIG_ENABLE_GEN_ONOFF_SERVER */