Gecko Bootloader can load application images into the application area from different sources.

• It can load from host controller via UART/SPI.
• It can load from a remote device OTA (over-the-air) via Bluetooth connection with the help of the Apploader.
• It can load from internal flash (if the internal flash is big enough to accomodate both the application code and an upgrade image).
• It can load from external flash.

What it cannot do is uploading the application image to a temporary storage slot of the internal/external flash before loading it from there into the application area. This article helps you implement the missing step: uploading the image to the internal/external flash via a Bluetooth connection.

This article guides you through how to upload images to storage slots using the standard OTA DFU process (used by the OTA Apploader). To learn how to load the uploaded images from the slots into the application area please read this article: https://www.silabs.com/community/wireless/bluetooth/knowledge-base.entry.html/2017/07/19/switching_betweenfi-GnNI

To make the OTA uploader compatible with Silicon Labs Bluetooth OTA Apploader that loads the image directly to the application area, first we have to understand how the standard OTA DFU method works.

The standard OTA DFU sequence (implemented in the OTA Apploader) looks like this:

1. App is running.
2. Device is reset into DFU mode. In this mode the bootloader will start the Apploader instead of the Application. The Apploader is a simple application with a minimal Bluetooth stack, that handles the upload process. The Apploader uses the API of the Gecko Bootloader to decode the GBL files and to store the application image in the flash. (Note: before Bluetooth SDK v2.7 the Apploader was built into the stack binary and was referenced as supervisor code. To learn more about the legacy OTA update process please refer to AN1045: Bluetooth ® Over-the-Air Device Firmware Update for EFR32xG1 and BGM11x Series Products. Standalone Apploader is used only since Bluetooth SDK v2.7)
   
3. The Apploader advertises and waits for a Bluetooth connection
4. The Apploader waits for the OTA start command (using OTA control characteristic)
5. The Apploader starts receiving the GBL file (using OTA data characteristic)
6. The headers of the GBL file are stored in Slot 0 to be parsed
   
7. After parsing the headers, the rest of the GBL file is decoded on-the-fly, and the application is copied right to the application area, overwriting the old application
   
8. The Apploader receives the OTA end command and restarts the device in normal mode.

The OTA uploader uses a similar process:

1. App is running (device is not reset, since the uploader is implemented in the user application)
   
2. If there are multiple slots, the remote device chooses which slot to upload to, using a custom characteristic (e.g. slot0. Slot0 can be either in the internal or in the external flash. The application do not have to know this, flash is handled by the bootloader API)
3. The uploader waits for the OTA start command (using OTA control characteristic)
4. The uploader starts receiving the GBL file (using OTA data characteristic)
5. the GBL file is saved into slot0/slot1 as it is using the bootloader API (the application does not have to know where Slot0/Slot1 is located, bootloader API handles the writing)
   
6. The uploader receives the OTA end command
7. If there are multiple slots, the remote device may upload a new image to the other slot(s)
8. The remote device chooses which slot to bootload from using a custom characteristic
9. The device is reset in bootloader mode
10. The bootloader parses the given slot, retrieves the Application code from the GBLfile and copies the code to the application area from the internal/external flash
    
11. The bootloader starts the new Application

Implementation

The attached code implements image uploading to the slots using the standard OTA process. It is also extended with the possibility to select a slot to upload to, and to select a slot to boot from. You are free to modify this example according to your needs.

To create a project with multislot OTA DFU follow these steps:

1. Create an Internal Storage Bootloader (multiple images) or a SPI Flash Storage Bootloader (multiple images) project in Simplicity Studio
2. Check the Storage Slot configuration in AppBuilder and modify it according to your needs.
3. Generate and build the project
    
4. Create a SoC – Empty project
5. Remove the Silicon Labs OTA service from your GATT database if it is present
6. Add the Silicon Labs OTA service in Visual GATT Editor (BLE GATT Configurator)
   1. On the left plane select Services
   2. Find Silicon Labs OTA services
   3. Drag and drop it to the right pane
   4. Select the Silicon Labs OTA Data characteristic
   5. Set its type to user (the content will not be stored to database but processed by the application)
   6. Set its length to 244
   7. Set Write and Write Without Response properties to true
   8. Select the Silicon Labs OTA control characteristic
   9. set its type the user
   10. Set Write and Write Without Response properties to true
7. Add Slot Manager service in Visual GATT Editor (only needed if you want to manage multiple slots)
   1. Add a new service, named e.g. Slot Manager Service
   2. Add a new characteristic within this service called e.g. Upload Slot (this will be used to select a slot to upload data to)
   3. Set its ID to upload_slot (needed for reference in the code)
   4. Set its type to hex
   5. Set its length to 1
   6. Add Read and Write properties
   7. Add a new characteristic within this service called e.g. Bootload Slot (this will be used to trigger bootload from the given slot)
   8. Set its ID to boot_slot (needed for reference in the code)
   9. Set its type to hex
   10. Set its length to 1
   11. Add Write property
8. Now your GATT database should look like this:
                                   
9. Click Generate to build the GATT database
10. Copy the attached ota_dfu_multislot.c and ota_dfu_multislot.h files into the project
11. Copy btl_interface.c and btl_interface_storage.c from C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v1.1\platform\bootloader\api to your project
12. Go to Project Properties > C/C++ Build > Settings and add the following folders to the Includes:
    "${StudioSdkPath}/platform/bootloader"
    "${StudioSdkPath}/platform/bootloader/api"
    or copy the .h files from these folders to your project
13. Remove apploader from the project as we won't need it anymore:
    1. Go to Project Properties > C/C++ Build > Settings
    2. Go to GNU ARM C Linker > Miscellaneous or IAR Linker for ARM > Library 
    3. Remove binapploader.o from the list
14. Add the followings to main.c
    1. Add #include “ota_dfu_multislot.h” to the beginning of main.c
    2. Add ota_dfu_handle_event(evt); after evt = gecko_wait_event();
    3. Remove the code that triggers DFU reset upon writing into ota_control characteristic

       //case gecko_evt_gatt_server_user_write_request_id:
       // ... 
       //break;

        

    4. Save main.c
15. Build the project
     
16. Add the bootloader image to your application image as described here:

    http://community.silabs.com/t5/Bluetooth-Wi-Fi-Knowledge-Base/Adding-Gecko-Bootloader-to-Bluetooth-projects/ta-p/195432

    (Note: setting gecko_bootloader=true in the .isc file will copy btl_interface.c and btl_interface_storage.c into your project again. Remove the instances you copied before to avoid duplicated definitions)

17. Flash the image to your device

Usage

1. Create full.gbl file from the application you want to upload. (Note: since the uploader is implemented in the user application, and not in the Apploader, you should implement the uploader in the application to be uploaded, as well!!) E.g.
   1. Make a copy of your multislot OTA DFU project
   2. Change the Device Name from “Empty Example” to “Updated app” in the Visual GATT Editor
   3. Press Generate
   4. Build the project
   5. Run create_bl_files.bat
   6. Find the .gbl files in output_gbl folder
2. Copy full.gbl to your smartphone (in case of Android copy it to SiliconLabs_BGApp/OTAFiles/myproject, in case of iOS upload it to iCloud)
3. Open Blue Gecko app on your smartphone
4. Find your device with Bluetooth browser (advertising as Empty Example) and connect to it
5. Find the unknown service and open it (this is your custom service including Upload slot and Bootload slot characteristics)
6. Open the first characteristic (this is the upload characteristic) and write the slot number in it, you want to upload to
7. In the local menu select OTA
8. Select the partial OTA tab
9. Select the folder and the full.gbl file you want to upload
10. Click OTA. The file will be uploaded to the selected slot.
11. Now open the second characteristic in the unknown service (Bootload slot) and write the slot number in it, you want to load the application from. The device will be reset and the application will be loaded.
12. Disconnect and find your device advertising itself as “Updated app”