nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Einar Thorsrud — Thu, 10 Feb 2022 13:36:36 GMT

Hi,

That will not work. Calling nrfx_saadc_sample() in the end calls nrfx_saadc_sample(), which looks like this:

nrfx_err_t nrfx_saadc_sample()
{
    NRFX_ASSERT(m_cb.state != NRFX_DRV_STATE_UNINITIALIZED);

    nrfx_err_t err_code = NRFX_SUCCESS;
    if (m_cb.adc_state != NRF_SAADC_STATE_BUSY)
    {
        err_code = NRFX_ERROR_INVALID_STATE;
    }
    else if (m_cb.low_power_mode)
    {
        nrf_saadc_task_trigger(NRF_SAADC_TASK_START);
    }
    else
    {
        nrf_saadc_task_trigger(NRF_SAADC_TASK_SAMPLE);
    }

    NRFX_LOG_INFO("Function: %s, error code: %s.", __func__, NRFX_LOG_ERROR_STRING_GET(err_code));
    return err_code;
}

So you need to have set everything up for sampling, and not for instance, be in the middle of another sampling. If you want to do thing like this where you juts call a function and everything is done for you and you are ready again once it returns you need to use the blocking API instead, which is nrfx_saadc_sample_convert() in this case.

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Nikosant03 — Wed, 09 Feb 2022 07:10:31 GMT

Thank you for your answer hmolesworth but I cannot modify the hardware at the moment. However I do not understand why I cannot sampling in a loop like this

for(uint_8 i=0; i<no_of_sensors; i++){
nrf_drv_saadc_sample();
}

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

hmolesworth — Tue, 08 Feb 2022 18:10:24 GMT

Apart from timing and power consumption, what analogue mux are you using? It is not too difficult to make external sample/hold circuits for each analogue pressure sensor to effectively give synchronous ADC sampling if you are able to modify the hardware. A single sample pin would then capture all 8 values simultaneously which would be read out with less importance on SAADC sampling speed as the serial box-car waveform

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Nikosant03 — Tue, 08 Feb 2022 11:02:50 GMT

Hi Einar, sorry for the late reply.

Well, it seems that the best approach is using the app timer, however I learned a lot of things by experimenting with alternative solutions. In my case, the sampling interval is not super critical, but the power consumption is (and the PPI increases the power consumption significantly).

Now my task is to read the IMU (I2C protocol) and 8 analog pressure sensors (connected on a MUX) with a frequency of 100Hz and send the payload through BLE. I want to start sampling when the user enables the notifications

So I start an app timer when the notifications are enabled

static void on_cus_evt(ble_cus_t *p_cus_service,
  ble_cus_evt_t *p_evt, int gatt_handler) {
  ret_code_t err_code;

  if (gatt_handler == CCCD_HANDLE) {
    switch (p_evt->evt_type) {
    case BLE_CUS_EVT_NOTIFICATION_ENABLED:
      NRF_LOG_INFO("Notification Enabled");
      notification = ENABLE;

      err_code = app_timer_start(m_notification_timer_id, samplingRate, NULL);
      APP_ERROR_CHECK(err_code);
      
      
      ........
      ....
      ..
      }

When the timer expires (every 10ms), it calls the read_sensor() where I want initially read the IMU, then the pressure sensors, and then transmit the data.

void read_sensors(void *p_context) {

  ret_code_t err_code;
  UNUSED_PARAMETER(p_context);

  // Read the IMU
  IMU_read(&sampling);

  // Read the pressure sensors
  for (uint8_t i = 0; i < NO_SENSORS - 1; i++) {
    pressure_sensors_read(&sampling);
  }

  sampling.index = 0;

  // Increment the packet counter
  packet_increment(&sampling);

  logger(&sampling);

  // Buffer that payload
  my_sensors_buffer(&sampling);

  // if the buffer is not empty Tx data
  if (!nrf_queue_is_empty(&m_sensor_data_queue)) {
    data_tx(&sampling);
  }
}

However when I run the for loop to read all the sensors, I read just the first sensor and not the other seven

To read the pressure sensors I used an additional app timer and I set the SAADC_INERVAL to 50us just to read the sensors fast

void pressure_sensors_read(struct s_sampling *sampling) {
  ret_code_t err_code;
  err_code = app_timer_start(m_SAADC_timer_id, SAADC_INTERVAL, NULL);
  APP_ERROR_CHECK(err_code);
}

void saadc_sample() {
  ret_code_t err_code;

  err_code = app_timer_stop(m_SAADC_timer_id);
  APP_ERROR_CHECK(err_code);

  err_code = nrf_drv_saadc_sample(); // na - trigger sampling
  APP_ERROR_CHECK(err_code);
}

By the way this is my saadc callback function

void saadc_callback(nrf_drv_saadc_evt_t const *p_event) {

  ret_code_t err_code;

  if (p_event->type == NRF_DRV_SAADC_EVT_DONE) { 

    err_code = nrfx_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLES_IN_BUFFER); // convert two's complement to a proper value.
    APP_ERROR_CHECK(err_code);

    NRF_LOG_INFO("FF[%d]: %d", sampling.index, p_event->data.done.p_buffer[0]);

    sampling.flexi_force[sampling.index++] = p_event->data.done.p_buffer[0];

    selectMuxPin(sampling.index); // na - change MUX channel to read the next sensor
  }
}

The NRF_LOG_INFO("FF[%d]:.... prints just once

So, how could I read the pressure sensors before transmitting payload? Any example?

Thanks!

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Einar Thorsrud — Wed, 22 Dec 2021 10:07:12 GMT

Hi,

[quote user="Nikosant03"]Something like that (I used RTC for now instead of app timer)?[/quote]

Something like that, but not exactly like here.

I really recommend you use the app_timer instead, as that implements some features for you which you need. And prevents you from ending up in a few pitfalls, which you have done here. Looking at your RTC handler, you first call nrf_drv_saadc_sample(), and after that has completed you configure the RTC for the next compare event. But a bit of time has elapsed here, so you will have more ticks than you had planned in between here.

[quote user="Nikosant03"]The RTC IRQ priority is set to 6. Should it be 7?[/quote]

The interrupt priorities does not matter much in itself, but matters relative to others in the system, so this is application specific. How important is this timing compared to other events in the system, and can other events handle being blocked for too long? If you can live with a bit of jitter in the sampling interval, then using a low priority (like 7) makes sense, or perhaps even moving it to the main loop (no interrupt at all).

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Nikosant03 — Tue, 21 Dec 2021 16:01:07 GMT

[quote userid="7377" url="~/f/nordic-q-a/82990/nrf52840-sdk16---saadc-rtc-ppi-power-optimized-solution/344622#344622"]

No, you should not need two app timers. Just a single one where you do the following:

Enable the SAADC
Sample all sensors back to back
Disable SAADC

[/quote]

Something like that (I used RTC for now instead of app timer)?

Definitions

#define RTC_FREQUENCY 32                               // Determines the RTC frequency and prescaler
#define SAADC_SAMPLE_INTERVAL_MS 1000                  // Interval in milliseconds at which RTC times out and triggers SAADC sample task (
#define SAADC_SAMPLES_IN_BUFFER 1                      // Number of SAADC samples in RAM before returning a SAADC event. For low power SAADC set this constant to 1. Otherwise the EasyDMA will be enabled for an extended time which consumes high current.
#define SAADC_OVERSAMPLE NRF_SAADC_OVERSAMPLE_DISABLED // Oversampling setting for the SAADC. Setting oversample to 4x This will make the SAADC output a single averaged value when the SAMPLE task is triggered 4 times. Enable BURST mode to make the SAADC sample 4 times when triggering SAMPLE task once.
#define SAADC_BURST_MODE 0                             // Set to 1 to enable BURST mode, otherwise set to 0.
#define SENSORS 8

const nrf_drv_rtc_t rtc = NRF_DRV_RTC_INSTANCE(2); /**< Declaring an instance of nrf_drv_rtc for RTC2. */
static uint32_t rtc_ticks = RTC_US_TO_TICKS(SAADC_SAMPLE_INTERVAL_MS * 1000, RTC_FREQUENCY);
static nrf_saadc_value_t m_buffer_pool[2][SAADC_SAMPLES_IN_BUFFER];
static uint32_t m_adc_evt_counter = 0;

RTC handler

static void rtc_handler(nrf_drv_rtc_int_type_t int_type) {
  uint32_t err_code;

  if (int_type == NRF_DRV_RTC_INT_COMPARE0) {
    nrf_drv_saadc_sample(); // Trigger the SAADC SAMPLE task

    err_code = nrf_drv_rtc_cc_set(&rtc, 0, rtc_ticks, true); // Set RTC compare value and enable the interrupt
    APP_ERROR_CHECK(err_code);
    m_adc_evt_counter = 0;
    nrf_drv_rtc_counter_clear(&rtc); // Clear the RTC counter to start count from zero
  }
}

ADC handler

void saadc_callback(nrf_drv_saadc_evt_t const *p_event) {
  ret_code_t err_code;
  if (p_event->type == NRF_DRV_SAADC_EVT_DONE) // Capture offset calibration complete event
  {
    err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAADC_SAMPLES_IN_BUFFER); // Set buffer so the SAADC can write to it again.
    APP_ERROR_CHECK(err_code);

    NRF_LOG_INFO("ADC event number: %d\r\n", (int)m_adc_evt_counter); // Print the event number on UART

    for (int i = 0; i < p_event->data.done.size; i++) {
      NRF_LOG_INFO("SAADC result: %d\r\n", p_event->data.done.p_buffer[i]); // Print the SAADC result on UART
    }

    m_adc_evt_counter++;
    if ((m_adc_evt_counter % SENSORS) != 0) { // Sample all the sensors

      nrf_drv_saadc_sample(); // Trigger the SAADC SAMPLE task
      //add code to switch the MUX
    }
  }
}

The RTC IRQ priority is set to 6. Should it be 7? I do not have experience with differing processing. Is this something essential that I should include?

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Einar Thorsrud — Tue, 21 Dec 2021 14:10:32 GMT

No, you should not need two app timers. Just a single one where you do the following:

Enable the SAADC
Sample all sensors back to back
Disable SAADC

Note that the above would take a bit of time to complete, so you should either ensure that the interrupt priority of the app_timer is lower than other interrupts (by setting APP_TIMER_CONFIG_IRQ_PRIORITY in sdk_config.h accordingly), or defer the actual processing to the main loop (either manually or using the app_scheduler).

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Nikosant03 — Tue, 21 Dec 2021 14:05:29 GMT

Thank Einar,

So I need two app timers? The first one will expire every 10ms to start sampling with the first sensor and then I need the second app timer to keep sampling the rest 7 sensors right (probably 80-100us it would be fine)? But now I am thinking that 80-100us is fast enough and could be a problem with the higher priority interrupts.

The requirement is to start sampling every 10ms BUT the sampling between the sensors (8 in total) to be done as fast as possible.

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Einar Thorsrud — Tue, 21 Dec 2021 13:20:24 GMT

Yes, it will. Not on its own, though. You also need to disable the SAADC (nrf_saadc_int_disable()) when done and re-enable it before using it in order to obtain low power consumption (if not, the SAADC will always be enabled and so the high frequency clock will also always run).

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Nikosant03 — Tue, 21 Dec 2021 13:15:46 GMT

Hi Einar,

So you suggest not using the PPI but just application timers because my sampling frequency is low? This will keep down the power consumption since I won't use PPI I guess?

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Einar Thorsrud — Tue, 21 Dec 2021 12:38:02 GMT

Hi,

The suggestion you already got makes sense I would say. Though I would simplify even further and simply us an extra repeated app_timer, which gives you all you need out of the box. This way simply do the SAADC handling from SW, and use a normal system on low power sleep in between.

The down-side of this approach is that as you do this in SW, a higher priority interrupt would delay your sampling. As you sample every 10 ms (not very often) that is perhaps not a big problem? Also, depending on interrupt priorities and durations of the high priority interrupts you have in the rest of your code, the actual worst case delay will probably be very short compared to the 10 ms interval.

RE: nRF52840 SDK16 - SAADC + RTC + PPI (power optimized solution)

Mehmet Nuri — Tue, 21 Dec 2021 00:19:18 GMT

why not do the whole thing under RTC Compare event handler ? set the new event at the end of the handler and you wont need to time the whole thing up. And by the way, you can use app_timer for this. App timer uses RTC1 and saadc uses app_timer. An RTC can configure 4 compare event. 1 used by the saadc. you have 3 of them free. you can set a app_timer event(basically compare event) and do the saadc readings in event handler. at the end of the handler you set a new timer and so on. You just remember not to go to sleep in app_timer event handler. it just stucks there. I just discovered it :D you can look into my ticket. I use saadc and app_timer. whole code is not shared but what you need is there. Look at my ticket