PWM Frequency Measurement on nRF52 with SDK 11

RE: PWM Frequency Measurement on nRF52 with SDK 11

Øyvind Karlsen — Mon, 04 Jul 2016 05:55:39 GMT

Hi,

You can set up an application timer, as shown in this tutorial.

RE: PWM Frequency Measurement on nRF52 with SDK 11

Mark — Thu, 30 Jun 2016 21:34:18 GMT

Bret, I want to go back to the initial answer you posted "It will be a lot more accurate to let the PWM transitions cause an interrupt and have the ISR increment a counter. Then let the whole works run for, say, 5 seconds. Divide the number of counts by 5 and you will have Hz."

So Based on the following code I can have the ISR increment a counter. But how can I start and stop the ISR within a specified period of time? Does the following code work reliably?

static uint32_t IRQcount = 0;
static const uint32_t oneSecond = 1000000;

void in_pin_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{
    IRQcount++;
}
/**
  * @brief Function for configuring: PIN_IN pin for input, PIN_OUT pin for output, 
  * and configures GPIOTE to give an interrupt on pin change.
  */
static void gpio_init(void)
{
    ret_code_t err_code;

    err_code = nrf_drv_gpiote_init();
    APP_ERROR_CHECK(err_code);

    nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_LOTOHI(true);
    in_config.pull = NRF_GPIO_PIN_PULLUP;

    err_code = nrf_drv_gpiote_in_init(PIN_IN, &in_config, in_pin_handler);
    APP_ERROR_CHECK(err_code);

    nrf_drv_gpiote_in_event_enable(PIN_IN, false);
}

/**
  * @brief Function for application main entry.
  */
int main(void)
{
    gpio_init();

    const int period_30ms = 30000;
    uint16_t i;
    bool time_start = false;
    uint32_t freq_value = 0;

        while (true)
        {
            if(time_start == true)
            {
                       nrf_drv_gpiote_in_event_enable(PIN_IN, true);
                       for(i = 0; i < 30000; i++);
                       nrf_drv_gpiote_in_event_enable(PIN_IN, false);
                       freq_value = IRQcount*oneSecond/period_30ms; //frequency in Hz
                       IRQcount = 0;
                       time_start = false;
            }
            nrf_delay_ms(1000);
            time_start = true;
        }
}

RE: PWM Frequency Measurement on nRF52 with SDK 11

Bret Foreman — Fri, 24 Jun 2016 00:45:04 GMT

So if you set your pre-scaler to increment the timer every 1 uS, then your 10mS time will be 10,000 ticks. A 16-bit timer can count up to 64K ticks so you are good.

RE: PWM Frequency Measurement on nRF52 with SDK 11

Bret Foreman — Fri, 24 Jun 2016 00:34:19 GMT

You calculate the uS for each tick according to how you set up the timer. The timer has a pre-scaler that divides the system clock down into counter ticks. You set up that pre-scaler such that your timer doesn't overflow before your event occurs. In your case, your longest time between events is 10mS (100Hz). Does that make sense?

RE: PWM Frequency Measurement on nRF52 with SDK 11

Mark — Fri, 24 Jun 2016 00:14:31 GMT

OK, I see... Yeah, even Arduino doesn't use a timer to actually measure the rise or fall time. It counts the number of ticks(increments) that happen from 0V to 5V, and converts them to microseconds. Now, I noticed SDK 11 has a function nrf_drv_timer_us_to_ticks() but didn't see any nrf_drv_timer_ticks_to_us(). How can I make such function?

RE: PWM Frequency Measurement on nRF52 with SDK 11

Bret Foreman — Thu, 23 Jun 2016 20:11:03 GMT

I am familiar with the Arduino IDE. With the Nordic, you are usually using a SoftDevice, a kind of operating system that Arduino does not have. With the SoftDevice, accurately measuring fast events gets complicated. Here's how to do it: infocenter.nordicsemi.com/index.jsp

RE: PWM Frequency Measurement on nRF52 with SDK 11

Mark — Thu, 23 Jun 2016 19:20:32 GMT

I don't care how fast the frequency varies, but I need to measure it every millisecond, and within 1% accuracy.

I don't think I need to know about FM demodulation. If I could use a timer to measure how fast the GPIO pin goes from 0V to 3.3V and vice versa in the next cycle, that should be accurate enough for me.

I don't know how familiar you are with Arduino IDE, but there's a PulseIn() function that measures PWM frequency pretty good. At least it was pretty accurate for me when I was measuring PWM frequencies from 100Hz to 500Hz.

I just want to accomplish the same goal with nRF52, and it seems to be pretty complicated!

RE: PWM Frequency Measurement on nRF52 with SDK 11

Bret Foreman — Thu, 23 Jun 2016 18:46:31 GMT

Ah, your OP didn't mention that you want to measure a varying frequency. How fast can it vary, how often do you need to measure it, and what accuracy do you need? By the way, periodically measuring a varying frequency is essentially FM demodulation. You might browse that topic in Wikipedia to see the various ways it can be done and understand their benefits and drawbacks.

RE: PWM Frequency Measurement on nRF52 with SDK 11

Mark — Thu, 23 Jun 2016 18:39:56 GMT

Well, as I stated earlier the PWM frequency changes between 100Hz and 1000Hz. The frequency can go from 100Hz to 1000Hz in 5, 6, 7, or even 10 seconds; so there is a slow ramp up for frequency. If I try to measure the PWM frequency within 5 seconds it won't be accurate and I will see an average value of 500Hz. Whereas if I try to measure the frequency as the state of GPIO pin changes I can measure frequency within 1 to 10 milliseconds.

I used to measure frequencies with 8-bit ATmega328p processor and accuracy was never an issue for me, and it was always accurate. Why would I encounter lower accuracy if I try to measure frequency in a window of faster than 5 seconds?

RE: PWM Frequency Measurement on nRF52 with SDK 11

Bret Foreman — Thu, 23 Jun 2016 17:45:15 GMT

I should add that people use this technique all the time for measuring the frequency of external periodic events. It's a standard approach.

RE: PWM Frequency Measurement on nRF52 with SDK 11

Bret Foreman — Thu, 23 Jun 2016 17:43:35 GMT

Mark, you wouldn't be stalling the CPU. You would just increment a counter inside the ISR, then exit the ISR. The whole process will take a couple of uS each time the PWM transition occurs. How quickly do you need your result? You could count for less than 5 seconds if you are willing to accept lower accuracy in the result. It's a direct, linear trade-off between accuracy and measurement time.

RE: PWM Frequency Measurement on nRF52 with SDK 11

Mark — Thu, 23 Jun 2016 17:32:52 GMT

Isn't 5 seconds a long time?

How can I take advantage of PPI so I won't stall CPU while measuring frequency?

Could you please describe in more details how I can setup GPIO pin, timer, and ISR in order to measure frequency?

Thanks

RE: PWM Frequency Measurement on nRF52 with SDK 11

Bret Foreman — Thu, 23 Jun 2016 01:50:31 GMT

It will be a lot more accurate to let the PWM transitions cause an interrupt and have the ISR increment a counter. Then let the whole works run for, say, 5 seconds. Divide the number of counts by 5 and you will have Hz.