esp_gen_srv_model.c

Go to the documentation of this file.

#include "meshx_control_task.h"
#include "interface/ble_mesh/server/meshx_ble_mesh_gen_srv.h"
 
#define CONTROL_TASK_MSG_EVT_TO_BLE_GEN_SRV_MASK \
    CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF_SRV

static meshx_err_t meshx_plat_gen_srv_create(void* p_model, void** p_pub, void** p_srv)
{
    if(!p_model || !p_pub || !p_srv)
        return MESHX_INVALID_ARG;
 
    meshx_err_t err = MESHX_SUCCESS;
 
    err = meshx_plat_create_model_pub(p_pub, 1);
    if (err)
        return meshx_plat_del_model_pub(p_pub);
 
    *p_srv = (MESHX_GEN_ONOFF_SRV *) MESHX_CALOC(1, sizeof(MESHX_GEN_ONOFF_SRV));
    if(!*p_srv)
        return MESHX_NO_MEM;
 
    ((MESHX_GEN_ONOFF_SRV*)*p_srv)->rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP;
    ((MESHX_GEN_ONOFF_SRV*)*p_srv)->rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP;
    ((MESHX_MODEL*)p_model)->user_data = *p_srv;
 
    void **temp = (void**) &((MESHX_MODEL*)p_model)->pub;
 
    *temp = *p_pub;
 
    return err;
}

static const char *server_state_str[] = {
    [ESP_BLE_MESH_GENERIC_SERVER_STATE_CHANGE_EVT] = "SRV_STATE_CH",
    [ESP_BLE_MESH_GENERIC_SERVER_RECV_GET_MSG_EVT] = "SRV_RECV_GET",
    [ESP_BLE_MESH_GENERIC_SERVER_RECV_SET_MSG_EVT] = "SRV_RECV_SET"
};
 

static void esp_ble_mesh_generic_server_cb(MESHX_GEN_SRV_CB_EVT event,
                                           MESHX_GEN_SRV_CB_PARAM *param)
{
    ESP_UNUSED(server_state_str);
    MESHX_LOGD(MODULE_ID_MODEL_SERVER, "%s, op|src|dst:%04" PRIx32 "|%04x|%04x",
            server_state_str[event], param->ctx.recv_op, param->ctx.addr, param->ctx.recv_dst);
 
    if (event != ESP_BLE_MESH_GENERIC_SERVER_STATE_CHANGE_EVT)
        return;
 
    meshx_gen_srv_cb_param_t pub_param = {
        .ctx = {
            .net_idx    = param->ctx.net_idx,
            .app_idx    = param->ctx.app_idx,
            .dst_addr   = param->ctx.recv_dst,
            .src_addr   = param->ctx.addr,
            .opcode     = param->ctx.recv_op,
            .p_ctx      = &param->ctx
        },
        .model = {
            .pub_addr   = param->model->pub->publish_addr,
            .model_id   = param->model->model_id,
            .el_id      = param->model->element_idx,
            .p_model    = param->model
        },
        .state_change = {
            .onoff_set.onoff = param->value.state_change.onoff_set.onoff
        }
    };
 
    if(pub_param.model.model_id == ESP_BLE_MESH_MODEL_ID_GEN_ONOFF_SRV)
    {
        MESHX_GEN_ONOFF_SRV *srv = (MESHX_GEN_ONOFF_SRV *)param->model->user_data;
        srv->state.onoff = pub_param.state_change.onoff_set.onoff;
    }
 
    meshx_err_t err = control_task_msg_publish(
        CONTROL_TASK_MSG_CODE_FRM_BLE,
        pub_param.model.model_id,
        &pub_param,
        sizeof(meshx_gen_srv_cb_param_t));
    if (err)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Failed to publish to control task");
    }
}

meshx_err_t meshx_plat_gen_srv_send_status(
        meshx_model_t *p_model,
        meshx_ctx_t *p_ctx,
        meshx_ptr_t p_data,
        uint32_t data_len
    )
{
    static esp_ble_mesh_msg_ctx_t ctx;
    const esp_ble_mesh_msg_ctx_t *pctx = (esp_ble_mesh_msg_ctx_t *)p_ctx->p_ctx;
    if(pctx != NULL)
    {
        memcpy(&ctx, pctx, sizeof(esp_ble_mesh_msg_ctx_t));
    }
 
    ctx.net_idx    =   p_ctx->net_idx;
    ctx.app_idx    =   p_ctx->app_idx;
    ctx.addr       =   p_ctx->dst_addr;
    ctx.send_ttl   =   ESP_BLE_MESH_TTL_DEFAULT;
    ctx.send_cred  =   0;
    ctx.send_tag   =   BIT1;
 
    esp_err_t err = esp_ble_mesh_server_model_send_msg(p_model->p_model,
        &ctx,
        p_ctx->opcode,
        (uint16_t)data_len,
        (uint8_t*)p_data);
    if(err)
    {
        MESHX_LOGE(MODULE_ID_MODEL_SERVER, "Mesh Model msg send failed (err: 0x%x)", err);
        return MESHX_ERR_PLAT;
    }
    MESHX_LOGD(MODULE_ID_MODEL_SERVER, "Mesh Model msg sent (opcode: 0x%04x)", p_ctx->opcode);
    return MESHX_SUCCESS;
}

meshx_err_t meshx_plat_set_gen_srv_state(void * p_model, uint8_t on_off_state)
{
    if(!p_model)
        return MESHX_INVALID_ARG;
 
    MESHX_MODEL * model = (MESHX_MODEL *)p_model;
    MESHX_GEN_ONOFF_SRV *srv = (MESHX_GEN_ONOFF_SRV *)model->user_data;
 
    srv->state.onoff = on_off_state;
 
    return MESHX_SUCCESS;
}

meshx_err_t meshx_plat_gen_srv_init(void)
{
    meshx_err_t err = MESHX_SUCCESS;
 
    /* Register the ESP Generic Server callback */
    esp_err_t esp_err = esp_ble_mesh_register_generic_server_callback(
            (MESHX_GEN_SRV_CB)&esp_ble_mesh_generic_server_cb
        );
    if(esp_err != ESP_OK)
        err = MESHX_ERR_PLAT;
 
    return err;
}
 
meshx_err_t meshx_plat_on_off_gen_srv_create(void* p_model, void** p_pub, void** p_onoff_srv)
{
    if(!p_model || !p_pub || !p_onoff_srv)
        return MESHX_INVALID_ARG;
 
    /* SIG ON OFF initialisation */
    uint16_t model_id = ESP_BLE_MESH_MODEL_ID_GEN_ONOFF_SRV;
    memcpy((meshx_ptr_t) &(((MESHX_MODEL*)p_model)->model_id), &model_id, sizeof(model_id));
 
    return meshx_plat_gen_srv_create(p_model, p_pub, p_onoff_srv);
}
 
meshx_err_t meshx_plat_gen_srv_delete(void** p_pub, void** p_srv)
{
    if(p_srv)
    {
        MESHX_FREE(*p_srv);
        *p_srv = NULL;
    }
 
    return meshx_plat_del_model_pub(p_pub);
}
 
meshx_err_t meshx_plat_gen_on_off_srv_restore(void* p_model, uint8_t state)
{
    return meshx_plat_set_gen_srv_state (p_model, state);
}