ADC and PWM events

RE: ADC and PWM events

Karl Ylvisaker — Thu, 06 Jan 2022 14:01:46 GMT

Hello again,

Thank you for your patience with this - I have been out of office for some time, but now I am back again.

[quote user="Nppn7"]how is it possible that the PWM blocks the ADC? Shouldn't the PWM only start the ADC? And then it is up to the ADC how long it will need.[/quote]

The PWM will not be blocking the SAADC's execution - the SAADC will start a conversion as soon as the TASKS_SAMPLE task is triggered if it is not already busy. Which SAADC event are you now using to indicate that a single conversion has finished, and what buffer size for the SAADC are you using?

It seems to me that the conversions itself take a lot shorter than 190 µs, if that is what is being indicated by the second channel going low in your oscilloscope picture.

Please also see my other questions in my previous comment.

Best regards,
Karl

RE: ADC and PWM events

Nppn7 — Mon, 20 Dec 2021 15:01:45 GMT

Hi,

how is it possible that the PWM blocks the ADC? Shouldn't the PWM only start the ADC? And then it is up to the ADC how long it will need. These are my PWM settings:

static nrfx_pwm_t TIMEAPI_pwm_instance_s = NRFX_PWM_INSTANCE(0);
static nrf_pwm_values_individual_t TIMEAPI_pwm_sequence_values_s;
nrf_pwm_sequence_t const TIMEAPI_pwm_sequence_s =
{
    .values.p_individual = &TIMEAPI_pwm_sequence_values_s,
    .length              = NRF_PWM_VALUES_LENGTH(TIMEAPI_pwm_sequence_values_s),
    .repeats             = 0,
    .end_delay           = 0
};

    nrfx_pwm_config_t const pwm_config_s =
    {
        .output_pins =
        {
            GENAPI_GpioGetMotorDir1_s().pin_number, // channel 0
            GENAPI_GpioGetMotorDir2_s().pin_number, // channel 1
            NRFX_PWM_PIN_NOT_USED, // channel 2
            NRFX_PWM_PIN_NOT_USED  // channel 3
        },
        .irq_priority = APP_IRQ_PRIORITY_HIGHEST,
        .base_clock   = NRF_PWM_CLK_2MHz,
        .count_mode   = NRF_PWM_MODE_UP,
        .top_value    = 100, // 100 @ 2MHz -> 20kHz
        .load_mode    = NRF_PWM_LOAD_INDIVIDUAL,
        .step_mode    = NRF_PWM_STEP_AUTO
    };
    APP_ERROR_CHECK(nrfx_pwm_init(&TIMEAPI_pwm_instance_s, &pwm_config_s, NULL));

    TIMEAPI_pwm_sequence_values_s.channel_0 = motor_pwm_duty_cycle_U8;
    TIMEAPI_pwm_sequence_values_s.channel_1 = 0;
    (void)nrfx_pwm_simple_playback(&TIMEAPI_pwm_instance_s, &TIMEAPI_pwm_sequence_s, 2, NRFX_PWM_FLAG_LOOP);

RE: ADC and PWM events

hmolesworth — Tue, 07 Dec 2021 16:35:29 GMT

The PWM is responsible for the 190uSecs, nothing to do with the SAADC .. what are the PWM settings? I don't see them in the posts above

RE: ADC and PWM events

Karl Ylvisaker — Fri, 03 Dec 2021 14:55:17 GMT

Hello,

[quote user="Nppn7"]thanks for the input. Using your code I could see the ADC conversion as GPIO. It seems to be started correctly but needs a lot of time (>190 uS). I need the PWM to run a motor. And measuing the motor current should be synched with PWM.[/quote]

Great, I am happy to hear that you were able to see the SAADC timing using the PPI.
Are you saying that a single conversion takes 190 µs? This would indeed indicate that something is wrong with the usage of the SAADC.

[quote user="Nppn7"]I need the PWM to run a motor. And measuing the motor current should be synched with PWM.[/quote]

How does your circuitry for measurement of the motor current using the SAADC look?
How will you synchronize the motor with the SAADC - do you mean to map the duty cycle to the SAADC's sample rate, for instance? If so, how closely does the SAADC need to match the motors changes in duty cycle?

Best regards,
Karl

RE: ADC and PWM events

Nppn7 — Fri, 03 Dec 2021 11:46:10 GMT

Hi,

thanks for the input. Using your code I could see the ADC conversion as GPIO. It seems to be started correctly but needs a lot of time (>190 uS). I need the PWM to run a motor. And measuing the motor current should be synched with PWM.

These are my settings:

#define NRFX_SAADC_ENABLED 1

#define NRFX_SAADC_CONFIG_RESOLUTION 2

#define NRFX_SAADC_CONFIG_OVERSAMPLE 0

#define NRFX_SAADC_CONFIG_LP_MODE 0

#define NRFX_SAADC_CONFIG_IRQ_PRIORITY 6

And I am using default settings for the channel:

#define NRFX_SAADC_DEFAULT_CHANNEL_CONFIG_SE(PIN_P) \
{                                                   \
    .resistor_p = NRF_SAADC_RESISTOR_DISABLED,      \
    .resistor_n = NRF_SAADC_RESISTOR_DISABLED,      \
    .gain       = NRF_SAADC_GAIN1_6,                \
    .reference = NRF_SAADC_REFERENCE_INTERNAL,     \
    .acq_time   = NRF_SAADC_ACQTIME_10US,           \
    .mode       = NRF_SAADC_MODE_SINGLE_ENDED,      \
    .burst      = NRF_SAADC_BURST_DISABLED,         \
    .pin_p      = (nrf_saadc_input_t)(PIN_P),       \
    .pin_n      = NRF_SAADC_INPUT_DISABLED          \
}

RE: ADC and PWM events

Karl Ylvisaker — Wed, 24 Nov 2021 13:30:32 GMT

Hello,

As @hmolesworth mentions you may do this through connecting the SAMPLE and DONE/END event to the setting and clearing task of a GPIO through the PPI peripheral. You should then be able to see the exact time spent on the conversion on the oscilloscope scoping the GPIO. I am however not certain that I have understood why you would want / need the PWM peripheral in this mix - could you elaborate on this?

Best regards,
Karl

RE: ADC and PWM events

hmolesworth — Wed, 24 Nov 2021 02:47:59 GMT

Maybe try using the PPI, either separate channels or FORK from PWM. Here's an example just using the SAADC (not tested):

// softdevice uses PPI channels 17-31 and groups 4-5
// See "Mask of PPI channels reserved by the SoftDevice when the SoftDevice is enabled"
//  nrf_soc.h: NRF_SOC_SD_PPI_CHANNELS_SD_ENABLED_MSK
//             NRF_SOC_SD_PPI_GROUPS_SD_ENABLED_MSK
// maybe use sd_ppi_channel_assign() if enabling when SD enabled
// Up to three tasks can be used in each GPIOTE channel for performing write operations to a pin, two
// are fixed (SET and CLR), and one (OUT) configurable to perform Set, Clear or Toggle
//  - "HiToLo" Task mode: Clear pin from OUT[n] task 

// PPI Peripheral channel assignments for driving PIN_MONITOR_SAADC
#define SAADC_GPIOTE_CH      0
#define SAADC_PPI_CH_A       0
#define SAADC_PPI_CH_B       1
// Arbitrary pin - say P0.05
#define PIN_MONITOR_SAADC    5

   // Set PIN_MONITOR_SAADC high at start of sample
   NRF_PPI->CH[SAADC_PPI_CH_A].EEP = (uint32_t)&NRF_SAADC->EVENTS_STARTED;
   NRF_PPI->CH[SAADC_PPI_CH_A].TEP = (uint32_t)&NRF_GPIOTE->TASKS_SET[SAADC_GPIOTE_CH];
// NRF_PPI->FORK[SAADC_PPI_CH_A].TEP = (uint32_t)&NRF_PWM0->TASKS_STOP;     // <<== optionally can do a second action with a FORK
   // Clear PIN_MONITOR_SAADC low at end of sample
   NRF_PPI->CH[SAADC_PPI_CH_B].EEP = (uint32_t)&NRF_SAADC->EVENTS_DONE;
   NRF_PPI->CH[SAADC_PPI_CH_B].TEP = (uint32_t)&NRF_GPIOTE->TASKS_CLR[SAADC_GPIOTE_CH];
// NRF_PPI->FORK[SAADC_PPI_CH_B].TEP = (uint32_t)&NRF_PWM0->TASKS_NEXTSTEP; // <<== optionally can do a second action with a FORK

   NRF_GPIOTE->CONFIG[SAADC_GPIOTE_CH] = GPIOTE_CONFIG_MODE_Task       << GPIOTE_CONFIG_MODE_Pos | 
                                         GPIOTE_CONFIG_POLARITY_HiToLo << GPIOTE_CONFIG_POLARITY_Pos | 
                                         PIN_MONITOR_SAADC             << GPIOTE_CONFIG_PSEL_Pos | 
                                         GPIOTE_CONFIG_OUTINIT_Low     << GPIOTE_CONFIG_OUTINIT_Pos;
   // Enable
   NRF_PPI->CHENSET = ((1UL << SAADC_PPI_CH_A) | (1UL << SAADC_PPI_CH_B));

Using the PWM PPI FORK as the set should also work ok