RE: Writing long characteristic values

Samuele Forconi — Mon, 24 Mar 2014 10:05:53 GMT

Hi Ole, thanks for your answer and sorry for my late reply, but I was sick.

Your answer is very well explained, so I managed to get the handle written doing some little modifications to the on_write function and instead of checking the value_handle I setup this code:


if(p_evt_write->op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW)
{
	if(*((uint16_t *)m_mem_block.p_mem) == p_actrl->dhc_handles.value_handle)
	{
            printf("LONG CHARACTERISTIC WRITTEN!\r\n");
        }
}

And now the program prints also the "LONG CHARACTERISTIC WRITTEN!" on the console.

Thanks for your support.

Regards, Samuele.

RE: Writing long characteristic values

Ole Morten — Tue, 18 Mar 2014 14:05:13 GMT

Your implementation seems correct, but you may have misunderstood somewhat how the conclusion of a long write is.

In summary, a handle is only included in each Prepare Write Request, and these are not directly given to your application when not using authorization (since they include partial values and are in general not very useful, since they haven't yet been written). Instead, only the Execute Write is given as an event to the application, and this contains no handle information by spec. Hence, the event that comes to the application is also without handle, but with a specific type; BLE_GATTS_OP_EXEC_WRITE_REQ_NOW (ble_gatts.h).

At this point, if you want to know which handle(s) were written, you'll have to manually parse the memory block you gave to the softdevice. The format for this memory is given here.

Depending on what you want, it may also be an option to just look at the actual value the attribute contains at this point. When you get the write event, the data in the GATT Table have already been updated, be it in the memory you've set aside for the block (in case of VLOC_USER), or inside the stack (in case of VLOC_STACK). If the latter, you can get the new value only by using sd_ble_gatts_value_get().

Part of the reason for doing it this way is as I mentioned above that the partial writes could in some cases be aborted and not committed. Also, as part of one queued write any number of handles could in theory be written to.

If you need further information on how this works, I'd recommend you to take a close look at MSC you link to, and combine it with the information in the Core Specification about the different requests involved (Volume 3, Part F, section 3.4.6). Please let me know if you need elaborations on something.