long write samples

RE: long write samples

Ulrich Myhre — Fri, 19 Sep 2014 09:54:48 GMT

Your understanding is correct, as long as you remember to skip "length" number of bytes to find the next chunk. I do not have the capacity to recreate your project, so maybe you could provide some sample data and the associated uart prints you got from it? Maybe in a private message if you do not want to show too much of your work.

RE: long write samples

Aashish Patel — Thu, 18 Sep 2014 20:02:26 GMT

Hello, I have tried parsing the mem_block we are passing to SD. But getting confused on the parser implementation. I have tried different methods but I am not getting result. Referring to the user mem layout given here

But I am getting inconsistent results. If I read length of memblock it shows proper value for less than 20 bytes value but above 20 bytes it shows same value.

This is my understanding of user mem layout. So SD writes total value provided to it in chunks to user_mem_block. In case of long write to same characteristic with same handle but with increasing offset changed. So parser we will have to read first chunk then move chunk bytes ahead ..and check handle value again read chunk and so on till we get BLE_GATT_HANDLE_INVALID. I implemented a parser like this but didn't get proper result.

Then I just printed the contents of mem_queue.I was getting proper values till 35-36 bytes but then again some random bytes then remaining bytes.

case BLE_GATTS_EVT_WRITE:
       								
					simple_uart_putstring("In Write Event\n\r");

					if (p_ble_evt->evt.gatts_evt.params.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW)
					{
						  simple_uart_putstring("In Write Req Now Op\n\r");	
						  int i;
							for (i = 0; i < MEM_BLOCK_SIZE ; i++)
							{
								simple_uart_put(m_mem_block.p_mem[i]);
							}
							
					}
					simple_uart_put('\n');
					simple_uart_put('\r');
        break;

If you can give me a simple illustration of a parser then it would be great. Forgot to mention I am using dongle running MCP firmware to send long write values over BLE.

Please ignore if there are any typos (I haven't had much sleep in last 2 days).

RE: long write samples

Aashish Patel — Tue, 16 Sep 2014 14:23:12 GMT

Thanks your detailed response. I will test with both approach where stack handles request and where application handles request. In case of stack handling the memory, I would have to pass address and length of memory block to my data handler from on_write function in applicatio right ? .. will try this things and update.

RE: long write samples

Ulrich Myhre — Tue, 16 Sep 2014 14:03:53 GMT

If you choose to let the stack handle the memory for you, you will not be able to see the individual chunks coming in until the execute happens. Then all of them will arrive in a single write event. If you let your application handle each request, they will arrive as BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST which you have to authorize one by one. You can choose between these behaviors by giving a mem block in mem_reply (stack handled) or NULL (app handled). The MSCs for the APP handled variant can be found here: devzone.nordicsemi.com/.../a00856.html

RE: long write samples

Aashish Patel — Mon, 15 Sep 2014 15:21:34 GMT

as per your suggestion I have set reliable_wr flag for android to detect and following the sequence you have suggested. But I have one doubt on nordic app side. I think I will have to modify on_write(): if ( (p_evt_write->handle == p_nus->rx_handles.cccd_handle) && (p_evt_write->len == 2) ) { if (ble_srv_is_notification_enabled(p_evt_write->data)) { p_nus->is_notification_enabled = true; } else { p_nus->is_notification_enabled = false; } } else if ( (p_evt_write->handle == p_nus->tx_handles.value_handle) && (p_nus->data_handler != NULL) ) { p_nus->data_handler(p_nus, p_evt_write->data, p_evt_write->len); } else { // Do Nothing. This event is not relevant to this service. }

and data_handler function void nus_data_handler(ble_nus_t * p_nus, uint8_t * p_data, uint16_t length) { for (int i = 0; i < length; i++) { simple_uart_put(p_data[i]); } simple_uart_put('\n'); }

As per my understanding whatever mem_block we pass is populated in reliable write. So in on write function Can I just send contents of mem_block byte by byte to console using simple_uart_put ?

RE: long write samples

Ulrich Myhre — Mon, 15 Sep 2014 12:54:38 GMT

I am not exactly sure on how to do this from the Android side, sorry. Your app should call beginReliableWrite(), proceed with multiple writeCharacteristic() calls with chunks of 20-byte, then end with an executeReliableWrite(). This should trigger a USER_MEM_REQUEST, and after some delay, a GATTS_EVT_WRITE followed by a USER_MEM_RELEASE event. You might have to set the "reliable_wr" flag in the char_ext_props field to 1 when adding the characteristic for Android to discover this functionality.

RE: long write samples

Aashish Patel — Mon, 15 Sep 2014 12:41:41 GMT

I have increased MAX_TX_CHAR_LEN ..also added BLE_EVT_USER_MEM_REQUEST an passed pointer to mem buffer of size 100 ...changed ble_uart_code ..but still I see only 20 bytes on uart console output.

Do I need to send data from peer (android app in chunks of 20 bytes ) .. for this to work properly...I have created a android for sending data.

RE: long write samples

Ulrich Myhre — Mon, 15 Sep 2014 08:12:34 GMT

You will have to set BLE_NUS_MAX_TX_CHAR_LEN to something larger than 20.

RE: long write samples

Aashish Patel — Mon, 15 Sep 2014 07:36:38 GMT

Thanks for quick response

Reliable write would work for us as we want to write data (which is more than 20 bytes long) to a characteristic using android app. For eg: "Nordic semiconductor application". This characteristic value should than be displayed on console.

ble_app_uart is working fine for me. But it only displays 20 bytes no matter how much data we send.

So what modifications should I make to this example and where to make it working for more than 20 bytes.

RE: long write samples

Ulrich Myhre — Mon, 15 Sep 2014 07:27:57 GMT

I think you might be confusing long writes and long MTU.

Long writes, also called "Reliable writes" or "Queued Writes", allows you to reliably and simultaneously write multiple <=20-byte chunks to a single or multiple characteristic(s)/descriptor(s). It does not allow you to transfer more data per connection event than other functions. (There are some restrictions in peer memory, and you are not allowed to have overlapping regions.) See here for some MSCs.

If you want to send more than 20 bytes, you will have to break it down into chunks. If you need to write all the chunks at the same time (i.e. you want to update some data display that continuously reads more than 20 bytes of data each update) you can use reliable writes. If you want to enable/disable multiple CCCDs you can use reliable writes. However, if you need to send more than 20 bytes per packet, that is not currently possible with the Nordic SoftDevices.