Faster nrf53 PWM frequency update through Zephyr?

RE: Faster nrf53 PWM frequency update through Zephyr?

JonasForssell — Sat, 14 Aug 2021 13:03:55 GMT

I am going to close this ticket now since the original question was answered. The issue with being able to change frequency remains and I will open a new ticket around this.

Many thanks to Jörg and Torbjörn for your kind help!

/Jonas

RE: Faster nrf53 PWM frequency update through Zephyr?

JonasForssell — Fri, 13 Aug 2021 12:54:22 GMT

Encouraged by my earlier success, I tried to make the driver run in wave_form mode in order to have the possibility of updating the top_value dynamically and thereby changing the frequency.

Starting off with a simple single setup, I do not however get the expected output.

The fourth value (supposed to be countertop) is ignored for some reson and the default value seems to be around 1000 which results in a 1kHz signal. With a 50 on the duty cycle position I get expected 5% duty. I have confirmed that I can change the duty cycle as expected but the countertop value is ignored.

Any idea what I have got wrong?

/**
 * Simple program to drive LED0 on the nrf5340 evaluation board using the nrfx driver for lower level access
 * Jonas Forssell
 */

#include <stdio.h>
#include <string.h>
#include <nrfx_pwm.h>
#include <zephyr.h>

// Use Zephyr macro to get access to the LED0 on the board
#define OUTPUT_PIN DT_GPIO_PIN(DT_ALIAS(led0), gpios)

// Use nrfx to create a PWM instance which we will connect to the LED0 later
static nrfx_pwm_t m_pwm0 = NRFX_PWM_INSTANCE(0);

// Declare variables holding PWM sequence values. In this example only one channel is used 
// We start off with a counter to 50 and a top value of 100 giving a 50% duty cyle.
nrf_pwm_values_wave_form_t seq_values[] = {50, 0, 0, 100};

nrf_pwm_sequence_t const seq =
{
    .values.p_wave_form = seq_values,
    .length          = NRF_PWM_VALUES_LENGTH(seq_values),
    .repeats         = 0,
    .end_delay       = 0
};


nrfx_pwm_config_t const config0 =
    {
        .output_pins =
        {
            OUTPUT_PIN,                        // channel 0 now connected to LED0
            NRFX_PWM_PIN_NOT_USED,             // channel 1
            NRFX_PWM_PIN_NOT_USED,             // channel 2
            NRFX_PWM_PIN_NOT_USED,             // channel 3
        },
        .irq_priority = NRFX_PWM_DEFAULT_CONFIG_IRQ_PRIORITY,
        .base_clock   = NRF_PWM_CLK_1MHz,       // Here we select which prescaler to use
        .count_mode   = NRF_PWM_MODE_UP,
        .top_value    = 100,                    // This is ignored when in wave form mode
        .load_mode    = NRF_PWM_LOAD_WAVE_FORM,
        .step_mode    = NRF_PWM_STEP_AUTO
    };

int main(void) {

// Init PWM without error handler
nrfx_pwm_init(&m_pwm0, &config0, NULL, NULL);

// Set and start
nrfx_pwm_simple_playback(&m_pwm0, &seq, 1, NRFX_PWM_FLAG_LOOP);

while(1) 
    k_msleep(3000);

}

RE: Faster nrf53 PWM frequency update through Zephyr?

ovrebekk — Fri, 13 Aug 2021 08:12:36 GMT

Hi Jonas

Good to hear you got it working 🙂

Older examples written for the nRF5 SDK will require some porting, since the older nrf_drv drivers are all replaced by nrfx drivers in Zephyr.

Best regards
Torbjørn

RE: Faster nrf53 PWM frequency update through Zephyr?

JonasForssell — Thu, 12 Aug 2021 13:34:08 GMT

Based on your feedback Torbjörn and Jörg, I have messed about for a while trying to create a working PWM example where I use the nrfx_pwm drivers instead.

I was quite amazed to get this to work. I based it on a simple-pwm example I found for the nrf_pwm driver but needed to tweak it a bit. Mostly by replacing nrf references with corresponding nrfx equivalents.

I needed to use Zephyr to get a reference to the LED0 from the devicetree but then it compiled and worked.

Thanks for your help gentlemen!

/Jonas

/**
 * Simple program to drive LED0 on the nrf5340 evaluation board using the nrfx driver for lower level access
 * Jonas Forssell
 */

#include <stdio.h>
#include <string.h>
#include <nrfx_pwm.h>
#include <zephyr.h>


// Use Zephyr macro to get access to the LED0 on the board
#define OUTPUT_PIN DT_GPIO_PIN(DT_ALIAS(led0), gpios)

// Use nrfx to create a PWM instance which we will connect to the LED0 later
static nrfx_pwm_t m_pwm0 = NRFX_PWM_INSTANCE(0);

// Declare variables holding PWM sequence values. In this example only one channel is used 
nrf_pwm_values_individual_t seq_values[] = {0, 0, 0, 0};
nrf_pwm_sequence_t const seq =
{
    .values.p_individual = seq_values,
    .length          = NRF_PWM_VALUES_LENGTH(seq_values),
    .repeats         = 0,
    .end_delay       = 0
};


// Set duty cycle between 0 and 100%
void pwm_update_duty_cycle(uint8_t duty_cycle)
{
    
    // Check if value is outside of range. If so, set to 100%
    if(duty_cycle >= 100)
    {
        seq_values->channel_0 = 100;
    }
    else
    {
        seq_values->channel_0 = duty_cycle;
    }
    
    nrfx_pwm_simple_playback(&m_pwm0, &seq, 1, NRFX_PWM_FLAG_LOOP);
}

static void pwm_init(void)
{
    nrfx_pwm_config_t const config0 =
    {
        .output_pins =
        {
            OUTPUT_PIN,                        // channel 0 now connected to LED0
            NRFX_PWM_PIN_NOT_USED,             // channel 1
            NRFX_PWM_PIN_NOT_USED,             // channel 2
            NRFX_PWM_PIN_NOT_USED,             // channel 3
        },
        .irq_priority = NRFX_PWM_DEFAULT_CONFIG_IRQ_PRIORITY,
        .base_clock   = NRF_PWM_CLK_1MHz,
        .count_mode   = NRF_PWM_MODE_UP,
        .top_value    = 100,
        .load_mode    = NRF_PWM_LOAD_INDIVIDUAL,
        .step_mode    = NRF_PWM_STEP_AUTO
    };
    // Init PWM without error handler
    nrfx_pwm_init(&m_pwm0, &config0, NULL, NULL);
    
}


int main(void)
{

    // Start clock for accurate frequencies
    NRF_CLOCK->TASKS_HFCLKSTART = 1; 
    // Wait for clock to start
    while(NRF_CLOCK->EVENTS_HFCLKSTARTED == 0) 
        ;
    
    pwm_init();

    for (;;)
    {
        for(int i = 0; i <= 100; i++)
        {
            k_msleep(10);
            pwm_update_duty_cycle(i);
        }
    }
}


/** @} */

RE: Faster nrf53 PWM frequency update through Zephyr?

ovrebekk — Thu, 12 Aug 2021 09:02:13 GMT

Hi Jonas

I wouldn't recommend programming the hardware directly, but it is possible to bypass the Zephyr PWM driver and use the nrfx_pwm driver instead. Then you are much closer to the hardware, but you don't need to spend a lot of time understanding how the hardware works.

As Jörg is hinting at it is possible to write directly to the RAM buffer assigned to the PWM, rather than starting the PWM explicitly each time you want to change it.

When using the nrfx_pwm driver you have to provide the buffer to the driver, which means you have access to it in the application and can update it without involving the driver.

The idea of connecting the ADC to the same buffer is interesting, but this is not something we have tested. Also, the drawback of this method is that you are not able to do any scaling, inversion or anything else that you might want to do to the data before you output it on the PWM.

Best regards
Torbjørn

RE: Faster nrf53 PWM frequency update through Zephyr?

Turbo J — Thu, 12 Aug 2021 09:01:18 GMT

What I meant by "programming the hardware directly" was reading the PS document where all those SAADC and PWM registers are documented, and then translating that information directly into C code.

And yes, that ignores Zephyr and nrfx (almost) completely - both won't allow you enough control over the hardware IMHO.

Otherwise I don't see how to implement you application.

This is actually quite a common theme in µC programming whenever you code something interesting that the original developers (of the APIs and Zephyr) did not anticipate before.

RE: Faster nrf53 PWM frequency update through Zephyr?

JonasForssell — Thu, 12 Aug 2021 08:31:31 GMT

I've been studying a bit more to try to comprehend the limitations. Here are my conclusions. They might be wrong:

1. I have not yet found any info on how Zephyr actually implements PWM but the frequency update limitation mensioned above is still valid.

2. nrf53 development are based around Zephyr and the possibility of using the nrf5 SDK is not available.

3. However, nrfx API can be activated (still have to learn how) and seems to support nrf53. In this case, I suspect some Zephyr bits should be deactivated to avoid conflict.

4. To get high performance PWM (>200 kHz), I need to activate and use the PWM peripheral in the nrf53 (using nrfx commands)

Examples and documentation I have found so far:
https://docs.zephyrproject.org/latest/samples/boards/nrf/nrfx/README.html

https://devzone.nordicsemi.com/f/nordic-q-a/69264/outputting-a-pwm-signal-and-it-s-inverse-thru-gpio-pins

So far, I have not found an example where the nrfx PWM is implemented and Zephyr is deactivated.

I would greatly appreciate any help and guidance on this topic.

/Jonas

RE: Faster nrf53 PWM frequency update through Zephyr?

JonasForssell — Wed, 11 Aug 2021 07:43:21 GMT

Thanks for quick feedback Turbo J!!

I've tried experimenting with different pulse values down to ns and although it idoes affect the PWM signal, it does not change the update timing unfortunately.

Your tip regarding the PWM and SAADC seems really interesting. Any tips on where I can read further on this? Perhaps examples?

Thanks

/Jonas

RE: Faster nrf53 PWM frequency update through Zephyr?

Turbo J — Wed, 11 Aug 2021 07:08:13 GMT

Your PWM period time of 100000 is in the ms range, and you cannot set a new value during that period. See PS for details.

What you could do - IMHO not in zephyr, but by programming the hardware directly - is using the same buffer for the SAADC result and the PWM input. This way the PWM can pick up a newly sampled ADC value for each period.