nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

inghowe83 — Fri, 22 Feb 2019 08:16:22 GMT

Hi Guys,

Any founding on this topics? How the .base_clock = NRF_PWM_CLK_2MHz influence the .top_value = 32768, // = 0x8000?

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

awneil — Mon, 24 Sep 2018 11:35:53 GMT

The Assert is actually in nrf_pwm_configure():

__STATIC_INLINE void nrf_pwm_configure(NRF_PWM_Type * p_reg,
                                       nrf_pwm_clk_t  base_clock,
                                       nrf_pwm_mode_t mode,
                                       uint16_t       top_value)
{
    NRFX_ASSERT(top_value <= PWM_COUNTERTOP_COUNTERTOP_Msk);

    p_reg->PRESCALER  = base_clock;
    p_reg->MODE       = mode;
    p_reg->COUNTERTOP = top_value;
}

and PWM_COUNTERTOP_COUNTERTOP_Msk is defined in nrf52810_bitfields.h:

/* Bits 14..0 : Value up to which the pulse generator counter counts. This register is ignored when DECODER.MODE=WaveForm and only values from RAM are used. */
#define PWM_COUNTERTOP_COUNTERTOP_Pos (0UL) /*!< Position of COUNTERTOP field. */
#define PWM_COUNTERTOP_COUNTERTOP_Msk (0x7FFFUL << PWM_COUNTERTOP_COUNTERTOP_Pos) /*!< Bit mask of COUNTERTOP field. */

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

Edvin — Mon, 24 Sep 2018 10:27:25 GMT

Ok. It worked in my tests, but maybe we tried on different chips.

You can use 7FFF then.

I can agree that the PWM drivers are a bit confusing, which is why I suggested the PPI implementation, which only uses a timer and the GPIOTE driver to toggle the pins.

The example actually uses both the GPIO driver and the PWM driver to control the LEDs/pins. The NRF_DRV_PWM_PIN_INVERTED is actually not used when the PWM is running. That is, when you call nrf_drv_pwm_simple_playback(). It is used when the PWM is stopped (which it doesn't do in this example, so it is a bit misleading.

If you want to stop the PWM (by not using the loop-flag, but the NRF_DRV_PWM_FLAG_STOP, then the NRF_DRV_PWM_PIN_INVERTED will cause the pin to go high after the sequence. And pin high means LED off. If you remove PIN_INVERTED and use NRF_DRV_PWM_FLAG_STOP, you will see that the LED will turn on after the sequence.

But if you want to have a constant duty cycle, e.g. for controlling a motor, you might not want to turn it off at all, so then you would have to use the first bit to tell it whether you want to have an active high or an active low PWM signal.

Best regards,

Edvin

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

awneil — Fri, 21 Sep 2018 16:36:53 GMT

Quoting from code doesn't seem to work on this forum?

        .top_value    = 32768, // = 0x8000

causes nrf_drv_pwm_init() to Assert - the maximum allowed value is 7FFF.

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

awneil — Thu, 20 Sep 2018 22:14:02 GMT

Now I see:

nrf_pwm_sequence_t.repeats sets the number of times to repeat each step within the sequence;
playback_count sets the number of times to repeat the entire sequence.

Of course, with only a single step in the sequence, they both end up as the same effect!

EDIT

To further clarify, nrf_pwm_sequence_t.repeats is the number of repeats after the first iteration; ie,

repeats = 0 runs each step once;
repeats = 1 runs each step once, plus 1 repeat;
repeats = 2 runs each step once, plus 2 repeats;
repeats = n runs each step once, plus n repeats

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

awneil — Wed, 19 Sep 2018 16:58:24 GMT

[quote userid="26071" url="~/f/nordic-q-a/38607/nrf5-sdk15-0---pwm-driver-just-set-a-fixed-duty-cycle/149367"]But you can do this with a simple test[/quote]

Sadly, there seems to be far too much of that with the Nordic parts.

Documentation is supposed to tell us these things - not leave us puzzled and having to experiment & reverse-engineer it all!

[quote userid="26071" url="~/f/nordic-q-a/38607/nrf5-sdk15-0---pwm-driver-just-set-a-fixed-duty-cycle/149367"]the signal will start high[/quote]

So what is the NRF_DRV_PWM_PIN_INVERTED flag supposed to do in the config.output_pins[] settings?

I doesn't seem to make any difference ...

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

Edvin — Wed, 19 Sep 2018 09:02:09 GMT

I agree. That is also why I didn't specify which is which. But you can do this with a simple test. Set it to e.g. 1/10th of 0x7FFF ≈ 0x0800. Then check if the light is on for 1/10th, or off for 1/10th of the period. Testing this shows that with sec_value of 0x0800 the LED is on for a very short amount of time. Since the LED is ON when the pin is LOW, this means that if the msb is 0, then the PWM signal will go from low to high when 0x0800 ticks = 2048 ticks has passed. Then it stays high until the .top_value is reached.

Note that you will see a similar behavior if you set the value to 0x8000 (=0b1000 0000 0000 0000) + 0x7FFF-0x0800 = 0xF7FF.

This is because the signal will start high, and stay high until the value reaches 0xF7FF-0x8000 = 0x77FF ticks, and switch to LOW (LED ON) for the rest of the period, which is 0x8000 ticks.

But to summarize:

msb = 0, signal goes low to high on seq_values.

msb = 1, signal goes high to low on seq_values.

Best regards,

Edvin

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

awneil — Tue, 18 Sep 2018 17:40:19 GMT

[quote userid="26071" url="~/f/nordic-q-a/38607/nrf5-sdk15-0---pwm-driver-just-set-a-fixed-duty-cycle/149264"]If you look in the description of the sec_values, you see that the first bit will be the polarity of the PWM signal, as described in nrf_pwm.h, line 248 (in SDK15.0.0).[/quote]

What it doesn't tell you is how it sets the polarity - does 1 set active high, or active low?

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

awneil — Tue, 18 Sep 2018 14:55:00 GMT

So what's the difference between the nrf_pwm_sequence_t.repeats setting, and the playback_count parameter in nrfx_pwm_simple_playback() ?

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

awneil — Tue, 18 Sep 2018 14:23:34 GMT

[quote userid="26071" url="~/f/nordic-q-a/38607/nrf5-sdk15-0---pwm-driver-just-set-a-fixed-duty-cycle/149264"]I changed nrf_pwm_sequence_t.repeats to 0, but changed the flag to NRF_PWM_FLAG_LOOP, so that it will repeat the signal forever[/quote]

I think that's the key piece of information that's missing from all the documentation!

I did wonder if there was an option like this, but could not find it anywhere - so what I did was to set repeats to UINT16_MAX. With my other settings, this meant that it only needed attention every 20 minutes or so.

With repeats set to zero, and the LOOP flag set, does this mean that a NRF_DRV_PWM_EVT_FINISHED event is never generated?

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

Edvin — Tue, 18 Sep 2018 14:03:26 GMT

Yes. This is basically what the pwm driver does.

See the attached version of demo3 in examples\peripheral\pwm_driver.

If you replace demo3() with this, it will have the LED in a dimmed position.

static void demo3(void)
{
    NRF_LOG_INFO("Demo 3");

    /*
     * This demo uses only one channel, which is reflected on LED 1.
     * The LED blinks three times (200 ms on, 200 ms off), then it stays off
     * for one second.
     * This scheme is performed three times before the peripheral is stopped.
     */

    nrf_drv_pwm_config_t const config0 =
    {
        .output_pins =
        {
            BSP_LED_0 | NRF_DRV_PWM_PIN_INVERTED, // channel 0
            NRF_DRV_PWM_PIN_NOT_USED,             // channel 1
            NRF_DRV_PWM_PIN_NOT_USED,             // channel 2
            NRF_DRV_PWM_PIN_NOT_USED,             // channel 3
        },
        .irq_priority = APP_IRQ_PRIORITY_LOWEST,
        .base_clock   = NRF_PWM_CLK_2MHz,//NRF_PWM_CLK_125kHz,
        .count_mode   = NRF_PWM_MODE_UP,
        .top_value    = 32768, // = 0x8000
        .load_mode    = NRF_PWM_LOAD_COMMON,
        .step_mode    = NRF_PWM_STEP_AUTO
    };
    APP_ERROR_CHECK(nrf_drv_pwm_init(&m_pwm0, &config0, NULL));
    m_used |= USED_PWM(0);

    // This array cannot be allocated on stack (hence "static") and it must
    // be in RAM (hence no "const", though its content is not changed).
    static uint16_t /*const*/ seq_values[] =
    {
        0x3000,
//        0x2000,
//        0x4000,
//        0x6000,
//        0x7FFF,
//        0x8000
    };
    nrf_pwm_sequence_t const seq =
    {
        .values.p_common = seq_values,
        .length          = NRF_PWM_VALUES_LENGTH(seq_values),
        .repeats         = 0,
        .end_delay       = 0
    };

    (void)nrf_drv_pwm_simple_playback(&m_pwm0, &seq, 3, NRF_DRV_PWM_FLAG_LOOP);
}

You see that if you remove all but 1 seq_values[], this value will be used.

As you see, you can adjust the frequency of the base clock, which will change the tick rate. The seq_values[] value will be the number of ticks before it changes.

The .top_value is the number of ticks before the clock will reset the counter (.base clock * .top_value = pwm period).

If you look in the description of the sec_values, you see that the first bit will be the polarity of the PWM signal, as described in nrf_pwm.h, line 248 (in SDK15.0.0).

The most significant bit (bit 15) will decide the polarity of the output, while bit 0-14 will be the duty cycle.

I changed nrf_pwm_sequence_t.repeats to 0, but changed the flag to NRF_PWM_FLAG_LOOP, so that it will repeat the signal forever.

Best regards,

Edvin

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

awneil — Tue, 18 Sep 2018 13:03:23 GMT

OK - thanks.

So, for completeness, is it possible to use the PWM peripheral to give a simple fixed duty cycle that will continue indefinitely?

RE: nRF5 SDK15.0 - PWM Driver: Just set a fixed duty cycle?

Edvin — Tue, 18 Sep 2018 12:10:57 GMT

Hello,

I would agree to some degree of what you are saying. The PWM driver example is good for fancy PWM LEDs, but if you want a simple PWM with a fixed period and a dimmed LED that is easily controllable, it might be easier to use the PPI module with a timer.

Attached is a simple PPI example that does this. If you run it on an nRF52DK, it shouldn't need any modifications. It should dim 2 LEDs in a pattern.

The PPI setup might look a bit scary, but the function that is actually controlling the LEDs duty cycle is controlled from the main() function. Note that for simplicity, the example uses nrf_delay_ms(), which is not a good approach, power consumption vise.

devzone.nordicsemi.com/.../ppi_5F00_double_5F00_channel_5F00_pwm.zip

Note that the pwm[0/1]_set_duty_cycle() doesn't need to use the sin_scaled() function. You can set it to any value between 1 and 1024 (TIMER_RELOAD), which is the number of ticks in the current setup.

You can change the TIMER_RELOAD to change the period of your PWM signal.

In the zip-folder attached, only a Keil project is included. But you should be able to change any of the main.c files from the projects in SDK\examples\periperal with this one, if you want to use a different IDE.

Let me know if anything is unclear, or if you have any questions regarding the PPI, or if you want to use the PWM driver instead of this.

Best regards,

Edvin