Ejemplo n.º 1
0
void app_eaci_data_proxm_hdl(uint8_t msg_id, uint8_t param_len, uint8_t const *param)
{
    uint16_t conhdl;
    if (param_len == BD_ADDR_LEN)
    {
        app_eaci_get_conhdl_by_param(&conhdl, param);
    }
    else
    {
        app_eaci_get_conhdl_by_param(&conhdl, param + (param_len - BD_ADDR_LEN));
    }
    uint8_t idx = app_get_client_idx_by_conhdl(conhdl, ATT_SVC_LINK_LOSS);
    
    if ((app_proxm_env[idx].enabled == false) && (msg_id != EACI_MSG_DATA_REQ_PROXM_ENABLE))
        return;

    switch (msg_id)
    {
        case EACI_MSG_DATA_REQ_PROXM_ENABLE:
            if (param_len == BD_ADDR_LEN)
            {
                if (conhdl != 0xFFFF)
                    app_proxm_enable_req(NULL, NULL, NULL, conhdl);
            }
            break;

        case EACI_MSG_DATA_READ_PROXM_TX_POWER:
            if (param_len == BD_ADDR_LEN)
            {
                if (conhdl != 0xFFFF)
                    app_proxm_rd_txpw_lvl_req(conhdl);
            }

        case EACI_MSG_DATA_WRITE_PROXM_IAS:
            if (param_len == (BD_ADDR_LEN + 1))
            {
                uint8_t alert_lvl = param[0];
                if (conhdl != 0xFFFF)
                    app_proxm_wr_alert_lvl_req(1, alert_lvl, conhdl);
            }
            break;

        case EACI_MSG_DATA_WRITE_PROXM_LLS:
            if (param_len == (BD_ADDR_LEN + 1))
            {
                uint8_t alert_lvl = param[0];
                if (conhdl != 0xFFFF)
                    app_proxm_wr_alert_lvl_req(0, alert_lvl, conhdl);
            }
            break;

        default:
            break;
    }
}
Ejemplo n.º 2
0
void app_eaci_data_basc_hdl(uint8_t msg_id, uint8_t param_len, uint8_t const *param)
{
    uint16_t conhdl;
    if (param_len == BD_ADDR_LEN)
    {
        app_eaci_get_conhdl_by_param(&conhdl, param);
    }
    else
    {
        app_eaci_get_conhdl_by_param(&conhdl, param + (param_len - BD_ADDR_LEN));
    }
    uint8_t idx = app_get_client_idx_by_conhdl(conhdl, ATT_SVC_BATTERY_SERVICE);
    
    if ((app_basc_env[idx].enabled == false) && (msg_id != EACI_MSG_DATA_REQ_BATT_ENABLE))
        return;

    switch (msg_id)
    {
        case EACI_MSG_DATA_REQ_BATT_ENABLE:
            if (param_len == BD_ADDR_LEN)
            {
                if (conhdl != 0xFFFF)
                    app_basc_enable_req(NULL, NULL, conhdl);
            }
            break;

        case EACI_MSG_DATA_REQ_BATT_RD_CHAR_VAL:
            if (param_len == (BD_ADDR_LEN + 1))
            {
                if (conhdl != 0xFFFF)
                    app_basc_rd_char_req(param[0], 0, conhdl);
            }
            break;

        case EACI_MSG_DATA_REQ_BATT_CFG_NOTIFY:
            if (param_len == (BD_ADDR_LEN + 2))
            {
                uint16_t ntf_cfg = param[1] << 8 | param[0];
                app_basc_cfg_indntf_req(ntf_cfg, 0, conhdl);
            }
            break;

        default:
            break;
    }
}
Ejemplo n.º 3
0
void app_eaci_data_htpc_hdl(uint8_t msg_id, uint8_t param_len, uint8_t const *param)
{
    uint16_t conhdl;
    if (param_len == BD_ADDR_LEN)
    {
        app_eaci_get_conhdl_by_param(&conhdl, param);
    }
    else
    {
        app_eaci_get_conhdl_by_param(&conhdl, param + (param_len - BD_ADDR_LEN));
    }
    uint8_t idx = app_get_client_idx_by_conhdl(conhdl, ATT_SVC_HEALTH_THERMOM);
    
    if ((app_htpc_env[idx].enabled == false) && (msg_id != EACI_MSG_DATA_REQ_HT_ENABLE))
        return;

    switch(msg_id)
    {
        case EACI_MSG_DATA_REQ_HT_ENABLE:
            if (param_len == BD_ADDR_LEN)
            {
                if (conhdl != 0xFFFF)
                    app_htpc_enable_req(NULL, conhdl);
            }
            break;
            
        case EACI_MSG_DATA_REQ_HT_TEMP_MEAS:
            if (param_len == (BD_ADDR_LEN + 2))
            {
                uint16_t cfg_val = param[1] << 8 | param[0];
                if (conhdl != 0xFFFF)
                    app_htpc_cfg_indntf_req(HTPC_CHAR_HTS_TEMP_MEAS, cfg_val,conhdl);
            }
            break;
            
        case EACI_MSG_DATA_REQ_HT_INTM_TEMP:
            if (param_len == (BD_ADDR_LEN + 2))
            {
                uint16_t cfg_val = param[1] << 8 | param[0];
                if (conhdl != 0xFFFF)
                    app_htpc_cfg_indntf_req(HTPC_CHAR_HTS_INTM_TEMP, cfg_val,conhdl);
            }
            break;
        
        case EACI_MSG_DATA_REQ_HT_MEAS_INTV:
            if (param_len == (BD_ADDR_LEN + 2))
            {
                uint16_t cfg_val = param[1] << 8 | param[0];
                if (conhdl != 0xFFFF)
                    app_htpc_cfg_indntf_req(HTPC_CHAR_HTS_MEAS_INTV, cfg_val,conhdl);
            }
            break;

        case EACI_MSG_DATA_REQ_HT_RD_MEAS_INTV:
            if (param_len == BD_ADDR_LEN)
            {
                if (conhdl != 0xFFFF)
                    app_htpc_rd_char_req(HTPC_CHAR_HTS_MEAS_INTV, conhdl);
            }
            break;

        default:
            break;
    }
}
Ejemplo n.º 4
0
void app_eaci_data_glc_hdl(uint8_t msg_id, uint8_t param_len, uint8_t const *param)
{
    uint16_t conhdl;
    if (param_len == BD_ADDR_LEN)
    {
        app_eaci_get_conhdl_by_param(&conhdl, param);
    }
    else
    {
        app_eaci_get_conhdl_by_param(&conhdl, param + (param_len - BD_ADDR_LEN));
    }
    uint8_t idx = app_get_client_idx_by_conhdl(conhdl, ATT_SVC_GLUCOSE);
    
    if ((app_glpc_env[idx].enabled == false) && (msg_id != EACI_MSG_DATA_REQ_GL_ENABLE))
        return;

    switch (msg_id)
    {
        case EACI_MSG_DATA_REQ_GL_ENABLE:
            if (param_len == BD_ADDR_LEN)
            {
                if (conhdl != 0xFFFF)
                    app_glpc_enable_req(NULL, conhdl);
            }
            break;
        // Register
        case EACI_MSG_DATA_REQ_GL_REGISTER:
            if (param_len == (BD_ADDR_LEN + 1))
            {
                uint8_t meas_ctx_en = param[0];
                if (conhdl != 0xFFFF)
                    app_glpc_register_req(meas_ctx_en, conhdl);
            }
            break;
        // Read Features
        case EACI_MSG_DATA_REQ_GL_FEATURES_RD:
            if (param_len == BD_ADDR_LEN)
            {
                if (conhdl != 0xFFFF)
                    app_glpc_read_features_req(conhdl);
            }
            break;

        //operation code - Report Stored Records
        case EACI_MSG_DATA_REQ_GL_RSR_RACP:
            if (param_len == BD_ADDR_LEN + 5)
            {
                struct glp_racp_req req;
                req.op_code = GLP_REQ_REP_STRD_RECS;
                req.filter.operator = param[0];
                req.filter.filter_type = GLP_FILTER_SEQ_NUMBER;
                req.filter.val.seq_num.min = param[2] << 8 | param[1];
                req.filter.val.seq_num.max = param[4] << 8 | param[3];
                if (conhdl != 0xFFFF)
                    app_glpc_racp_req(&req, conhdl);
            }
            break;

        //operation code - Delete Stored Records
        case EACI_MSG_DATA_REQ_GL_DSR_RACP:
            if (param_len == BD_ADDR_LEN + 5)
            {
                struct glp_racp_req req;
                req.op_code = GLP_REQ_DEL_STRD_RECS;
                req.filter.operator = param[0];
                req.filter.filter_type = GLP_FILTER_SEQ_NUMBER;
                req.filter.val.seq_num.min = param[2] << 8 | param[1];
                req.filter.val.seq_num.max = param[4] << 8 | param[3];
                if (conhdl != 0xFFFF)
                    app_glpc_racp_req(&req, conhdl);
            }
            break;

        //operation code - Abort Operation
        case EACI_MSG_DATA_REQ_GL_AO_RACP:
            if (param_len == BD_ADDR_LEN + 5)
            {
                struct glp_racp_req req;
                req.op_code = GLP_REQ_ABORT_OP;
                if (conhdl != 0xFFFF)
                    app_glpc_racp_req(&req, conhdl);
            }
            break;

        //operation code - Report Number of Stored Records
        case EACI_MSG_DATA_REQ_GL_RN_RACP:
            if (param_len == BD_ADDR_LEN + 5)
            {
                struct glp_racp_req req;
                req.op_code = GLP_REQ_REP_NUM_OF_STRD_RECS;
                req.filter.operator = param[0];
                req.filter.filter_type = GLP_FILTER_SEQ_NUMBER;
                req.filter.val.seq_num.min = param[2] << 8 | param[1];
                req.filter.val.seq_num.max = param[4] << 8 | param[3];
                
                if (conhdl != 0xFFFF)
                    app_glpc_racp_req(&req, conhdl);
            }
            break;

        default:
            break;
    }
}
Ejemplo n.º 5
0
void app_eaci_data_disc_hdl(uint8_t msg_id, uint8_t param_len, uint8_t const *param)
{
    uint16_t conhdl;
    if (param_len == BD_ADDR_LEN)
    {
        app_eaci_get_conhdl_by_param(&conhdl, param);
    }
    else
    {
        app_eaci_get_conhdl_by_param(&conhdl, param + (param_len - BD_ADDR_LEN));
    }
    uint8_t idx = app_get_client_idx_by_conhdl(conhdl, ATT_SVC_DEVICE_INFO);
    
    if ((app_disc_env[idx].enabled == false) && (msg_id != EACI_MSG_DATA_REQ_DISC_ENABLE))
        return;

    switch (msg_id)
    {
        case EACI_MSG_DATA_REQ_DISC_ENABLE:
            if (param_len == BD_ADDR_LEN)
            {
                if (conhdl != 0xFFFF)
                    app_disc_enable_req(NULL, conhdl);
            }
            break;

        case EACI_MSG_DATA_REQ_DISC_CHAR_RD:
            if (param_len == (BD_ADDR_LEN + 1))
            {
                uint8_t char_code = 0;
                uint8_t flg = param[0];
                switch(flg)
                {
                    case 0:
                        char_code = DISC_MANUFACTURER_NAME_CHAR;
                        break;
                    case 1:
                        char_code = DISC_MODEL_NB_STR_CHAR;
                        break;
                    case 2:
                        char_code = DISC_SERIAL_NB_STR_CHAR;
                        break;
                    case 3:
                        char_code = DISC_HARD_REV_STR_CHAR;
                        break;
                    case 4:
                        char_code = DISC_FIRM_REV_STR_CHAR;
                        break;
                    case 5:
                        char_code = DISC_SW_REV_STR_CHAR;
                        break;
                    case 6:
                        char_code = DISC_SYSTEM_ID_CHAR;
                        break;
                    case 7:
                        char_code = DISC_IEEE_CHAR;
                        break;
                    case 8:
                        char_code = DISC_PNP_ID_CHAR;
                        break;
                    default:
                        break;
                }
                if (conhdl != 0xFFFF)
                    app_disc_rd_char_req(char_code, conhdl);

            }
            break;

        default:
            break;
    }
}