Hi,
I already achieved the update of all available nodes in a mesh network, where the update is injected over a serial connection to one node.
Now my question is, if I can load the whole update into the flash of the nRF52833 and then start the update if the whole dfu is on the device.
If this is possible, where should I start? Can I somehow overwrite the current serial connection in the DFU Mesh example with flow control to give back a successful
response when I saved the packet?
Hi Sebastian,
It's actually not too hard to achieve what you are looking for.
The way it currently works is that the nrfutil sends the init data and the image in small packets with 16 byte payload each and at 0.5 second interval. The application when receiving these packet (with opcode from SERIAL_OPCODE_CMD_RANGE_OPENMESH_START to SERIAL_OPCODE_CMD_RANGE_OPENMESH_END) will forward to the bootloader using a SVC call provided by the bootloader. The bootloader will then call a call back to either notify to the application or to wait for command from application (only relay or relay and replace image).
What you need to do is to replace the UART communication and send data directly from the application to the bootloader.
As you already found, a packet with SERIAL_OPCODE_CMD_OPENMESH_DFU_DATA opcode will be forwarded to the bootloader using nrf_mesh_dfu_rx()
For the call back, you can find an example on how to handling it inside mesh_evt_handler() in main.c in the dfu application example.
To know how the nrfutil send the image, please have a look at here: https://github.com/NordicSemiconductor/pc-nrfutil/blob/mesh_dfu/nordicsemi/dfu/dfu_transport_mesh.py
And at _dfu_send_image() function inside here: https://github.com/NordicSemiconductor/pc-nrfutil/blob/mesh_dfu/nordicsemi/dfu/dfu.py
You can speed up the process by reducing the 0.5 second interval (SEND_DATA_PACKET_WAIT_TIME) however this will increase the risk that the packet is not distributed properly to the whole network before new packet is broadcasted.
Thank you, I can now download the file over the python script, but I won't have enough flash to achieve that. How does the normal DFU process work? It needs somehow to store all the packets of the new firmware and flash it at the end, right? If so, where does it store the files?
You can find in the dfu example (from SDK v3.2) we have the function called optimal_bank_address(). This is where we find the location to store the new image.
The best way of storing the new image is to store it right after the current application. However our current bootloader doesn't support it, so it's calculated at the middle of the free area (end of application address and beginning of persistent data flash address).
How do you plan to send the image to the first nRF52 ? Is it via a programmer ? Or via BLE ? or other medium ?
I will send the image over Serial at the moment and later I want to send it over BLE to the first node. I think the idea is more like to store the image first on one node and then distribute it in the mesh network as usual.
I see, so my understanding is the main point of this application is to reduce the time you need to connect the DFU master (the UART device or the BLE device) to the DFU unit. After you transfer the image to the DFU unit (which should take less than a minute), you can leave the DFU unit to broadcast the image to the mesh network ?
If that's the case, you would need to build the application so that it can receive the image, store it into flash, and then from there, start to call the bootloader APIs to send the pieces of the image to the bootloader for broadcasting.
I would expect a good amount of work needed to achieve this. But it's not a very difficult task. You just need to understand the protocol how we send the image to to the bootloader. Unfortunately it's not very well documented. But you can start by looking at the nrfutil source code and the bootloader source code.
The protocol for the normal BLE DFU described here (format of init packet) it should be similar to what inside the .zip package for MESH DFU : https://infocenter.nordicsemi.com/topic/sdk_nrf5_v16.0.0/lib_bootloader_dfu_validation.html?cp=7_1_3_5_1_1_0#lib_bootloader_dfu_init
You are right, I try to save connection time for an end user.
I try now to write to the same flash address as will be used for the bootloader. For this, I use the optimal_bank_address() function provided in the examples for DFU. Now I have my address and my packets, but I don't know how I can now read from the flash. There is nrf_flash.c which provides a write function, but there is no read function. How Can I read out the flash data I wrote?
You can just use a pointer variable and point that pointer to an address in the flash to read it. There is no different between flash and ram when it come to reading. That's why we don't have a function for read. You can use an array pointer.
Check function flashwrite_read_cmd() in flashwrite example.
You can just use a pointer variable and point that pointer to an address in the flash to read it. There is no different between flash and ram when it come to reading. That's why we don't have a function for read. You can use an array pointer.
Check function flashwrite_read_cmd() in flashwrite example.
