ADC + BLE IN ADC

[pavan_142297]

Hello All,

I configure ADC & BLE UART in one code. we are using 4 ADC channels. but I observed that there is a timing delay approx 2-3 sec to update ADC. we are using a 1 kb buffer for each ADC. to calculate voltage and current values.
anyone can suggest, how we can resolve the time delay issue from ADC configuration.

[Jared]

Hi,

Could you share your code and specify from what point you measure 2-3 seconds?

regards

Jared 

[pavan_142297]

hi Jared,

 please check the configuration, I am sharing here,

static void saadc_sampling_event_init(void)
{
    ret_code_t err_code;

    err_code = nrf_drv_ppi_init();
    APP_ERROR_CHECK(err_code);

    nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
    timer_cfg.bit_width = NRF_TIMER_BIT_WIDTH_32;

    err_code = nrf_drv_timer_init(&m_timer, &timer_cfg, timer_handler);
    APP_ERROR_CHECK(err_code);
  

    /* setup m_timer for compare event every 400ms */
    uint32_t ticks = nrf_drv_timer_us_to_ticks(&m_timer, 200);

    nrf_drv_timer_extended_compare(&m_timer,
                                   NRF_TIMER_CC_CHANNEL0,
                                   ticks,
                                   NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK,
                                   false);  
    nrf_drv_timer_enable(&m_timer);    
    uint32_t timer_compare_event_addr = nrf_drv_timer_compare_event_address_get(&m_timer, NRF_TIMER_CC_CHANNEL0);       
    uint32_t saadc_sample_task_addr   = nrf_drv_saadc_sample_task_get();
    /* setup ppi channel so that timer compare event is triggering sample task in SAADC */
    err_code = nrf_drv_ppi_channel_alloc(&m_ppi_channel);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_ppi_channel_assign(m_ppi_channel,
                                          timer_compare_event_addr,
                                          saadc_sample_task_addr);
}

static void saadc_sampling_event_enable(void)
{
    ret_code_t err_code;
    err_code = nrf_drv_ppi_channel_enable(m_ppi_channel);
    APP_ERROR_CHECK(err_code);
}


static void saadc_sampling_event_disable(void)
{
 ret_code_t err_code;
 err_code = nrf_drv_ppi_channel_disable(m_ppi_channel);
  APP_ERROR_CHECK(err_code);
}

static void saadc_callback(nrf_drv_saadc_evt_t const * p_event)
{
    if (p_event->type == NRF_DRV_SAADC_EVT_DONE)
    {
       ret_code_t err_code;

       err_code = nrf_drv_saadc_buffer_convert(p_event->data.done.p_buffer, SAMPLES_IN_BUFFER);
       APP_ERROR_CHECK(err_code);

       int i,j;
       switch(ADCChannel)
      { 
        case Vchannel:
            for(i=0;i<=SAMPLE_COUNT;i+=4)
              {
                 adc_data[adc_count]= p_event->data.done.p_buffer[i]-voltage_thershold_value;
                 adc_count+=1;
               }
             break;
       case Cchannel0:
             for(i=0;i<=SAMPLE_COUNT;i+=4)
              {
                 adc_data[adc_count]= p_event->data.done.p_buffer[i+1]-current_thershold_value;
                 adc_count+=1;
               }
             break;
       case Cchannel1:
              for(i=0;i<=SAMPLE_COUNT;i+=4)
              {
                 adc_data[adc_count]= p_event->data.done.p_buffer[i+2]-current_thershold_value;
                 adc_count+=1;
               }
             break;
       case Cchannel2:
              for(i=0;i<=SAMPLE_COUNT;i+=4)
              {
                 adc_data[adc_count]= p_event->data.done.p_buffer[i+3]-current_thershold_value;
                 adc_count+=1;
               }
             break;

      }
       }
        if(adc_count>=BUFFER_COUNT)
       {
       start_calc = 1;
       adc_count =0;
       }
    }



static void saadc_init(void)
{
    ret_code_t err_code;

    nrf_saadc_channel_config_t channel_config =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN2);    //P0.04

   nrf_saadc_channel_config_t channel_config1 =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN4);    //P0.28

    nrf_saadc_channel_config_t channel_config2 =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN6);    //P0.30

    nrf_saadc_channel_config_t channel_config3 =
        NRF_DRV_SAADC_DEFAULT_CHANNEL_CONFIG_SE(NRF_SAADC_INPUT_AIN3);    //P0.05

    err_code = nrf_drv_saadc_init(NULL, saadc_callback);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_channel_init(0, &channel_config);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_channel_init(1, &channel_config1);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_channel_init(2, &channel_config2);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_channel_init(3, &channel_config3);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[0], SAMPLES_IN_BUFFER);
    APP_ERROR_CHECK(err_code);
    err_code = nrf_drv_saadc_buffer_convert(m_buffer_pool[1], SAMPLES_IN_BUFFER);
    APP_ERROR_CHECK(err_code);
}

Regards,

pavan

[Jared]

The code looks somewhat ok.  What point do you measure 2-3 seconds from?