meshx_gen_client.c

Go to the documentation of this file.

#include "stdlib.h"
#include "meshx_txcm.h"
#include "meshx_gen_client.h"
 
#if CONFIG_ENABLE_GEN_CLIENT
#define MESHX_CLIENT_INIT_MAGIC_NO 0x1121
typedef struct meshx_gen_cli_cb_reg
{
    uint16_t model_id;          
    meshx_gen_client_cb_t cb;   
}meshx_gen_cli_cb_reg_t;

typedef struct meshx_gen_cli_resend_ctx
{
    uint16_t model_id;              
    meshx_gen_cli_cb_param_t param; 
}meshx_gen_cli_resend_ctx;

typedef struct meshx_gen_client_msg_ctx
{
    meshx_ptr_t model;              
    uint16_t opcode;                
    uint16_t addr;                  
    uint16_t net_idx;               
    uint16_t app_idx;               
    meshx_gen_cli_set_t state;      
}meshx_gen_client_msg_ctx_t;

typedef struct meshx_gen_cli_cb_reg_node
{
    meshx_gen_cli_cb_reg_t reg;             
    struct meshx_gen_cli_cb_reg_node *next; 
} meshx_gen_cli_cb_reg_node_t;

static struct{
    uint16_t client_init;                            
    meshx_gen_cli_cb_reg_node_t *cli_cb_reg_head;    
} g_meshx_client_control;

static meshx_err_t meshx_gen_cli_cb_reg_add(meshx_gen_cli_cb_reg_t reg)
{
    meshx_gen_cli_cb_reg_node_t *node = (meshx_gen_cli_cb_reg_node_t*) MESHX_MALLOC(sizeof(meshx_gen_cli_cb_reg_node_t));
    if (!node)
        return MESHX_NO_MEM;
 
    node->reg = reg;
    node->next = g_meshx_client_control.cli_cb_reg_head;
    g_meshx_client_control.cli_cb_reg_head = node;
 
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_is_gen_cli_get_opcode(uint16_t opcode)
{
    switch(opcode)
    {
        case MESHX_MODEL_OP_GEN_ONOFF_GET:
        case MESHX_MODEL_OP_GEN_LEVEL_GET:
        case MESHX_MODEL_OP_GEN_ONPOWERUP_GET:
        case MESHX_MODEL_OP_GEN_POWER_LEVEL_GET:
        case MESHX_MODEL_OP_GEN_BATTERY_GET:
        case MESHX_MODEL_OP_GEN_LOC_GLOBAL_GET:
        case MESHX_MODEL_OP_GEN_LOC_LOCAL_GET:
        case MESHX_MODEL_OP_GEN_MANUFACTURER_PROPERTIES_GET:
        case MESHX_MODEL_OP_GEN_MANUFACTURER_PROPERTY_GET:
        case MESHX_MODEL_OP_GEN_ADMIN_PROPERTIES_GET:
        case MESHX_MODEL_OP_GEN_ADMIN_PROPERTY_GET:
        case MESHX_MODEL_OP_GEN_USER_PROPERTIES_GET:
        case MESHX_MODEL_OP_GEN_USER_PROPERTY_GET:
        case MESHX_MODEL_OP_GEN_CLIENT_PROPERTIES_GET:
            return MESHX_SUCCESS;
        default:
            return MESHX_FAIL;
    }
}

static meshx_err_t meshx_is_gen_cli_model(uint32_t model_id)
{
    switch (model_id)
    {
        case MESHX_MODEL_ID_GEN_ONOFF_CLI:
        case MESHX_MODEL_ID_GEN_LEVEL_CLI:
        case MESHX_MODEL_ID_GEN_POWER_ONOFF_CLI:
        case MESHX_MODEL_ID_GEN_POWER_LEVEL_CLI:
        case MESHX_MODEL_ID_GEN_BATTERY_CLI:
        case MESHX_MODEL_ID_GEN_LOCATION_CLI:
            return MESHX_SUCCESS;
        default:
            return MESHX_FAIL;
    }
}

static meshx_err_t meshx_is_unack_opcode(uint32_t opcode)
{
    switch(opcode)
    {
        case MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK:
        case MESHX_MODEL_OP_GEN_LEVEL_SET_UNACK:
        case MESHX_MODEL_OP_GEN_ONPOWERUP_SET_UNACK:
        case MESHX_MODEL_OP_GEN_POWER_LEVEL_SET_UNACK:
        case MESHX_MODEL_OP_GEN_LOC_GLOBAL_SET_UNACK:
        case MESHX_MODEL_OP_GEN_LOC_LOCAL_SET_UNACK:
        case MESHX_MODEL_OP_GEN_MANUFACTURER_PROPERTY_SET_UNACK:
        case MESHX_MODEL_OP_GEN_ADMIN_PROPERTY_SET_UNACK:
        case MESHX_MODEL_OP_GEN_USER_PROPERTY_SET_UNACK:
            return MESHX_SUCCESS;
        default:
            return MESHX_FAIL;
    }
}

static meshx_err_t meshx_gen_client_txcm_fn_model_send(meshx_gen_client_msg_ctx_t *msg_param, size_t msg_param_len)
{
    if(msg_param == NULL || msg_param_len != sizeof(meshx_gen_client_msg_ctx_t))
    {
        return MESHX_INVALID_ARG;
    }
 
    return meshx_plat_gen_cli_send_msg(
        msg_param->model,
        &msg_param->state,
        msg_param->opcode,
        msg_param->addr,
        msg_param->net_idx,
        msg_param->app_idx,
        (meshx_is_gen_cli_get_opcode(msg_param->opcode) == MESHX_SUCCESS)
    );
}

static meshx_err_t meshx_handle_txcm_msg(
    dev_struct_t *pdev,
    control_task_msg_evt_t evt,
    meshx_gen_cli_resend_ctx *param
)
{
    MESHX_UNUSED(evt);
    meshx_err_t err = MESHX_SUCCESS;
    meshx_gen_cli_cb_reg_t const * reg_cb = NULL;
    const meshx_gen_cli_cb_reg_node_t *node = g_meshx_client_control.cli_cb_reg_head;
 
    MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "TXCM Timeout for model 0x%x", param->model_id);
 
    while (node)
    {
        if (param->model_id == node->reg.model_id)
        {
            reg_cb                  = &node->reg;
            param->param.err_code   = MESHX_TIMEOUT;
            param->param.evt        = MESHX_GEN_CLI_TIMEOUT;
            err = reg_cb->cb(pdev, param->model_id, &param->param);
        }
        node = node->next;
    }
 
    if(reg_cb == NULL)
    {
        return MESHX_SUCCESS;
    }
 
    return err;
}

static meshx_err_t meshx_gen_cli_handle_ack(uint16_t src_addr)
{
    meshx_err_t err = MESHX_SUCCESS;
    err = meshx_txcm_request_send(MESHX_TXCM_SIG_ACK, src_addr, NULL, 0, NULL);
    return err;
}

static meshx_err_t meshx_gen_cli_handle_resend(uint16_t model_id, const meshx_gen_cli_cb_param_t *param)
{
    meshx_gen_cli_resend_ctx ctx = {
        .model_id = model_id
    };
    memcpy(&ctx.param, param, sizeof(meshx_gen_cli_cb_param_t));
 
    return meshx_txcm_request_send(
        MESHX_TXCM_SIG_RESEND,
        MESHX_ADDR_UNASSIGNED,
        &ctx,
        sizeof(meshx_gen_cli_resend_ctx),
        NULL);
}

static meshx_err_t meshx_handle_gen_onoff_msg(
    dev_struct_t *pdev,
    control_task_msg_evt_t model_id,
    meshx_gen_cli_cb_param_t *param
)
{
    if(!param || !pdev)
    {
        MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Invalid parameters");
        return MESHX_INVALID_ARG;
    }
    meshx_gen_cli_cb_reg_t const * reg_cb = NULL;
    meshx_err_t err = MESHX_SUCCESS;
 
    meshx_gen_cli_cb_reg_node_t *node = g_meshx_client_control.cli_cb_reg_head;
 
    while (node)
    {
        if (model_id == node->reg.model_id)
        {
            MESHX_LOGD(MODULE_ID_MODEL_CLIENT, "op|src|dst:%04" PRIx32 "|%04x|%04x",
                       param->ctx.opcode, param->ctx.src_addr, param->ctx.dst_addr);
            reg_cb = &node->reg;
            if (param->evt == MESHX_GEN_CLI_TIMEOUT || param->err_code != MESHX_SUCCESS)
            {
                MESHX_LOGD(MODULE_ID_MODEL_CLIENT, "Retrying to send the message");
                err = meshx_gen_cli_handle_resend((uint16_t)model_id, param);
                if(err != MESHX_SUCCESS)
                {
                    MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Resend failed: %d", err);
                }
                else
                {
                    /* As the retry would callback shall be triggered by the TXCM */
                    MESHX_DO_NOTHING;
                }
            }
            else
            {
                /* We need to notify if the ack is from the same source as that of dest */
                err = meshx_gen_cli_handle_ack(param->ctx.src_addr);
                if(err != MESHX_SUCCESS)
                {
                    MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Ack failed: %d", err);
                }
                err = reg_cb->cb(pdev, model_id, param);
            }
        }
        node = node->next;
    }
 
    if(reg_cb == NULL)
    {
        return MESHX_SUCCESS;
    }
 
    return err;
}

meshx_err_t meshx_gen_client_init(void)
{
    if (g_meshx_client_control.client_init == MESHX_CLIENT_INIT_MAGIC_NO)
        return MESHX_SUCCESS;
    g_meshx_client_control.client_init = MESHX_CLIENT_INIT_MAGIC_NO;
 
    meshx_err_t err = meshx_txcm_event_cb_reg((meshx_txcm_cb_t) &meshx_handle_txcm_msg);
    if(err != MESHX_SUCCESS)
        return err;
    return meshx_plat_gen_cli_init();
}

meshx_err_t meshx_gen_cli_send_msg(meshx_gen_client_send_params_t *params)
{
    if (!params || !params->model || !params->state)
    {
        return MESHX_INVALID_ARG;
    }
 
    meshx_err_t err = MESHX_SUCCESS;
    bool is_unack = meshx_is_unack_opcode(params->opcode) == MESHX_SUCCESS;
    /* Broadcast / Multicast will not be sending an ACK. Hence, it is not required to queue */
    meshx_txcm_sig_t req_type = (is_unack || (MESHX_ADDR_IS_UNICAST(params->addr) == false)) ?
                                MESHX_TXCM_SIG_DIRECT_SEND : MESHX_TXCM_SIG_ENQ_SEND;
 
    meshx_gen_client_msg_ctx_t send_msg =
    {
        .addr    = params->addr,
        .model   = params->model,
        .opcode  = params->opcode,
        .app_idx = params->app_idx,
        .net_idx = params->net_idx,
    };
    memcpy(&send_msg.state, params->state, sizeof(send_msg.state));
 
    err = meshx_txcm_request_send(
        req_type,
        send_msg.addr,
        &send_msg,
        sizeof(send_msg),
        (meshx_txcm_fn_model_send_t) &meshx_gen_client_txcm_fn_model_send
    );
    if(err)
    {
        MESHX_LOGE(MODULE_ID_MODEL_CLIENT, "Failed to send message: %p", (meshx_ptr_t) err);
    }
    return err;
}

meshx_err_t meshx_gen_client_from_ble_reg_cb(uint32_t model_id, meshx_gen_client_cb_t cb)
{
    if (!cb || meshx_is_gen_cli_model(model_id) != MESHX_SUCCESS)
    {
        return MESHX_INVALID_ARG;
    }
 
    meshx_err_t err = MESHX_SUCCESS;
    meshx_gen_cli_cb_reg_t reg = { .model_id = (uint16_t)model_id, .cb = cb };
 
    err = meshx_gen_cli_cb_reg_add(reg);
    if (err != MESHX_SUCCESS)
    {
        return err;
    }
 
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_FRM_BLE,
        model_id,
        (control_task_msg_handle_t) &meshx_handle_gen_onoff_msg
    );
}
 
#endif /* CONFIG_ENABLE_GEN_CLIENT */