Synchronizing DMA SAADC with PWM using nRF52

[Jarmo]

We have an optical measurement system where we need to pulse LED and sample a phototransistor precisely during the LED pulse. The rate of sampling is 1 kHz and we plan to use 1:10 pulse ratio for the LED.

This far, I have written a working system than samples at 1 kHz using SAADC and DMA (using four channels, actually). The LED is not pulsed yet, but is on all the time.

I guess it is relatively simple to use pulse width modulation (PWM) to pulse the LED. However, I need to sychronize ADC with the PWM pulse. In another words, analog-to-digital conversion must happen about 100 us after the LED is put on.

My question is how to get this done? It would be best to stay in DMA based ADC, but is the synchronization with PWM possible? Or do I need to switch to interrupt based ADC (hopefully not)?

[Jarmo]

I think that since both ADC and PWM are driven by the same clock (rtc or core clock), the problem converges into the question how to set rate parameters identically for both and how to start PWM and ADC processes at the same time (or at least almost).

[Øyvind Karlsen]

Starting them at the same time is easily done by using PPI and the FORK register. This allows you to get a event, for example a timer compare, and then trigger ADC->TASKS_START and PWM->TASKS_START off of that event.

[Øyvind Karlsen]

Hi,

I think this should be very feasible using PPI, it will require some fine tuning. Programmable peripheral interconnect (PPI) is essentially configurable hardware shorts, so that on a timer capture compare you can trigger a measurement all without waking up the CPU. In the example below I set up some code that will generate a 8 MHz output on pin 18 using PPI, TIMER and GPIOTE.

int main(void)
{
    // Set up GPIO as output
    nrf_gpio_range_cfg_output(17, 18);
    nrf_gpio_pin_clear(17); // Light LED 1 to indicate that the code is running

    // Start high frequency clock
    NRF_CLOCK->TASKS_HFCLKSTART = 1;
    while (NRF_CLOCK->EVENTS_HFCLKSTARTED == 0)
    {
        // Wait for clock to start
    }
    NRF_CLOCK->EVENTS_HFCLKSTARTED = 0;

    // Configure GPIOTE to toggle pin 18 
    NRF_GPIOTE->CONFIG[0] = GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos |
                            GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos |
                            18 << GPIOTE_CONFIG_PSEL_Pos | 
                            GPIOTE_CONFIG_OUTINIT_Low << GPIOTE_CONFIG_OUTINIT_Pos;

    // Set up timer
    NRF_TIMER1->PRESCALER = 0;
    NRF_TIMER1->CC[0] = 2; // Adjust the output frequency by adjusting the CC.
    NRF_TIMER1->SHORTS = TIMER_SHORTS_COMPARE0_CLEAR_Enabled << TIMER_SHORTS_COMPARE0_CLEAR_Pos;
    NRF_TIMER1->TASKS_START = 1;

    // Set up PPI to connect the timer compare event with the GPIOTE toggle task
    NRF_PPI->CH[0].EEP = (uint32_t) &NRF_TIMER1->EVENTS_COMPARE[0];
    NRF_PPI->CH[0].TEP = (uint32_t) &NRF_GPIOTE->TASKS_OUT[0];

    NRF_PPI->CHENSET = PPI_CHENSET_CH0_Enabled << PPI_CHENSET_CH0_Pos;

    while (true)
    {

    }
}

Similarly you will be able to configure ADC and PWM modules to use PPI.

• TIMER uses the high-frequency clock source (HFCLK, 16 MHz), which means better resolution (62.5 ns) and higher power consumption (typ. 5 or 70 uA depending on HFCLK source).
• RTC uses the low-frequency clock source (LFCLK, 32 KHz), which means less resolution (~30 us) and lower power consumption (typ. 0.1 uA).

So for your case I believe you will be able to get away with using the RTC.

In particular look into the FORK register of the PPI module, this will allow you to start several modules at the same time.

Finally here's a link to the PPI documentation.

Best regards,

Øyvind

[Jarmo]

Thanks a lot, sounds very good! I will try that when we get the project that far :)

[Jarmo]

Okay, I am now trying to set up that system. However, it seems like there's some confusion when trying to map your example into the software API instead of poking directly the hardware. Sorry to say, but most of your APIs are nothing but easy to understand. My code looks like below, I have commented away your original lines and tried to replace them with the API calls:

    nrf_ppi_channel_t ch;
    uint32_t timerEvent = nrf_drv_timer_compare_event_address_get(&m_timer, NRF_TIMER_CC_CHANNEL0);
    nrf_drv_ppi_channel_alloc(&ch);
    // Configure GPIOTE to toggle debug pin 
    NRF_GPIOTE->CONFIG[0] = GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos |
                            GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos |
                            MCU_DEBUG_LED << GPIOTE_CONFIG_PSEL_Pos | 
                            GPIOTE_CONFIG_OUTINIT_Low << GPIOTE_CONFIG_OUTINIT_Pos;
    // Set up PPI to connect the timer compare event with the GPIOTE toggle task
    nrf_drv_ppi_channel_assign(ch, timerEvent, 0); // ???
    // NRF_PPI->CH[ch].EEP = (uint32_t) &NRF_TIMER1->EVENTS_COMPARE[0];
    / /NRF_PPI->CH[ch].TEP = (uint32_t) &NRF_GPIOTE->TASKS_OUT[0];
    nrf_drv_ppi_channel_enable(ch);
    // NRF_PPI->CHENSET = PPI_CHENSET_CH0_Enabled << PPI_CHENSET_CH0_Pos;

As you might guess, this does not work. I am wondering if the index zero in NRF_GPIOTE->CONFIG[0] refers to PPI channel or what is it? What is wrong with this code?