In this exercise, you will learn about the impact of various SoC peripherals on the device’s power consumption.

You will measure the impact of enabling the serial console, watchdog, timers from different power domains, and PWM outputs, both standard and low-power GRTC-based, on the average and sleep current.

By comparing these configurations, you will learn how the peripheral selection from different power domains influences the power consumption, which is crucial for designing low-power embedded devices. The exercise demonstrates how careful peripheral selection can significantly reduce current consumption, especially in battery-powered applications.

A handful of steps in this exercise are marked as optional as they require additional hardware:

• Logic analyzer or oscilloscope

Exercise steps

In the GitHub repository for this course, go to the base code for this exercise, found in l5/l5_e2.

This base code is just a modified version of the peripheral_lbs sample.

The base code includes all the options that enable the components you will test in the exercise. They are defined in Kconfig and disabled by default. We will enable them one by one, while walking you through the observations we make.

source "Kconfig.zephyr"
menu "Lesson 4 Exercise 2 config"
config PWM_DUTY_CYCLE
	depends on  PWM || NRFX_PWM_GRTC
	int "PWM duty cycle in %"
	default 25
config NRFX_PWM_GRTC
	bool "Use GRTC for PWM"
	default n
config NRFX_TIMER00_1MHz
	bool "Use TIMER00 at 1MHz"
	default n
	select NRFX_TIMER
config NRFX_TIMER00_128MHz
	bool "Use TIMER00 at 128MHz"
	default n
	select NRFX_TIMER
config NRFX_TIMER20_1MHz
	bool "Use TIMER20 at 1MHz"
	default n
	select NRFX_TIMER
endmenu

source "Kconfig.zephyr"
menu "Lesson 4 Exercise 2 config"
config PWM_DUTY_CYCLE
	depends on  PWM || NRFX_PWM_GRTC
	int "PWM duty cycle in %"
	default 25
config NRFX_PWM_GRTC
	bool "Use GRTC for PWM"
	default n
config NRFX_TIMER00_1MHz
	bool "Use TIMER00 at 1MHz"
	default n
	select NRFX_TIMER
config NRFX_TIMER00_128MHz
	bool "Use TIMER00 at 128MHz"
	default n
	select NRFX_TIMER
config NRFX_TIMER20_1MHz
	bool "Use TIMER20 at 1MHz"
	default n
	select NRFX_TIMER
endmenu

The helper functions for this exercise can be found in the src directory.

They are all used in the main() function in main.c depending on the configuration:

... 
#if defined(CONFIG_WATCHDOG)
    if( init_watchdog() <0) {
        printk("Failed to initialize watchdog \\n");
        return 0;
    }
#endif
#if defined(CONFIG_NRFX_TIMER00_1MHz)
    enable_timer00(TIMER_1MHZ);
#endif
#if defined(CONFIG_NRFX_TIMER00_128MHz)
    enable_timer00(TIMER_128MHZ);
#endif
#if defined(CONFIG_NRFX_TIMER20_1MHz)
    enable_timer20(TIMER_1MHZ);
#endif
#if defined(CONFIG_NRFX_PWM_GRTC)   
    set_grtc_pwm(CONFIG_PWM_DUTY_CYCLE);   
#endif    
#if defined(CONFIG_PWM) 
if ( set_pwm_out(CONFIG_PWM_DUTY_CYCLE ) < 0) {
    printk("Failed to set PWM output \\n");
    return 0;
}
#endif
while (1) 
{
    #if defined(CONFIG_WATCHDOG)
       watchdog_feed();
    #endif
        k_sleep(K_MSEC(1000));
}
...

... 
#if defined(CONFIG_WATCHDOG)
    if( init_watchdog() <0) {
        printk("Failed to initialize watchdog \\n");
        return 0;
    }
#endif
#if defined(CONFIG_NRFX_TIMER00_1MHz)
    enable_timer00(TIMER_1MHZ);
#endif
#if defined(CONFIG_NRFX_TIMER00_128MHz)
    enable_timer00(TIMER_128MHZ);
#endif
#if defined(CONFIG_NRFX_TIMER20_1MHz)
    enable_timer20(TIMER_1MHZ);
#endif
#if defined(CONFIG_NRFX_PWM_GRTC)   
    set_grtc_pwm(CONFIG_PWM_DUTY_CYCLE);   
#endif    
#if defined(CONFIG_PWM) 
if ( set_pwm_out(CONFIG_PWM_DUTY_CYCLE ) < 0) {
    printk("Failed to set PWM output \\n");
    return 0;
}
#endif
while (1) 
{
    #if defined(CONFIG_WATCHDOG)
       watchdog_feed();
    #endif
        k_sleep(K_MSEC(1000));
}
...

1. Build and flash the base code to your DK and observe the power consumption.

Run the Power Profiler application and ensure the DK is powered over the PPK2, as we have done in previous exercises.

Observe the base current consumption of the application (left), at around 8-9 μA, and the System ON IDLE current (right), at around 2 μA.

2. Enable a watchdog and observe the power consumption.

In this part of the exercise, you will enable a watchdog for your application. The watchdog peripheral is located in the low-power domain, so it should not increase the average power consumption drastically.

We can take a look at the nRF54L15 datasheet to observe how much current it consumes.

2.1 Enable the watchdog peripheral in the project.

Enable the watchdog peripheral by adding the following line in the prj.conf file. Make sure that the rest of the options are disabled

CONFIG_WATCHDOG=y

CONFIG_WATCHDOG=y

This will include the src/wdg_conf.c file with all the necessary settings in the application.

2.2 Build (pristine build) and flash the application to your DK, and observe the current consumption.

As the watchdog is placed in the low-power domain that is already active (by default), notice that the current consumption increases slightly.

3. Enable serial connection and observe the power consumption.

The base code for this exercise has the serial connection disabled by default, which gave approximately 8.73 µA average current consumption, as we saw in step 1. Let’s see how enabling the serial console affects this, by enabling UARTE20 which is located in the peripheral power domain.

3.1 Enable only the serial console driver in the project.

Make sure that the rest of the options are disabled, specifically CONFIG_WATCHDOG that we enabled in a previous step. Enable the serial console driver by replacing CONFIG_SERIAL=n it with the following line in the prj.conf file

CONFIG_SERIAL=y

CONFIG_SERIAL=y

3.2 Build (pristine build) and flash the application to your DK, and observe the current consumption.

Let’s examine the average and sleep current consumption. Enabling the serial connection consumes ~150 µA in IDLE mode and ~156 µA on average. That is the result of enabling the peripheral power domain.

Timers

Now we will use timers from different power domains to see how the selection of the domain affects the average current consumption.

In the nRF54L Series SoCs, there are a few options for the timer selection, depending on performance needs and the integration with existing components (using peripherals from the same power domain when possible).

You can align the timer peripheral placement with the current consumption reported in the SoC datasheet. The most capable TIMER00 consumes much more power than the timers placed in the peripheral power domain. It is the case not only when using its maximum frequency, which other timers cannot achieve, but also when both are run at the same frequency. Try it in practice using timers from both power domains. The nRF54L Series SoC is also equipped with TIMER10 allocated for the Bluetooth LE stack.

4. Enable the peripheral power domain timer at 1 MHz.

In this section, let’s activate TIMER20 from the peripheral power domain and set 1 MHz as the base frequency.

4.1 Enable peripheral domain TIMER20 at 1 MHz.

We will do this by enabling the prepared Kconfig symbol (defined in the Kconfig file of the application) in the prj.conffile.

CONFIG_NRFX_TIMER20_1MHz=y

CONFIG_NRFX_TIMER20_1MHz=y

4.2 Leave the serial connection active (from the previous step).

CONFIG_SERIAL=y

CONFIG_SERIAL=y

4.3 Build (pristine build) and flash the application to your DK, and observe the current consumption.

Notice that using both peripherals from the same power domain results in a limited increase in current consumption, compared to step 3.2.

4.4 Disable the serial console driver.

Now let’s disable the serial port to test the timer’s current consumption.

CONFIG_SERIAL=n

CONFIG_SERIAL=n

4.5 Build (pristine build) and flash the application to your DK, and observe the current consumption.

Observe TIMER20 current consumption, which is close to the value presented in the table from the datasheet.

5. Enable the MCU power domain timer at 1 MHz.

In this section, let’s activate TIMER00 from the MCU power domain and use the same frequency for this timer: 1 MHz.

5.1 Enable MCU domain TIMER00 at 1 MHz.

We will do this by enabling the prepared Kconfig symbol (defined in the Kconfig file of the application) in the prj.conf file. Make sure that the rest of the options are disabled, specifically CONFIG_NRFX_TIMER20_1MHz which we enabled in a previous step.

Enable the following Kconfig option in the prj.conf file:

CONFIG_NRFX_TIMER00_1MHz=y

CONFIG_NRFX_TIMER00_1MHz=y

5.2 Build (pristine build) and flash the application to your DK, and observe the current consumption.

Using the timer from the MCU power domain increased the current consumption drastically compared to the timer in the peripheral power domain.

6. Enable the MCU power domain timer at 128 MHz.

Let’s increase the base frequency to use the maximum capability available only in TIMER00: 128 MHz.

6.1 Enable MCU domain TIMER00 at 128 MHz.

We will do this by enabling the prepared Kconfig symbol (defined in the Kconfig file of the application) in the prj.conf file. Make sure that the rest of the options are disabled, specifically CONFIG_NRFX_TIMER00_1MHz which we enabled in a previous step. Enable the following Kconfig option in the prj.conf file:

CONFIG_NRFX_TIMER00_128MHz=y

CONFIG_NRFX_TIMER00_128MHz=y

6.2 Build (pristine build) and flash the application to your DK, and observe the current consumption.

Observe that increasing the timer’s frequency has almost no impact on the current consumption. The power domain selection affected the power consumption much more than the increased frequency.

PWM

In this section, we compare the current consumption of the standard peripheral PWM with the low-power GRTC PWM. It is important to note that the GRTC PWM output is significantly less capable than the standard PWM, offering only limited configuration options and supporting a fixed period, which restricts its use to specific use cases.

We will first enable the standard PWM and observe the current consumption. Then we will replace it with the low-power PWM feature of the GRTC, and compare.

The GRTC WM operates at a fixed frequency of 128 Hz (period ~ 7.812 ms). To ensure a fair comparison, the standard peripheral PWM will also be configured to use the same frequency.

7. Enable the standard PWM peripheral.

7.1 Enable the standard PWM peripheral by adding the following line in the prj.conf file. Make sure that the rest of the options are disabled.

CONFIG_PWM=y

CONFIG_PWM=y

The PWM hardware configuration is found in the device overlay file in the boards directory.

We will use the default duty cycle already configured in the file:

config PWM_DUTY_CYCLE
	depends on  PWM || NRFX_PWM_GRTC
	int "PWM duty cycle in %"
	default 25

config PWM_DUTY_CYCLE
	depends on  PWM || NRFX_PWM_GRTC
	int "PWM duty cycle in %"
	default 25

7.2 Build (pristine build) and flash the application to your DK, and observe the current consumption. The PWM21 consumes ~155 µA, providing a 128 Hz/25% duty cycle signal.

7.3 (Optional) Use the scope to verify the signal. The PWM peripheral has direct access only to Port 1, so we will use P1.11. Connect a scope probe to P1.11 on the nRF54L15 DK.

8. Enable the GRTC PWM peripheral.

Now let’s use the GRTC for the same purpose and see how much current we can reduce.

The GRTC PWM has a fixed period of 256 LFCLK clock cycles, resulting in a 128 Hz frequency. The output is also available on the dedicated pin. For an SoC mounted on the nRF54L15 DK, it is P0.03.

Note: The GRTC PWM can operate in System OFF mode, which is not possible for other peripheral PWMs.

8.1 Disconnect the PWM output pin from the debugger.

On an nRF54L15 DK, the P0.03 works also as UART CTS. So we need to disconnect it from the debugger to prevent current leakage.

Use the board configurator for disabling the debugger serial console.

8.2 Enable the GRTC PWM output in the project.

Make sure that the rest of the options are disabled, specifically CONFIG_PWM which we enabled in a previous step. Enable the GRTC PWM output by adding the following line in the prj.conf file.

CONFIG_NRFX_PWM_GRTC=y

CONFIG_NRFX_PWM_GRTC=y

8.3 Build (pristine build) and flash the application to your DK, and observe the current consumption.

From the current consumption we can see that we have provided a PWM signal without a remarkable impact on the base current consumption from the initial current consumption of 8.73 µA in the base code of this exercise.

As for the comparison between GRTC PWM and standard PWM, the consumption for GRTC PWM is around 12 µA, which makes it a better option than 155 µA using the standard PWM. This however requires that the 128 Hz frequency of the signal is enough to meet your product requirement.

8.4 (Optional) Use the scope to verify the signal.

Connect a probe to the GRTC PWM Pin (pin location depends on the selected board).