SAADC fails to sync with PWM via PPI

RE: SAADC fails to sync with PWM via PPI

obbe — Fri, 14 Dec 2018 13:15:18 GMT

Of course! 🤦

RE: SAADC fails to sync with PWM via PPI

Edvin — Fri, 14 Dec 2018 13:11:32 GMT

Yes. But then it will be synchronized with a pin interrupt, either going HiToLo or LoToHi.

void pin_init(uint32_t pinselect)
{  
    NRF_GPIOTE->CONFIG[CHANNEL_NUMBER] = GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos | 
                                         GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos | 
                                         pinselect << GPIOTE_CONFIG_PSEL_Pos | 
                                         GPIOTE_CONFIG_OUTINIT_High << GPIOTE_CONFIG_OUTINIT_Pos; // no effect when in event mode.

    NRF_PPI->CH[PIN_PPI_CH_A].EEP   = (uint32_t)&NRF_GPIOTE->EVENTS_IN[CHANNEL_NUMBER];
    NRF_PPI->CH[PIN_PPI_CH_A].TEP   = (uint32_t)&NRF_SAADC->TASKS_SAMPLE;
    
    NRF_PPI->CHENSET                = (1 << PIN_PPI_CH_A);
}

What you really are looking for is just the state change of the pin, and not the PWM events, right?

BR,

Edvin

RE: SAADC fails to sync with PWM via PPI

obbe — Thu, 13 Dec 2018 15:42:26 GMT

Ok, so I guess it all boils down to this question: Is it possible to generate an event that is synchronised with the start of a PWM period?

RE: SAADC fails to sync with PWM via PPI

Edvin — Thu, 13 Dec 2018 12:20:14 GMT

The point of the peripherals on the nRF is that they should do as much as possible without having to interrupt or wait for the CPU. Especially with the PWM driver. If you generate a PWM signal to control an LED or an electric motor, you certainly don't want to get an application interrupt every 2ms to toggle the pin. So after you start the PWM, it will not generate an event on every PWM period.

I still don't understand whether you generate the PWM on the nRF to trigger samples, or if you ultimately want it to trigger on a PWM signal that is generated externally.

[quote user="obbe"]I basically want an interrupt every T seconds[/quote]

Sounds like a timer, and not PWM is the way to go.

BR,

Edvin

RE: SAADC fails to sync with PWM via PPI

obbe — Thu, 13 Dec 2018 08:55:57 GMT

Thanks for the thorough reply.

I set the pin when I want to start the ADC conversion, and then clear it in the event handler. The issue is not that I'm not getting samples or that the event handler is called. I get a DONE event.

The issue is that the sequence doesn't sync with the PWM. What I want is that if I want to acquire a sample, the ADC shall wait until the beginning of the next PWM cycle. Assuming the the acquisition time is t_acq and the PWM period is T, I would expect an interrupt at T+t_acq, but using the oscilloscope, I can see that these are not at all related.

So I'm thinking that I have misinterpreted when PWM events are generated. I basically want an interrupt every T seconds, regardless if I'm changing the PWM duty cycles or not.

If this is not clear I can write a sample program that explains the use case better?

RE: SAADC fails to sync with PWM via PPI

Edvin — Thu, 13 Dec 2018 07:56:11 GMT

Hello,

I see. You set the pin in the saadc_evt_handler, right? And you try to trigger the SAADC from the PWM started event, correct?

I have not used the SAADC on register level before, so I can't say without testing whether your SAADC setup is correct or not, but I guess the SAADC needs more samples before it will trigger the event. It fills up the entire buffer, which I guess is the one you have set to 3:

NRF_SAADC->RESULT.MAXCNT = 3U;

Hence, even if the EEP triggers:

NRF_PPI->CH[0].EEP = (uint32_t)(&(NRF_PWM0->EVENTS_SEQSTARTED[kIndicatorPwmSequence]));

And the TEP triggers:

NRF_PPI->CH[0].TEP = (uint32_t)(&NRF_SAADC->TASKS_SAMPLE);

It will not trigger the saadc_evt_handler; because the SAADC doesn't get a callback until it has finished reading n samples, where n is the number of elements in the buffer.

Check this log from the saadc example in the SDK:

<info> SAADC: Function: nrfx_saadc_init, error code: NRF_SUCCESS.
<info> SAADC: Channel initialized: 0.
<info> SAADC: Function: nrfx_saadc_channel_init, error code: NRF_SUCCESS.
<info> SAADC: Function: nrfx_saadc_buffer_convert, buffer length: 5, active channels: 1.
<info> SAADC: Function: nrfx_saadc_buffer_convert, error code: NRF_SUCCESS.
<warning> SAADC: Function: nrfx_saadc_buffer_convert, error code: NRF_SUCCESS.
<info> app: SAADC HAL simple example started.
<debug> SAADC: Event: 
<debug> SAADC: Event: NRF_SAADC_EVENT_END.
<warning> SAADC: Function: nrfx_saadc_buffer_convert, error code: NRF_SUCCESS.
<info> app: ADC event number: 0
<info> app: 12
<info> app: 11
<info> app: 12
<info> app: 9
<info> app: 9

Only the logs starting with <debug> are from the SAADC_IRQHandler, the rest is from main.c.

I modified this function by adding the NRFX_LOG_DEBUG("Event:"); in the start of this function:

void nrfx_saadc_irq_handler(void)
{
    NRFX_LOG_DEBUG("Event: ");
    if (nrf_saadc_event_check(NRF_SAADC_EVENT_END))
    {
        nrf_saadc_event_clear(NRF_SAADC_EVENT_END);
        NRFX_LOG_DEBUG("Event: %s.", EVT_TO_STR(NRF_SAADC_EVENT_END));
    ...

As you can see, the first event in the irq handler is the NRF_SAADC_EVENT_END, which is after the first 5 samples are sampled (there are 5 samples in the buffer in this example).

You should check out this example. It sets up a timer, starts it, and uses PPI to trigger sample events from the timeout events. You can see in the example that the timeout handler is empty, so it is only used to trigger the samples via PPI.

When doing PPI implementations like the one you have posted, it is a good idea to start with a simple check, such as starting with the PWM, but as an TEP, just toggle a pin. To set up an GPIOTE in ppi, you can try the following:

void pin_init(uint32_t pinselect)
{  
    NRF_GPIOTE->CONFIG[CHANNEL_NUMBER] = GPIOTE_CONFIG_MODE_Task << GPIOTE_CONFIG_MODE_Pos | 
                                         GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos | 
                                         pinselect << GPIOTE_CONFIG_PSEL_Pos | 
                                         GPIOTE_CONFIG_OUTINIT_High << GPIOTE_CONFIG_OUTINIT_Pos;

    NRF_PPI->CH[PIN_PPI_CH_A].EEP = (uint32_t)(&(NRF_PWM0->EVENTS_SEQSTARTED[kIndicatorPwmSequence]));
    NRF_PPI->CH[PIN_PPI_CH_A].TEP = (uint32_t)&NRF_GPIOTE->TASKS_CLR[PWM0_GPIOTE_CH];
    
    NRF_PPI->CHENSET               = (1 << PIN_PPI_CH_A);
}

I suggest you check out the saadc example, which triggers the samples via ppi, and sets up all this using the SDK API, together with starting checking whether the PWM is set up correctly by toggling the pin on the PWM event end points (EEP).

Best regards,

Edvin

RE: SAADC fails to sync with PWM via PPI

obbe — Wed, 12 Dec 2018 14:23:04 GMT

Hi,

Pin 3 is not connected to anything. I'm just using it to verify that the ADC is synced with the PWM properly. I.e. I sample the PWM output and pin 3 output with the oscilloscope to see that the ADC sampling occurs when the PWM signal is high.

Yeah, a little background info would probably be in place. But the short answer is: using the PWM signal as a timer to trigger the SAADC readings.

The PWM is controlling an RGB LED (sinking it through transistors). To detect that the LED is working properly, we want to measure the voltage drop over the diodes, using the SAADC.

For example, assume that the LED's are powered with 5V and have a voltage drop of 3V. A normally functioning diode, when on, would have a voltage of 5V-3V = 2V at its cathode. A diode that has short-circuited would have 5V and one that has open-circuited would have 0V (because we are sinking it to GND). If it is not on, the voltage would be >3.3V, even when it's working. (We are not really sure of this, but its a theory anyway)

So, in order to reliably determine if the diode is working, we need to sync the SAADC reading with when the LED is ON, thus with the PWM.

RE: SAADC fails to sync with PWM via PPI

Edvin — Wed, 12 Dec 2018 13:59:51 GMT

Hello,

What is your pin 3 connected to? Is it RED GREEN or BLUE pin of yours, or something else?

To be honest, I am having a little trouble understanding exactly what you want to do. Are you trying to create a feedback loop to measure the average on the PWM pin, or are you using the PWM signal as a timer to trigger the SAADC readings?

BR,

Edvin