5.1.2.4 BLE Deep Sleep Advertising

Recommended Readings

1. Getting Started with Application Building Blocks – See Building Block Examples from Related Links.

2. Getting Started with Peripheral Building Blocks – See Peripheral Devices from Related Links.

3. FreeRTOS and BLE Stack Setup – See Peripheral - FreeRTOS BLE Stack and App Initialize from Related Links.

4. BLE Software Specification – See MPLAB® Harmony Wireless BLE in Reference Documentation from Related Links.

5. See Low Power Design on PIC32CX-BZ3 Devices from Related Links.

Hardware Requirement

SDK Setup

Refer to Getting Started with Software Development from Related Links.

Software

To install Tera Term tool, refer to the Tera Term web page in the Reference Documentation from Related Links.

Smartphone App

Microchip Bluetooth® Data (MBD) iOS/Android app available in stores.

Programming the Precompiled Hex File or Application Example

Using MPLAB® X IPE:

1. Import and program the precompiled hex file: <Discover Path>\wireless_apps_pic32cxbz3_wbz35\apps\ble\building_blocks\peripheral\deep_sleep_adv\hex\deep_sleep_adv.X.production.signed.hex.
2. For detailed steps, refer to Programming a Device in MPLAB® IPE in Reference Documentation from Related Links.
   Note: Ensure to choose the correct Device and Tool information.

Using MPLAB® X IDE:

1. Perform the following the steps mentioned in Running a Precompiled Example. For more information, refer to Running a Precompiled Application Example from Related Links.
2. Open and program the application: <Discover Path>\wireless_apps_pic32cxbz3_wbz35\apps\ble\building_blocks\peripheral\ deep_sleep_adv\firmware\deep_sleep_adv.X.
3. For more details on how to find the Discover path, refer to Download Application Example from Discover in Running a Precompiled Application Example from Related Links.

Demo Description

This application example enables users to enter Deep Sleep mode while transmitting Connectable, Undirected BLE Advertisements. On power-on reset, the application will enter Deep Sleep mode. When USR-BTN1 (SW2) is pressed, the device on-board GREEN LED starts blinking to denote the start of advertisements. The device will then enter Deep Sleep mode periodically based on the advertisement interval of 1 second. When the device connects with the mobile app, the onboard LED starts to glow solid, which indicates that the connection is established and the device will enter Standby Sleep mode during Idle state.

Testing

Current Consumption Measurement

Hardware modification

Connect a Multimeter/Power Debugger/Oscilloscope to Power Measurement Header J5. If using a Power Debugger, users can use Data Visualizer to measure the current consumption.

Current measured in Deep sleep mode is around 1.9 uA.

Current measured in Deep sleep + Advertising mode is around 130 uA average.

Users of this early adopter package should go through the known issues document and understand the limitations, if any, with the current low power mode implementation.

Developing the application from scratch

There are two possible ways to develop this application. In the following section, users can make use of the import method available in the MPLAB Code Configurator (MCC). This is the easiest and quickest way to recreate the application with the help of an import component configuration. In the second section, users can experience the complete application development from scratch using the MCC.

1. Developing this Application using MPLAB Code Configurator Import method
2. Developing this Application from scratch using MPLAB Code Configurator

Developing this Application using MPLAB Code Configurator Import method

1. Create a new harmony project. For more details, see Creating a New MCC Harmony Project from Related Links.

2. Setup the basic components and configuration required to develop this application, import component configuration: <Discover Path>\wireless_apps_pic32cxbz3_wbz35\apps\ble\building_blocks\peripheral\deep_sleep_adv\firmware\deep_sleep_adv.X\deep_sleep_adv.mc4

   For more details on importing the component configuration, refer to Importing Existing App Example Configuration from Related Links.
   Note: Import and Export functionality of the Harmony component configuration will help users to start from a known working setup of the MCC configuration.
3. Accept dependencies or satisfiers when prompted.
4. Verify if the Project Graph window has all the expected configuration.

   

Developing this Application from scratch using MPLAB Code Configurator

1. Create a new harmony project. For more details, see Creating a New MCC Harmony Project from Related Links.

2. In the previous step, the BLE Stack component is included. Accept all the component auto-activations and attachment auto-connect confirmations.

   

3. Include the RCON Component from the peripheral category.
   

4. Include the Transparent Service and Transparent Profile component located at : Harmony-> Wireless->Drivers->BLE.

5. Establish the link between the Transparent Service and Profile components.

   

6. Click Transparent Profile component. In the configuration option, select Enable Server Role.

   
7. Click BLE Stack component. In the configuration option, select Enable Sleep Mode.
   
8. This action will trigger the auto inclusion of the RTC component. Accept the activations and auto-connect confirmations.
   
9. Final Project graph with all the required component.

   

Verify Advertisement and Component Configuration

This section details the configuration changes needed for each component in accordance with the application use case implementation.

Generate Code

For more details on code generation, refer to MPLAB Code Configurator (MCC) Code Generation from Related Links.

Files and Routines Automatically generated by the MCC

After generating the program source from the MCC interface by clicking Generate Code, the BLE configuration source and header files can then be found in the following project directories.

Initialization routines for OSAL, RF System, and BLE System are auto-generated by the MCC. See OSAL Libraries Help in Reference Documentation from Related Links. Initialization routine executed during program initialization can be found in the project file.

The BLE stack initialization routine executed during Application Initialization can be found in project files. This initialization routine is automatically generated by the MCC. This call initializes and configures the GAP, GATT, SMP, L2CAP and BLE middleware layers.

During system sleep, clock (system PLL) will be disabled and system tick will be turned off. FreeRTOS timer needs to be compensated for the time spent in sleep. RTC timer which works in sleep mode is used to accomplish this. RTC timer will be initialized after BLE stack initialization.

Header Files

• ble_gap.h contains BLE GAP functions and is automatically included in app.c

Manual Application Code Edit

This section talks about the mandatory code modifications that need to be incorporated in order to implement the Deep Sleep Advertising functionality.

1. app_user_edits.c
   • Some of the Harmony 3 generated files cannot be fully configured by the MPLAB Code Configurator. This file contains the instructions for the user to modify these files.

     Follow the instruction mentioned in app_user_edits.c and after completing the required edits, comment out or remove the #error line

2. Initialization.c
   • Comment the code inside SYS_Initialize function

     In the MCC Generated Code, the CLK_Initialize() and ROM functions are by default present inside the SYS_Initialize() function. The user needs to comment out the code referring to CLK_Initialize() and ROM functions in the SYS_Initialize() function and should add under _on_reset() function in same initialization.c file.

     

   • Code Inclusion inside _on_reset function

     The previously commented code inside SYS_Initilaze() function is included here

     

     CLK_Initialize(); 
         typedef int (*FUNC_PCHE_SETUP)(uint32_t);
         ((FUNC_PCHE_SETUP)(*(uint32_t*)0xF2D0))((PCHE_REGS->PCHE_CHECON & (~(PCHE_CHECON_PFMWS_Msk | PCHE_CHECON_ADRWS_Msk | PCHE_CHECON_PREFEN_Msk)))
                                         | (PCHE_CHECON_PFMWS(2) | PCHE_CHECON_PREFEN(1)));																
         //Set RF as idle mode
         RF_SetIdleMode();

   • Code Inclusion inside SYS_Initialize function

     DEVICE_DeepSleepWakeSrc_T wakeSrc;
     DEVICE_GetDeepSleepWakeUpSrc(&wakeSrc);
     if (wakeSrc == DEVICE_DEEP_SLEEP_WAKE_NONE) //Initialize RTC if wake source is none(i.e power on reset)
     {
      RTC_Initialize();
     }

     

3. heap_4.c
   • Comment the below code and replace it with the Modified Code inside heap_4.c (available as part of FreeRTOS>MemMang)

   

   static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; --> Original Code 
    
   static uint8_t  __attribute__((section (".bss.ucHeap"), noload)) ucHeap[ configTOTAL_HEAP_SIZE ]; -->Modified Code

4. Plib_rtc.h

Step 4 -

• Default generated: #define RTC_COUNTER_CLOCK_FREQUENCY (0U / (1UL << (0x1U - 1U)))
• Replace to: #define RTC_COUNTER_CLOCK_FREQUENCY (32768U / (1UL << (0x1U - 1U)))

Step 5 - Plib_clk.c

//check CLDO ready
    while ((CFG_REGS->CFG_MISCSTAT & CFG_MISCSTAT_CLDORDY_Msk) == 0);    
    
    //programming 4ms delay -  programming subsys_xtal_ready_delay  -> Reduce to 2ms
    //check xtal spec for delay required
    BTZBSYS_REGS->BTZBSYS_SUBSYS_CNTRL_REG1 = ((BTZBSYS_REGS->BTZBSYS_SUBSYS_CNTRL_REG1 & ~BTZBSYS_SUBSYS_CNTRL_REG1_subsys_xtal_ready_delay_Msk)
                                                | ((0x01) << BTZBSYS_SUBSYS_CNTRL_REG1_subsys_xtal_ready_delay_Pos)); 
    //wait for crystal ready
    while((BTZBSYS_REGS->BTZBSYS_SUBSYS_STATUS_REG1 & BTZBSYS_SUBSYS_STATUS_REG1_xtal_ready_out_Msk) != BTZBSYS_SUBSYS_STATUS_REG1_xtal_ready_out_Msk);

    // set PLL_enable
    BLE_REGS->BLE_DPLL_RG2 &= ~(0x02);

    //programming delay for pll lock - 500 us -> Reduce to 64us
    //32 us steps - check pll spec for final value 
    BTZBSYS_REGS->BTZBSYS_SUBSYS_CNTRL_REG3 = ((BTZBSYS_REGS->BTZBSYS_SUBSYS_CNTRL_REG3 & ~BTZBSYS_SUBSYS_CNTRL_REG3_subsys_pll_ready_delay_Msk )
                                                   | ((0x02) << BTZBSYS_SUBSYS_CNTRL_REG3_subsys_pll_ready_delay_Pos));

Step 6 - WBZ351.ld

• Additional linker file related changes need to be incorporated to define the backup RAM address. This configuration will be later made available in the MCC configuration. Until then, this manual edit is required.
• The highlighted code in the below image needs to be incorporated to the MCC generated WBZ351.ld file

User Application Development

Include

Enter Deep Sleep mode

• DEVICE_EnterDeepSleep(false,0);

  This API can be called to put the device to Deep Sleep mode.

Start Deep Sleep Advertisement

• APP_BleDsadvStart(false); 

  This API can be called in APP_STATE_INIT of app.c to start the Deep Sleep Advertising.

  Note: Users can explore more BLE Advertisement functionalities using the BLE Stack APIs. For more information, refer to BLE Stack in Reference Documentation from Related Links.

Application Use Case Implementation

This application implementation is purely user choice. It is designed in such a way that the device enters into Deep Sleep mode upon power up and when SW2 is pressed, the device starts the Deep Sleep Advertisements based on the fixed advertisement interval. Device then wakes up from Deep Sleep in regular intervals to start an advertisement and go back to sleep again.

This scenario is implemented by modifying the default generated code inside the switch case in app.c. User can implement their desired application workflow by making use of the available function calls.