RE: CUSTOM BLE SERVICE : READ WRITE RESPONSE

Hung Bui — Wed, 10 Jun 2020 10:02:32 GMT

http://www.theunixschool.com/2010/05/how-to-use-extern-variable-in-c.html

RE: CUSTOM BLE SERVICE : READ WRITE RESPONSE

Sunil vignesh — Wed, 10 Jun 2020 05:52:31 GMT

yes, that is the case. can yu give me an example

RE: CUSTOM BLE SERVICE : READ WRITE RESPONSE

Hung Bui — Tue, 09 Jun 2020 14:00:45 GMT

Are you sharing the same variable between different C files ?
If it's the case you need to use extern when you refer to a variable initialized in other file.

RE: CUSTOM BLE SERVICE : READ WRITE RESPONSE

Sunil vignesh — Wed, 03 Jun 2020 18:29:37 GMT

Ok, If in that case. I have main.c and drv_motion.c file and ble_motion.h

in drv_motion.c file

public variable

static ble_motion_init_t motion_init;

and i process the data. anywhere in the .c file i am able to print or read the perfect variable.

but same public variable declare in main.c file

it repeats zero.

eg:

in drv_motion.c

motion_init.init_train.training value = 5;

anf it prints value 5;

but in same method at same time of drv_motion.c prints from main.c file also doing print

static ble_motion_init_t b_motion_i;

when prints it shows 0.

RE: CUSTOM BLE SERVICE : READ WRITE RESPONSE

Hung Bui — Wed, 03 Jun 2020 09:06:23 GMT

Maybe you need to use static variable ? or public variable ? The way you defined

ble_motion_init_t motion_init;

it's a local variable and will be discarded after service_init() finishes.

RE: CUSTOM BLE SERVICE : READ WRITE RESPONSE

Sunil vignesh — Wed, 03 Jun 2020 04:18:30 GMT

Hi Hung,

Ok , I will tried this

"BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm); " its working but

i received "ldr r3, [pc, #4] " while i force to write the data.

I received this error while

if ( valid_data )
            {
               p_motion->calib_write_handler(p_motion,(ble_calibrate_t *)p_evt_rw_authorize_request->request.write.data);
            }

But when i use these line it doesn't entered into the calib_write_handler it means that calib_write_handler is NULL. how to make this as not equal to NULL.

if ( valid_data && (p_motion->calib_write_handler != NULL))
            {
               p_motion->calib_write_handler(p_motion,(ble_calibrate_t *)p_evt_rw_authorize_request->request.write.data);
            }

the respective code sequence is below

ble_motion.c

...
....


static void on_authorize_req(ble_motion_t * p_motion, ble_evt_t const * p_ble_evt)
{
    ble_gatts_evt_rw_authorize_request_t const * p_evt_rw_authorize_request = &p_ble_evt->evt.gatts_evt.params.authorize_request;
    uint32_t err_code;

    if (p_evt_rw_authorize_request->type  == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
    {
         if (p_evt_rw_authorize_request->request.write.handle == p_motion->calibrate_char_handles.value_handle)
        {
            ble_gatts_rw_authorize_reply_params_t rw_authorize_reply;
            bool                                  valid_data = true;
            uint16_t                              data_length = p_evt_rw_authorize_request->request.write.len;

            // Check for valid data
            if (data_length != sizeof(ble_calibrate_t))
            {
                valid_data = false;
            }
            else
            {
                ble_calibrate_t * p_calib = (ble_calibrate_t *)p_evt_rw_authorize_request->request.write.data;

                if ( ((p_calib->calibrate > 0) && (p_calib->calibrate < 255)))
                   
                     
                {
                    valid_data = false;
                }
            }

            rw_authorize_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE;

            if (valid_data)
            {
                rw_authorize_reply.params.write.update      = 1;
                rw_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_SUCCESS;
                rw_authorize_reply.params.write.p_data      = p_evt_rw_authorize_request->request.write.data;
                rw_authorize_reply.params.write.len         = p_evt_rw_authorize_request->request.write.len;
                rw_authorize_reply.params.write.offset      = p_evt_rw_authorize_request->request.write.offset;
            }
            else
            {
                rw_authorize_reply.params.write.update      = 0;
                rw_authorize_reply.params.write.gatt_status = BLE_GATT_STATUS_ATTERR_WRITE_NOT_PERMITTED;
            }

            err_code = sd_ble_gatts_rw_authorize_reply(p_ble_evt->evt.gatts_evt.conn_handle,
                                                       &rw_authorize_reply);
            APP_ERROR_CHECK(err_code);

            if ( valid_data && (p_motion->calib_write_handler != NULL))
            {
               p_motion->calib_write_handler(p_motion,(ble_calibrate_t *)p_evt_rw_authorize_request->request.write.data);
            }
        }
        
    }
}

...
...


static uint32_t calibrate_char_add(ble_motion_t * p_motion, const ble_motion_init_t * p_motion_init)
{
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_t    attr_char_value;
    ble_uuid_t          ble_uuid;
    ble_gatts_attr_md_t attr_md;

    memset(&char_md, 0, sizeof(char_md));

    char_md.char_props.read          = 1;
    char_md.char_props.write         = 1;
    char_md.char_props.write_wo_resp = 0;
    char_md.p_char_user_desc         = NULL;
    char_md.p_char_pf                = NULL;
    char_md.p_user_desc_md           = NULL;
    char_md.p_cccd_md                = NULL;
    char_md.p_sccd_md                = NULL;

    ble_uuid.type = p_motion->uuid_type;
    ble_uuid.uuid = BLE_CALIBRATE_CHAR;

    memset(&attr_md, 0, sizeof(attr_md));

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm);
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm);

    attr_md.vloc       = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth    = 0;
    attr_md.wr_auth    = 1;
    attr_md.vlen       = 0;

    memset(&attr_char_value, 0, sizeof(attr_char_value));

    attr_char_value.p_uuid       = &ble_uuid;
    attr_char_value.p_attr_md    = &attr_md;
    attr_char_value.init_len     = sizeof(ble_calibrate_t);
    attr_char_value.init_offs    = 0;
    attr_char_value.max_len      = sizeof(ble_calibrate_t);;
    attr_char_value.p_value      = ((uint8_t *)(&p_motion_init->init_calibrate));

    return sd_ble_gatts_characteristic_add(p_motion->service_handle,
                                           &char_md,
                                           &attr_char_value,
                                           &p_motion->calibrate_char_handles);
}


void ble_motion_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context)
{
    ble_motion_t * p_motion = (ble_motion_t *) p_context;

    if ((p_motion == NULL) || (p_ble_evt == NULL))
    {
        return;
    }

    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_CONNECTED:
            on_connect(p_motion, p_ble_evt);
            NRF_LOG_INFO("BLE UI connected\r\n");
            break;

        case BLE_GAP_EVT_DISCONNECTED:
            on_disconnect(p_motion, p_ble_evt);
            break;

        case BLE_GATTS_EVT_WRITE:
            on_write(p_motion, p_ble_evt);
            break;

        case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
            on_authorize_req(p_motion, p_ble_evt);
            break;

        default:
            // No implementation needed.
            break;
    }
}




uint32_t ble_motion_init(ble_motion_t * p_motion, const ble_motion_init_t * p_motion_init)
{
    uint32_t   err_code;
    ble_uuid_t ble_uuid;

    // Initialize service structure.
    p_motion->conn_handle             = BLE_CONN_HANDLE_INVALID;
//    p_motion->evt_handler             =  p_motion_init->evt_handler;
   

    ble_uuid128_t base_uuid = LSPOT_BASE_UUID;
    err_code = sd_ble_uuid_vs_add(&base_uuid, &p_motion->uuid_type);
    VERIFY_SUCCESS(err_code);

    ble_uuid.type = p_motion->uuid_type;
    ble_uuid.uuid = BLE_MOTION_SERVICE;

    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_motion->service_handle);
    VERIFY_SUCCESS(err_code);

    // Add characteristics.
    err_code = raw_data_char_add(p_motion, p_motion_init);
    VERIFY_SUCCESS(err_code);

     err_code = current_char_add(p_motion, p_motion_init);
    VERIFY_SUCCESS(err_code);


    err_code = calibrate_char_add(p_motion, p_motion_init);
    VERIFY_SUCCESS(err_code);


    return NRF_SUCCESS;
}

ble_motion.h

.
...
...

typedef PACKED( struct
{
    uint8_t calibrate;  /**< Transisior 1 */
   
}) ble_calibrate_t;

typedef struct ble_motion_s          ble_motion_t;

typedef void (*ble_calibrate_write_handler_t) (ble_motion_t * p_motion, ble_calibrate_t * calib);

typedef struct
{
    ble_current_t                   init_current;
    ble_calibrate_t                 init_calibrate;
    ble_calibrate_write_handler_t   calib_write_handler;
    
} ble_motion_init_t;


struct ble_motion_s
{
    uint16_t                    service_handle;  
    uint8_t                     uuid_type;                 
    uint16_t                    conn_handle; 
    ble_gatts_char_handles_t    raw_data_char_handles;          
    ble_gatts_char_handles_t    threshold_char_handles;          
    ble_gatts_char_handles_t    side_current_char_handles;       
    ble_gatts_char_handles_t    front_current_char_handles;       
    ble_gatts_char_handles_t    calibrate_char_handles;       
    ble_gatts_char_handles_t    tracking_char_handles;       
    ble_gatts_char_handles_t    device_pos_char_handles;       
    ble_gatts_char_handles_t    angle_pos_char_handles;       
    ble_gatts_char_handles_t    pos_config_char_handles;       
    ble_gatts_char_handles_t    vib_config_char_handles;                      
    bool                        is_raw_data_notif_enabled;
    bool                        is_threshold_notif_enabled;
    bool                        is_side_current_notif_enabled;
    bool                        is_front_current_notif_enabled;
    ble_calibrate_write_handler_t   calib_write_handler;
    
};

void ble_motion_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context);

uint32_t ble_motion_init(ble_motion_t * p_motion, const ble_motion_init_t * p_motion_init);

and declared at motion.c

...
...



...

static void ble_calibrate_handler(ble_motion_t * p_motion, ble_calibrate_t * calib)
{
    ret_code_t         err_code;
      NRF_LOG_INFO("RECEIVED VALUE :%d",calib->calibrate);

}



static ret_code_t service_init(bool major_minor_fw_ver_changed)
{
    uint32_t                                    err_code;
    ble_motion_init_t                           motion_init;
    motion_init.init_calibrate.calibrate  =     5;
    motion_init.calib_write_handler       =     ble_calibrate_handler;
    //uis_init.device_write_handler = ble_uis_device_handler;

   return ble_motion_init(&b_motion, &motion_init);
}

RE: CUSTOM BLE SERVICE : READ WRITE RESPONSE

Hung Bui — Tue, 02 Jun 2020 14:20:07 GMT

Hi Sunil,
You set

BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);

So both read and write permission are not allowed. This explain why you can't read. Note that permission is different from properties. Properties is the information the peer can get from the server, but the permission is the actual configuration of the read/write attribute.

You need to set

BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.read_perm);
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&attr_md.write_perm);

instead.