meshx_relay_client.c

Go to the documentation of this file.

 
#include "meshx_common.h"
#include "meshx_control_task.h"
#include "meshx_nvs.h"
#include "meshx_api.h"
 
#if CONFIG_RELAY_CLIENT_COUNT > 0
#include "meshx_relay_client_element.h"
 
#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
#define CONTROL_TASK_MSG_CODE_EVT_MASK CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF
#endif /* CONFIG_ENABLE_CONFIG_SERVER */
 
#define MOD_SRC                             MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT
#define RELAY_CLI_EL_STATE_CH_EVT_MASK      CONTROL_TASK_MSG_EVT_EL_STATE_CH_SET_ON_OFF
 
#define GET_RELATIVE_EL_IDX(_element_id)    _element_id - relay_element_init_ctrl.element_id_start
#define IS_EL_IN_RANGE(_element_id)         (_element_id >= relay_element_init_ctrl.element_id_start && _element_id < relay_element_init_ctrl.element_id_end)
#define RELAY_CLI_EL(_rel_el_id)            relay_element_init_ctrl.el_list[_rel_el_id]
 
static relay_client_element_ctrl_t relay_element_init_ctrl;

static meshx_err_t meshx_element_struct_init(uint16_t n_max)
{
    if (!n_max)
        return MESHX_INVALID_ARG;
 
    if (relay_element_init_ctrl.el_list)
    {
        MESHX_LOGW(MOD_SRC, "Relay element list already initialized");
        return MESHX_INVALID_STATE;
    }
 
    meshx_err_t err = MESHX_SUCCESS;
 
    relay_element_init_ctrl.element_cnt      = n_max;
    relay_element_init_ctrl.element_id_end   = 0;
    relay_element_init_ctrl.element_id_start = 0;
 
    relay_element_init_ctrl.el_list =
        (relay_client_elements_t *)MESHX_CALOC(relay_element_init_ctrl.element_cnt, sizeof(relay_client_elements_t));
 
    if (!relay_element_init_ctrl.el_list)
        return MESHX_NO_MEM;
 
    for (size_t i = 0; i < relay_element_init_ctrl.element_cnt; i++)
    {
        RELAY_CLI_EL(i).cli_ctx =
            (meshx_relay_client_model_ctx_t *)MESHX_CALOC(1, sizeof(meshx_relay_client_model_ctx_t));
 
        if (!RELAY_CLI_EL(i).cli_ctx)
            return MESHX_NO_MEM;
 
        err = meshx_on_off_client_create(&RELAY_CLI_EL(i).onoff_cli_model,
                                         &RELAY_CLI_EL(i).relay_cli_sig_model_list[RELAY_CLI_SIG_ONOFF_MODEL_ID]);
        if (err)
        {
            MESHX_LOGE(MOD_SRC, "Meshx On Off Client create failed (Err : 0x%x)", err);
            return err;
        }
        RELAY_CLI_EL(i).onoff_cli_model->meshx_sig
            = &RELAY_CLI_EL(i).relay_cli_sig_model_list[RELAY_CLI_SIG_ONOFF_MODEL_ID];
    }
 
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_element_struct_deinit(void)
{
    if (!relay_element_init_ctrl.element_cnt || !relay_element_init_ctrl.el_list)
    {
        MESHX_LOGE(MOD_SRC, "Relay element list not initialized");
        return MESHX_INVALID_STATE;
    }
 
    meshx_err_t err;
 
    for (size_t i = 0; i < relay_element_init_ctrl.element_cnt; i++)
    {
        if (RELAY_CLI_EL(i).cli_ctx)
        {
            MESHX_FREE(RELAY_CLI_EL(i).cli_ctx);
            RELAY_CLI_EL(i).cli_ctx = NULL;
        }
        err = meshx_on_off_client_delete(&RELAY_CLI_EL(i).onoff_cli_model);
        if (err)
            MESHX_LOGE(MOD_SRC, "Meshx On Off Server delete failed (Err : 0x%x)", err);
    }
 
    if (relay_element_init_ctrl.el_list)
    {
        MESHX_FREE(relay_element_init_ctrl.el_list);
        relay_element_init_ctrl.el_list = NULL;
    }
 
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_dev_create_relay_model_space(dev_struct_t const *pdev, uint16_t n_max)
{
    if (!pdev)
        return MESHX_INVALID_STATE;
 
    /* Assign Spaces for Model List, Publish List and onoff gen list */
    meshx_err_t err = meshx_element_struct_init(n_max);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Failed to initialize relay element structures: (%d)", err);
        meshx_element_struct_deinit();
        return err;
    }
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_add_relay_cli_model_to_element_list(
    dev_struct_t *pdev, uint16_t *start_idx, uint16_t n_max)
{
    if (!pdev || !start_idx || !n_max)
        return MESHX_INVALID_STATE;
 
    if ((n_max + *start_idx) > CONFIG_MAX_ELEMENT_COUNT)
    {
        MESHX_LOGE(MOD_SRC, "No of elements limit reached");
        return MESHX_NO_MEM;
    }
 
    meshx_err_t err = MESHX_SUCCESS;
    relay_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,
            RELAY_CLI_EL(i - *start_idx).relay_cli_sig_model_list,
            NULL,
            RELAY_CLI_MODEL_SIG_CNT,
            RELAY_CLI_MODEL_VEN_CNT);
        if (err)
        {
            MESHX_LOGE(MOD_SRC, "Failed to add element to composition: (%d)", err);
            return err;
        }
        err = meshx_nvs_element_ctx_get(
            i,
            RELAY_CLI_EL(i - *start_idx).cli_ctx,
            sizeof(meshx_relay_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGW(MOD_SRC, "Failed to get relay cli element context: (0x%x)", err);
        }
    }
    /* Increment the index for further registrations */
    relay_element_init_ctrl.element_id_end = *start_idx += n_max;
    return MESHX_SUCCESS;
}
 
#if CONFIG_ENABLE_CONFIG_SERVER

static meshx_err_t relay_client_config_cli_cb(
    const dev_struct_t *pdev,
    control_task_msg_evt_t evt,
    const meshx_config_srv_cb_param_t *params)
{
    MESHX_UNUSED(pdev);
    meshx_relay_client_model_ctx_t *el_ctx = NULL;
    size_t rel_el_id = 0;
    uint16_t element_id = 0;
    uint16_t base_el_id = 0;
    bool nvs_save = false;
    meshx_get_base_element_id(&base_el_id);
 
    MESHX_LOGD(MODULE_ID_ELEMENT_SWITCH_RELAY_CLIENT, "EVT: %p", (void *)evt);
    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 = RELAY_CLI_EL(rel_el_id).cli_ctx;
        el_ctx->app_id = params->state_change.mod_app_bind.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 = RELAY_CLI_EL(rel_el_id).cli_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(MOD_SRC, "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_relay_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_SRC, "Failed to set relay element context: (%d)", err);
        }
    }
    return MESHX_SUCCESS;
}
#endif /* #if CONFIG_ENABLE_CONFIG_SERVER */

static meshx_err_t relay_cli_prov_srv_msg_handle(const dev_struct_t *pdev, control_task_msg_evt_t evt, const void *params)
{
    if(!pdev)
        return MESHX_INVALID_ARG;
 
    MESHX_UNUSED(params);
    size_t rel_el_id = 0;
    switch (evt)
    {
        case CONTROL_TASK_MSG_EVT_SYSTEM_FRESH_BOOT:
            for (size_t i = relay_element_init_ctrl.element_id_start; i < relay_element_init_ctrl.element_id_end; i++)
            {
                rel_el_id = GET_RELATIVE_EL_IDX(i);
                if(false == (RELAY_CLI_EL(rel_el_id).element_model_init
                            & MESHX_BIT(RELAY_CLI_SIG_ONOFF_MODEL_ID)))
                {
                    MESHX_LOGD(MOD_SRC, "Sending GET for model: 0");
                    return meshx_relay_el_get_state((uint16_t) i);
                }
            }
            break;
        default:
            MESHX_LOGW(MOD_SRC, "Unhandled event: %p", (void *)evt);
            break;
    }
 
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_relay_cli_send_onoff_msg(
    const dev_struct_t *pdev,
    uint16_t element_id,
    uint8_t set_get,
    uint8_t ack)
{
    if (!pdev || !IS_EL_IN_RANGE(element_id))
        return MESHX_INVALID_ARG;
 
    meshx_err_t err = MESHX_SUCCESS;
    size_t rel_el_id = GET_RELATIVE_EL_IDX(element_id);
    meshx_onoff_client_model_t *model = RELAY_CLI_EL(rel_el_id).onoff_cli_model;
 
    meshx_relay_client_model_ctx_t *el_ctx = RELAY_CLI_EL(rel_el_id).cli_ctx;
    uint16_t opcode = MESHX_MODEL_OP_GEN_ONOFF_GET;
 
    if (MESHX_GEN_ON_OFF_CLI_MSG_SET == set_get)
    {
        opcode = ack ? MESHX_MODEL_OP_GEN_ONOFF_SET : MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK;
    }
 
    MESHX_LOGD(MOD_SRC, "OPCODE: %p", (void *)(uint32_t)opcode);
 
    meshx_gen_onoff_send_params_t params = {
        .element_id = element_id,
        .model      = model,
        .opcode     = opcode,
        .addr       = el_ctx->pub_addr,
        .net_idx    = pdev->meshx_store.net_key_id,
        .app_idx    = el_ctx->app_id,
        .state      = el_ctx->state.on_off,
        .tid        = el_ctx->tid
    };
    /* Send message to the relay client */
    err = meshx_onoff_client_send_msg(&params);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client Send Message failed: (%d)", err);
    }
    else
    {
        el_ctx->tid++;
        if(opcode == MESHX_MODEL_OP_GEN_ONOFF_SET_UNACK)
        {
            el_ctx->prev_state.on_off = el_ctx->state.on_off;
            el_ctx->state.on_off = !el_ctx->state.on_off;
        }
    }
    return err;
}

static meshx_err_t meshx_relay_client_element_state_change_handler(
    const dev_struct_t *pdev,
    control_task_msg_evt_t evt,
    const meshx_on_off_cli_el_msg_t *param
)
{
    MESHX_UNUSED(pdev);
    MESHX_UNUSED(evt);
    uint16_t element_id = param->model.el_id;
    if (!IS_EL_IN_RANGE(element_id))
    {
        return MESHX_SUCCESS;
    }
 
    size_t rel_el_id = GET_RELATIVE_EL_IDX(element_id);
    meshx_relay_client_model_ctx_t *el_ctx = RELAY_CLI_EL(rel_el_id).cli_ctx;
    meshx_api_relay_client_evt_t app_notify;
    meshx_err_t err = MESHX_SUCCESS;
    bool nvs_save = false;
    err = meshx_gen_on_off_state_change_handle(param, &el_ctx->prev_state, &el_ctx->state);
    if(err == MESHX_SUCCESS)
    {
        app_notify.err_code = param->err_code;
        app_notify.on_off = el_ctx->prev_state.on_off;
 
        err = meshx_send_msg_to_app(element_id,
                                    MESHX_ELEMENT_TYPE_RELAY_CLIENT,
                                    MESHX_ELEMENT_FUNC_ID_RELAY_SERVER_ONN_OFF,
                                    sizeof(meshx_api_relay_client_evt_t),
                                    &app_notify);
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_SRC, "Failed to send Relay state change message: (%d)", err);
        }
    }
    if (nvs_save)
    {
        err = meshx_nvs_element_ctx_set(element_id, el_ctx, sizeof(meshx_relay_client_model_ctx_t));
        if (err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MOD_SRC, "Failed to set Relay element context: (%d)", err);
        }
    }
    return MESHX_SUCCESS;
}

static meshx_err_t meshx_relay_client_to_ble_handler(
    const dev_struct_t *pdev,
    control_task_msg_evt_t evt,
    const meshx_gen_on_off_cli_msg_t *msg
)
{
    meshx_err_t err = MESHX_SUCCESS;
 
    if (!pdev || !msg || !IS_EL_IN_RANGE(msg->element_id))
        return MESHX_INVALID_ARG;
 
    if (RELAY_CLI_EL(GET_RELATIVE_EL_IDX(msg->element_id)).cli_ctx->pub_addr == MESHX_ADDR_UNASSIGNED)
    {
        MESHX_LOGW(MOD_SRC, "No publish address set for element: %d", msg->element_id);
        return MESHX_INVALID_STATE;
    }
    if (evt == CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF)
    {
        err = meshx_relay_cli_send_onoff_msg(pdev,
                                      msg->element_id,
                                      msg->set_get,
                                      msg->ack);
        if (err)
        {
            MESHX_LOGE(
                MOD_SRC,
                "Relay Client Control Task: Set OnOff failed (%p)", (void *)err);
        }
    }
    return err;
}
 
#if CONFIG_ENABLE_UNIT_TEST
typedef enum
{
    RELAY_CLI_CMD_GET = 0x00,
    RELAY_CLI_CMD_SET = 0x01,
    RELAY_CLI_CMD_SET_UNACK = 0x02,
    RELAY_CLI_MAX_CMD
} relay_cli_cmd_t;

static meshx_err_t relay_cli_unit_test_cb_handler(int cmd_id, int argc, char **argv)
{
    meshx_err_t err = MESHX_SUCCESS;
    MESHX_LOGD(MOD_SRC, "argc|cmd_id: %d|%d", argc, cmd_id);
    if (argc < 1 || cmd_id >= RELAY_CLI_MAX_CMD)
    {
        MESHX_LOGE(
            MOD_SRC, "Relay Client Unit Test: Invalid number of arguments");
        return MESHX_INVALID_ARG;
    }
 
    relay_cli_cmd_t cmd = (relay_cli_cmd_t)cmd_id;
    uint8_t set_get = (cmd == RELAY_CLI_CMD_GET) ? MESHX_GEN_ON_OFF_CLI_MSG_GET : MESHX_GEN_ON_OFF_CLI_MSG_SET;
    uint16_t el_id  = UT_GET_ARG(0, uint16_t, argv);
 
    err = !set_get ? meshx_relay_el_set_state(el_id, (cmd == RELAY_CLI_CMD_SET)) :
                    meshx_relay_el_get_state(el_id);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client Unit Test: Command %d failed", cmd);
    }
    return err;
}
#endif /* CONFIG_ENABLE_UNIT_TEST */
 

static meshx_err_t meshx_relay_cli_reg_app_req_cb()
{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_TO_BLE,
        CONTROL_TASK_MSG_CODE_EVT_MASK,
        (control_task_msg_handle_t)&meshx_relay_client_to_ble_handler
    );
}

static meshx_err_t meshx_relay_cli_el_state_change_reg_cb()
{
    return control_task_msg_subscribe(
        CONTROL_TASK_MSG_CODE_EL_STATE_CH,
        RELAY_CLI_EL_STATE_CH_EVT_MASK,
        (control_task_msg_handle_t)&meshx_relay_client_element_state_change_handler
    );
}

meshx_err_t meshx_relay_el_set_state(uint16_t el_id, bool ack)
{
    meshx_gen_on_off_cli_msg_t msg = {
        .ack        = ack == MESHX_GEN_ON_OFF_CLI_MSG_ACK,
        .set_get    = MESHX_GEN_ON_OFF_CLI_MSG_SET,
        .element_id = el_id
    };
    return control_task_msg_publish(
            CONTROL_TASK_MSG_CODE_TO_BLE,
            CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF,
            &msg,
            sizeof(msg));
}

meshx_err_t meshx_relay_el_get_state(uint16_t el_id)
{
    meshx_gen_on_off_cli_msg_t msg = {
        .ack        = MESHX_GEN_ON_OFF_CLI_MSG_ACK,
        .set_get    = MESHX_GEN_ON_OFF_CLI_MSG_GET,
        .element_id = el_id
    };
    return control_task_msg_publish(
            CONTROL_TASK_MSG_CODE_TO_BLE,
            CONTROL_TASK_MSG_EVT_TO_BLE_SET_ON_OFF,
            &msg,
            sizeof(msg));
}

meshx_err_t create_relay_client_elements(dev_struct_t *pdev, uint16_t element_cnt)
{
    meshx_err_t err;
 
    err = meshx_dev_create_relay_model_space(pdev, element_cnt);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Model space create failed: (%d)", err);
        return err;
    }
 
    err = meshx_add_relay_cli_model_to_element_list(pdev, (uint16_t *)&pdev->element_idx, element_cnt);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Model add to element create failed: (%d)", err);
        return err;
    }
 
#if CONFIG_ENABLE_CONFIG_SERVER
    err = meshx_config_server_cb_reg(
        (config_srv_cb_t)&relay_client_config_cli_cb,
        CONFIG_SERVER_CB_MASK);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Model config client callback reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_CONFIG_SERVER */
    err = meshx_relay_cli_reg_app_req_cb();
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client app req callback reg failed: (%d)", err);
        return err;
    }
    err = meshx_prov_srv_reg_el_client_cb(
        (prov_srv_cb_t)&relay_cli_prov_srv_msg_handle);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client freshboot callback reg failed: (%d)", err);
        return err;
    }
    err = meshx_relay_cli_el_state_change_reg_cb();
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "Relay Client element state change callback reg failed: (%d)", err);
        return err;
    }
#if CONFIG_ENABLE_UNIT_TEST
    err = register_unit_test(MOD_SRC, &relay_cli_unit_test_cb_handler);
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "unit_test reg failed: (%d)", err);
        return err;
    }
#endif /* CONFIG_ENABLE_UNIT_TEST */
 
    err = meshx_on_off_client_init();
    if (err)
    {
        MESHX_LOGE(MOD_SRC, "meshx_onoff_client_init failed: (%d)", err);
        return err;
    }
 
    return MESHX_SUCCESS;
}
 
REG_MESHX_ELEMENT_FN(relay_cli_el, MESHX_ELEMENT_TYPE_RELAY_CLIENT, create_relay_client_elements);
 
#endif /* CONFIG_RELAY_CLIENT_COUNT > 0*/