NRF52840 DONGLE NCS 2.7.0 LOW POWER MODE

RE: NRF52840 DONGLE NCS 2.7.0 LOW POWER MODE

Hieu — Tue, 26 Nov 2024 11:19:58 GMT

Hi krypton76,

[quote user="krypton76"]

The fact that i think it's deprectated is discussed here :
devzone.nordicsemi.com/.../can-t-enable-has_pm-to-support-power-management-notification

And in the NRF KCONFIG GUI i can't activate it : i can't check system power managment checkbox

And in the IDE i have the message : CONFIG_PM was assigned the value y, but got the value n. Missing dependencies:

(SOC_SERIES_EFR32BG22 && SOC_VENDOR_SILABS) || (SOC_SERIES_EFR32BG27 && SOC_VENDOR_SILABS) || (SOC_SERIES_EFR32MG24 && SOC_VENDOR_SILABS) || (SYS_CLOCK_EXISTS && HAS_PM)

[/quote]

Ah right. nRF52840 does not support the PM subsystem, evident by the lack of the HAS_PM Kconfig, which is what preventing you from setting CONFIG_PM. So, the PM subsystem isn't deprecated, but the nRF52 series doesn't support it.

Instead, you just have two sleep mode. System ON Idle is automatically entered when all threads go into idle, and System OFF is entered using sys_poweroff(), enabled with CONFIG_POWEROFF.

[quote user="krypton76"]Get GPIO state on/off on a pin by interrupt reading. I need to get the time spent between 2 high state interrupts, in order to calculate the frequency of the input signal.
It is from 2000hz to 5000hz, for what i count tics spent between 2 interrupts events on the 32khz clock[/quote]

I recommend using the Kernel Timing of the Zephyr RTOS for this. The system tick is based off a RTC running in 32kHz by default. The value you get from the k_uptime_* APIs are all from the RTC.

This has the benefit of not necessitate the running and control of a second RTC.

[quote user="krypton76"]Id do that for 100ms, i get at the end the average of frequencies, i send it by radio to third application then i go to deep sleep for 900ms and need a wake up by a timer.[/quote]

I am afraid the deepest sleep you can achieve with this requirement is System ON Idle. In System OFF mode, all timers are stopped, so you cannot wake up by time.

[quote user="krypton76"]For some reason if i plug in the dongle in an USB port the consomption raise up to 2mA.
SB2 is cut, CB1 soldiered. If i only put the device in USB port (without power it wit PKK) it can't put the device in bootloader mode.[/quote]

I honestly am not well versed in the USB hardware, so I am not sure what could be happening here. Let's revisit it if this remains a concern after our next steps.

[quote user="krypton76"]If i just put

void main(void) {

while (1) {

}

}

i get 2.91 mA

[/quote]

In this setup, the main thread stays active forever in the infinite loop.

You need to either let the main() function returns, or put it to sleep forever with k_sleep(K_FOREVER).

RE: NRF52840 DONGLE NCS 2.7.0 LOW POWER MODE

krypton76 — Mon, 25 Nov 2024 17:00:38 GMT

Hello and thanks for you reply.

The fact that i think it's deprectated is discussed here :
devzone.nordicsemi.com/.../can-t-enable-has_pm-to-support-power-management-notification

And in the NRF KCONFIG GUI i can't activate it : i can't check system power managment checkbox

And in the IDE i have the message : CONFIG_PM was assigned the value y, but got the value n. Missing dependencies:

(SOC_SERIES_EFR32BG22 && SOC_VENDOR_SILABS) || (SOC_SERIES_EFR32BG27 && SOC_VENDOR_SILABS) || (SOC_SERIES_EFR32MG24 && SOC_VENDOR_SILABS) || (SYS_CLOCK_EXISTS && HAS_PM)

My full functionnal goal is :

Get GPIO state on/off on a pin by interrupt reading. I need to get the time spent between 2 high state interrupts, in order to calculate the frequency of the input signal.
It is from 2000hz to 5000hz, for what i count tics spent between 2 interrupts events on the 32khz clock
Id do that for 100ms, i get at the end the average of frequencies, i send it by radio to third application then i go to deep sleep for 900ms and need a wake up by a timer.

// Include necessary Zephyr and Nordic headers
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <esb.h>
#include <stdio.h>

LOG_MODULE_REGISTER(esb_ptx, CONFIG_ESB_PTX_APP_LOG_LEVEL);

#define INTERRUPT_PIN 15               // GPIO pin for the interrupt
#define MAX_INTERRUPTS 500             // Max number of interrupts to capture

// Define GPIO configuration for the interrupt pin
static const struct gpio_dt_spec interrupt_pin = {
    .port = DEVICE_DT_GET(DT_NODELABEL(gpio0)),
    .pin = INTERRUPT_PIN,
    .dt_flags = GPIO_INPUT | GPIO_INT_EDGE_RISING,
};

// GPIO callback structure
static struct gpio_callback interrupt_cb_data;

// Variables to store interrupt data
volatile int interrupt_count = 0;
volatile uint32_t timestamps[MAX_INTERRUPTS];  // Array to store interrupt timestamps

// ESB payload for data transmission
static struct esb_payload tx_payload = ESB_CREATE_PAYLOAD(0);

// Function prototypes
static void interrupt_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins);
static int esb_initialize(void);
static void calculate_and_transmit(void);

// Interrupt handler
static void interrupt_handler(const struct device *dev, struct gpio_callback *cb, uint32_t pins) {
    if (interrupt_count < MAX_INTERRUPTS) {
        timestamps[interrupt_count++] = k_cycle_get_32();  // Capture the timestamp
    }
}

// Initialize Enhanced ShockBurst (ESB)
static int esb_initialize(void) {
    int err;
    uint8_t base_addr_0[4] = {0xE7, 0xE7, 0xE7, 0xE7};
    uint8_t base_addr_1[4] = {0xC2, 0xC2, 0xC2, 0xC2};
    uint8_t addr_prefix[8] = {0xE7, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8};

    struct esb_config config = ESB_DEFAULT_CONFIG;
    config.protocol = ESB_PROTOCOL_ESB_DPL;
    config.bitrate = ESB_BITRATE_1MBPS;
    config.mode = ESB_MODE_PTX;
    config.tx_output_power = ESB_TX_POWER_0DBM;

    err = esb_init(&config);
    if (err) {
        return err;
    }

    err = esb_set_base_address_0(base_addr_0);
    if (err) {
        return err;
    }

    err = esb_set_base_address_1(base_addr_1);
    if (err) {
        return err;
    }

    err = esb_set_prefixes(addr_prefix, ARRAY_SIZE(addr_prefix));
    return err;
}

// Calculate the average frequency and send via ESB
static void calculate_and_transmit(void) {
    if (interrupt_count < 2) {
        LOG_INF("Not enough interrupts to calculate frequency.");
        return;
    }

    uint32_t total_ticks = 0;
    for (int i = 1; i < interrupt_count; i++) {
        total_ticks += (timestamps[i] - timestamps[i - 1]);
    }

    uint32_t average_ticks = total_ticks / (interrupt_count - 1);

    // Format the payload as "XX_YYY"
    char payload[8];
    snprintf(payload, sizeof(payload), "%02d_%03d", average_ticks, interrupt_count);

    // Copy the formatted string into the ESB payload
    strncpy((char *)tx_payload.data, payload, sizeof(tx_payload.data));
    tx_payload.length = strlen(payload);

    // Send the payload
    if (esb_write_payload(&tx_payload)) {
        LOG_ERR("Failed to send payload.");
    } else {
        LOG_INF("Data sent: %s", payload);
    }
}

void main(void) {
    int err;

    // Configure the interrupt pin
    gpio_pin_configure(interrupt_pin.port, interrupt_pin.pin, GPIO_INPUT);
    gpio_pin_interrupt_configure(interrupt_pin.port, interrupt_pin.pin, GPIO_INT_EDGE_RISING);

    gpio_init_callback(&interrupt_cb_data, interrupt_handler, BIT(interrupt_pin.pin));
    gpio_add_callback(interrupt_pin.port, &interrupt_cb_data);

    // Initialize ESB
    err = esb_initialize();
    if (err) {
        LOG_ERR("Failed to initialize ESB, error: %d", err);
        return;
    }

    LOG_INF("System initialized. Waiting for interrupts...");

    while (1) {
        interrupt_count = 0;

        // Monitor interrupts for 100 ms
        k_sleep(K_MSEC(100));

        // Calculate and send the result
        calculate_and_transmit();

        // Wait before the next sampling
        k_sleep(K_MSEC(900));
    }
}

prj.conf

CONFIG_NCS_SAMPLES_DEFAULTS=y
CONFIG_ESB=y
CONFIG_DK_LIBRARY=y

# Power management
CONFIG_PM_DEVICE=y
CONFIG_PM_DEVICE_RUNTIME=y

i get an average power consumption of 520uA

For some reason if i plug in the dongle in an USB port the consomption raise up to 2mA.
SB2 is cut, CB1 soldiered. If i only put the device in USB port (without power it wit PKK) it can't put the device in bootloader mode.

If i just put

void main(void) {

while (1) {

}

}

i get 2.91 mA

RE: NRF52840 DONGLE NCS 2.7.0 LOW POWER MODE

Hieu — Mon, 25 Nov 2024 13:24:04 GMT

Hi krypton76,

I recommend first comment out all of your code and just let main() returns, and measure the current there, see how much current you have. If you have above 10uA, that's indicative that you have other subsystems running that is consuming power.

Secondly, I am a little confused if you want to actively polling GPIO every second, or if you want to passively get GPIO interrupt. If you use GPIO interrupt, you are using GPIOTE, and with that comes a little more current consumption. It should only be under 1uA increase, however. See GPIOTE — GPIO tasks and events.

Thirdly, do you need tight timing? If you don't, I recommend using the Zephyr RTOS system timing instead of running a separate peripheral. While you are using RTC, and don't introduce a new active clock source, it is still more current consumed there.

CONFIG_PM isn't deprecated. I am not certain about pm_state_* functions, but I haven't exactly followed it. Could you share the source that gives you that impression so I can look further into it?
Otherwise, for your requirement, I don't think you need to touch PM or PM device to achieve sub 10uA. As long as all your thread goes into sleep, you should achieve System ON Idle, which should get you within the target.

Hieu

RE: NRF52840 DONGLE NCS 2.7.0 LOW POWER MODE

krypton76 — Fri, 22 Nov 2024 17:50:16 GMT

As i understood, CONFIG_PM is deprecated and pm_state_* functions too.

So i start a new simple project :

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <hal/nrf_rtc.h>
#include <zephyr/pm/device.h>
#include <zephyr/logging/log.h>

LOG_MODULE_REGISTER(main, LOG_LEVEL_INF);

// Configuration RTC
#define RTC NRF_RTC1
#define RTC_FREQUENCY 32768    // Fréquence de l'horloge RTC (32.768 kHz)
#define TIMEOUT_MS 900         // Temps d'attente en millisecondes
#define TIMEOUT_TICKS (TIMEOUT_MS * RTC_FREQUENCY / 1000)

volatile bool rtc_timeout = false;

// Liste des périphériques à désactiver
const char *devices_to_disable[] = {
    "UART_0",
    "UART_1",
    "SPI_0",
    "SPI_1",
    "I2C_0",
    "I2C_1",
    "PWM_0",
    "PWM_1",
    "ADC_0",
};

// Gestionnaire d'interruption RTC
void rtc_handler(void)
{
    if (nrf_rtc_event_check(RTC, NRF_RTC_EVENT_COMPARE_0)) {
        nrf_rtc_event_clear(RTC, NRF_RTC_EVENT_COMPARE_0);
        rtc_timeout = true;
        LOG_INF("RTC timeout reached");
    }
}

void RTC1_IRQHandler(void)
{
    rtc_handler();
}

// Configurer le RTC pour générer une interruption après TIMEOUT_MS
static void configure_rtc(void)
{
    nrf_rtc_prescaler_set(RTC, 0);  // Pas de division, fréquence à 32.768 kHz
    nrf_rtc_cc_set(RTC, 0, TIMEOUT_TICKS);
    nrf_rtc_event_enable(RTC, NRF_RTC_INT_COMPARE0_MASK);
    nrf_rtc_int_enable(RTC, NRF_RTC_INT_COMPARE0_MASK);
    nrf_rtc_task_trigger(RTC, NRF_RTC_TASK_CLEAR);
    nrf_rtc_task_trigger(RTC, NRF_RTC_TASK_START);

    NVIC_ClearPendingIRQ(RTC1_IRQn);
    NVIC_SetPriority(RTC1_IRQn, 1);
    NVIC_EnableIRQ(RTC1_IRQn);

    LOG_INF("RTC configured for timeout of %d ms", TIMEOUT_MS);
}

// Désactiver les périphériques inutiles pour réduire la consommation
static void disable_unused_devices(void)
{
    for (int i = 0; i < ARRAY_SIZE(devices_to_disable); i++) {
        const struct device *dev = device_get_binding(devices_to_disable[i]);
        if (!dev) {
            LOG_WRN("Device %s not found", devices_to_disable[i]);
            continue;
        }

        if (pm_device_action_run(dev, PM_DEVICE_ACTION_SUSPEND) == 0) {
            LOG_INF("Device %s suspended", devices_to_disable[i]);
        } else {
            LOG_WRN("Failed to suspend device %s", devices_to_disable[i]);
        }
    }
}

void main(void)
{
    LOG_INF("Starting low-power mode with RTC wakeup");

    // Configurer le RTC
    configure_rtc();

    // Désactiver les périphériques inutilisés
    disable_unused_devices();

    while (1) {
        rtc_timeout = false;

        LOG_INF("Entering low-power mode for 900 ms...");
        k_sleep(K_MSEC(900));  // Le système entre en System ON Idle ici

        // Attendre que le RTC atteigne son timeout
        while (!rtc_timeout) {
            k_sleep(K_MSEC(1));
        }

        LOG_INF("Woke up from low-power mode");
    }
}

# Enable GPIO and RTC
CONFIG_GPIO=y

# Enable power management
CONFIG_PM_DEVICE=y

# Optimize stack sizes
CONFIG_MAIN_STACK_SIZE=1024
CONFIG_IDLE_STACK_SIZE=256

# Disable unnecessary logging to save power
CONFIG_PRINTK=n
CONFIG_CONSOLE=n
CONFIG_SERIAL=n
CONFIG_LOG=y

And i works a bit, but i get a constant average consumption of 214uA, which is far more than expected, regarding what it does.