NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

RE: NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

Turbo J — Sat, 31 May 2025 11:18:27 GMT

Might be pending FPU Exceptions. Roughly 0.5mA current seem likely.

The non-RTOS samples in the SDK should all have code (called from idle_state_handler) that silences (skips) FPU exceptions in the hardware.

I've not played much with FreeRTOS - no idea if that code piece made it into the Nordic examples for this OS.

You want to call this from an "idle" thread that gets called every time the CPU is supposed to start sleeping.

The trigger seems to be a bit random - its not unlikely that your bootloader somehow triggers conditions that would lead to an FPU exception...

RE: NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

Susheel Nuguru — Sat, 31 May 2025 10:14:37 GMT

Hi Joshua,

[quote user="jthmp"]Also, as a note: it looks like calling

ble_stack_init();

is enough to result in 450 uA of current. I don't even init advertising, or gap or anything else

[/quote]

You wrote the above earlier and also wrote below yesterday

[quote user="jthmp"]If I erase the bootloader and just run the application directly I get 100 uA.[/quote]

I am unable to connect these two together to same source of issue. The softdevice will not reenable any peripherals based on bootloader is present or not. So I am a bit unsure if softdevice_enable had any role to play in this. For a moment, let us keep this aside and focus only on bootloader.

To know which peripheral you have enabled in the bootloader, you might have to go and check the Enabled status register of each peripheral from the debugger.

Asking AI it gave a template code which might help to dump peripheral status runtime in your bootloader just before starting the application.

in sdk_config.h, use RTT

//------------------------------------------------------------------------------
// <e> NRF_LOG_ENABLED - Enables/disable logging.
//------------------------------------------------------------------------------
/// 1: Enabled; 0: Disabled
#define NRF_LOG_ENABLED 1

// <o> NRF_LOG_DEFAULT_LEVEL  - Default Severity level for logging.
//
// <0=> Off
// <1=> Error
// <2=> Warning
// <3=> Info
// <4=> Debug
#define NRF_LOG_DEFAULT_LEVEL 3

// <e> NRF_LOG_BACKEND_RTT_ENABLED - If enabled the RTT logging backend will be compiled.
//------------------------------------------------------------------------------
/// 1: Enabled; 0: Disabled
#define NRF_LOG_BACKEND_RTT_ENABLED 1
// </e>

// <e> NRF_LOG_BACKEND_SERIAL_USES_UART - If enabled the UART logging backend will be compiled.
//------------------------------------------------------------------------------
/// 1: Enabled; 0: Disabled
#define NRF_LOG_BACKEND_SERIAL_USES_UART 0
// </e>

// <e> NRF_LOG_BACKEND_UART_ENABLED - Enable UART logging backend.
//------------------------------------------------------------------------------
/// 1: Enabled; 0: Disabled
#define NRF_LOG_BACKEND_UART_ENABLED 0
// </e>

//------------------------------------------------------------------------------
// <e> NRF_LOG_USES_TIMESTAMP - Use timestamping on log messages.
//------------------------------------------------------------------------------
/// 1: Enabled; 0: Disabled
#define NRF_LOG_USES_TIMESTAMP 0
// </e>

In your bootloader have something like this to dump register status of every peripheral

#include <stdbool.h>
#include <stdint.h>
#include "nrf.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "nrf_drv_clock.h"
#include "app_error.h"

/** 
 * @brief  Scan the most common nRF52 peripherals and log any that remain enabled.
 *         Call this as early as possible in main(), before any peripheral initialization.
 */
static void dump_active_peripherals(void)
{
    NRF_LOG_INFO("=== Peripheral ENABLE STATUS ===");

    // UART0
    if (NRF_UART0->ENABLE != UART_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("UART0 is ENABLED (0x%08X)", NRF_UART0->ENABLE);
    }

#if defined(UARTE1)
    // UARTE1 (if your chip/board has it)
    if (NRF_UARTE1->ENABLE != UARTE_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("UARTE1 is ENABLED (0x%08X)", NRF_UARTE1->ENABLE);
    }
#endif

    // SPIM0 / SPIM1 / SPIM2 / SPIM3
    if (NRF_SPIM0->ENABLE != SPIM_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("SPIM0 is ENABLED (0x%08X)", NRF_SPIM0->ENABLE);
    }
    if (NRF_SPIM1->ENABLE != SPIM_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("SPIM1 is ENABLED (0x%08X)", NRF_SPIM1->ENABLE);
    }
    if (NRF_SPIM2->ENABLE != SPIM_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("SPIM2 is ENABLED (0x%08X)", NRF_SPIM2->ENABLE);
    }
#if defined(NRF_SPIM3)
    if (NRF_SPIM3->ENABLE != SPIM_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("SPIM3 is ENABLED (0x%08X)", NRF_SPIM3->ENABLE);
    }
#endif

    // TWI0 / TWI1
    if (NRF_TWI0->ENABLE != TWI_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("TWI0 is ENABLED (0x%08X)", NRF_TWI0->ENABLE);
    }
    if (NRF_TWI1->ENABLE != TWI_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("TWI1 is ENABLED (0x%08X)", NRF_TWI1->ENABLE);
    }

    // TIMER0 / TIMER1 / TIMER2 (check ENABLE bit)
    if (NRF_TIMER0->ENABLE != TIMER_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("TIMER0 is ENABLED (MODE=0x%02X)", NRF_TIMER0->MODE);
    }
    if (NRF_TIMER1->ENABLE != TIMER_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("TIMER1 is ENABLED (MODE=0x%02X)", NRF_TIMER1->MODE);
    }
    if (NRF_TIMER2->ENABLE != TIMER_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("TIMER2 is ENABLED (MODE=0x%02X)", NRF_TIMER2->MODE);
    }

    // PWM0 / PWM1
    if (NRF_PWM0->ENABLE != PWM_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("PWM0 is ENABLED (0x%08X)", NRF_PWM0->ENABLE);
    }
#if defined(NRF_PWM1)
    if (NRF_PWM1->ENABLE != PWM_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("PWM1 is ENABLED (0x%08X)", NRF_PWM1->ENABLE);
    }
#endif

    // SAADC
    if (NRF_SAADC->ENABLE != SAADC_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("SAADC is ENABLED (0x%08X)", NRF_SAADC->ENABLE);
    }

    // RNG: check if PSELCLK ≠ 0xFFFFFFFF (means RNG was started/configured)
    if (NRF_RNG->PSEL.PSELCLK != 0xFFFFFFFF) {
        NRF_LOG_INFO("RNG is CONFIGURED (PSELCLK=0x%08X)", NRF_RNG->PSEL.PSELCLK);
    }

    // RTC0 / RTC1 (check ENABLE bit)
    if (NRF_RTC0->ENABLE != RTC_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("RTC0 is ENABLED (PRESCALER=%u)", NRF_RTC0->PRESCALER);
    }
    if (NRF_RTC1->ENABLE != RTC_ENABLE_ENABLE_Disabled) {
        NRF_LOG_INFO("RTC1 is ENABLED (PRESCALER=%u)", NRF_RTC1->PRESCALER);
    }

    // CLOCK: HFCLK / LFCLK status
    if (NRF_CLOCK->HFCLKSTAT & CLOCK_HFCLKSTAT_STATE_Msk) {
        NRF_LOG_INFO("HFCLK is RUNNING (0x%08X)", NRF_CLOCK->HFCLKSTAT);
    }
    if (NRF_CLOCK->LFCLKSTAT & CLOCK_LFCLKSTAT_STATE_Msk) {
        NRF_LOG_INFO("LFCLK is RUNNING (0x%08X)", NRF_CLOCK->LFCLKSTAT);
    }

    NRF_LOG_INFO("==================================");
}


void exiting_bootloader()
{
    // 1) Initialize the logging (RTT backend in this example)
    ret_code_t err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);
    NRF_LOG_DEFAULT_BACKENDS_INIT();

    // 2) Temporarily start the low-frequency clock so that the CPU can sleep.
    //    (Otherwise HFCLKSTAT / LFCLKSTAT reads might be invalid.)
    nrf_drv_clock_init();
    nrf_drv_clock_lfclk_request(NULL);

    // 3) Dump active peripherals **before** you enable anything else.
    dump_active_peripherals();

    // 4) Enter an idle loop to push out logs and go to sleep between RTT interrupts
    while (true) {
        // Process any pending logs (RTT or UART). If none, sleep.
        if (!NRF_LOG_PROCESS()) {
            __WFE();
        }
    }
}

I have not tried this code myself but quick review shows that it is not that bad idea.

RE: NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

jthmp — Fri, 30 May 2025 21:10:04 GMT

Hi Susheel,

Yes, we need to find out what's going on in our bootloader.

RE: NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

Susheel Nuguru — Fri, 30 May 2025 20:58:45 GMT

That makes sense Joshua, so you can turnoff those peripherals that you turned on in bootloader before it jumps to the main application.

RE: NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

jthmp — Fri, 30 May 2025 20:55:23 GMT

Hi Susheel,

So I was able to get the current draw down below 100 uA with BLE Advertising.

It looks like our bootloader code is turning on some peripherals before loading the main application (BLE advertising task).

If I erase the bootloader and just run the application directly I get 100 uA.

RE: NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

Susheel Nuguru — Fri, 30 May 2025 20:54:53 GMT

If softdevice_enable itself is enough, then there are few possible reasons.

It is possible that the softdevice is trying to turn on in the LDO mode instead of using the DCDC buck converter. Can you do a small experiment to make sure you enable the DCDC mode and then enable the softdevice like below?

void power_management_init(void)
{
    ret_code_t err;

    err = nrf_drv_power_init(NULL);
    APP_ERROR_CHECK(err);

    nrf_drv_power_dcdc_enable(true);
}
...
...

// In main(), very early:
power_management_init();
ble_stack_init();

Make sure that

NRF_SDH_CLOCK_LF_SRC
CLOCK_CONFIG_LF_SRC

are set to XTAL and not RC.

Can't tink of anything else thatshould cause this. But try to run your firmware on the DK and see if you see the same results so that we can re-calibrate our debugging strategy.

RE: NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

jthmp — Fri, 30 May 2025 16:46:47 GMT

Hi Susheel,

So when I use the nrf 17.1 examples / ble_peripheral / ble_app_hrs / pca10056 / s140
I have to update the code to use the dcdc en and the low power clock. When I do this I get 60 uA on our custom board.

But I believe this is because in

on_adv_evt ->

BLE_ADV_EVT_IDLE

We call

sleep_mode_enter();

We will not want to do this for our application since it puts the nrf into OFF mode. If I comment out the sleep_mode_enter the current draw goes up to 450 uA.

Also, as a note: it looks like calling

ble_stack_init();

is enough to result in 450 uA of current. I don't even init advertising, or gap or anything else.

RE: NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

jthmp — Fri, 30 May 2025 16:12:38 GMT

Hi Susheel,

Thank you. I'll look into the suggestions you made.

We are using the BL654 BLE Module that has the nrf52840 MCU integrated.

I'm guessing that 450 uA while BLE is advertising at 1 sec intervals is too high?

If I disable the BLE the current draw drops down to 45 uA with a few tasks running and tickless idle mode (RTC1).

And I can provide a sample application from the 17.1 SDK that I also tested with - will post something next.

RE: NRF52840 running with BLE Advertising every 1 second consumes 450 uA even with tickless idle mode

Susheel Nuguru — Fri, 30 May 2025 08:38:23 GMT

Hi Joshua,

There were some issues on the earlier version of FreeRTOS but we fixed it since nRF5SDKv16, and a lot of products are out with low power on nRF52840 using tickless idle. If you can reproduce this on the nRF52840, then please attach a simplistic project for me to reproduce it. If you are using a custom hardware, then it most likely is an issue with your hardware or hardware configurations. In the latter case, I will try to look into the DCDC settings you have on your hardware to match with your firmware and also check if your clocks on your hardware match the clock configuration in your sdk_config.h file.