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? 

[pavan_142297]

Hi,

We are trying to measure 240VAC 50Hz supply and also Current being consumed using a CT. 

240VAC is dropped down and oscillates between 600mV to 1.8V with 50Hz frequency using a resistor bank & a capacitor filter. Each cycle of our 50Hz signal is 20ms. This AC signal is being read by an ADC of nRF52810. But I observed that when voltage is being increased or decreased nordic chip is taking time to reflect those signal changes.

[Jared]

pavan_142297 said:

But I observed that when voltage is being increased or decreased nordic chip is taking time to reflect those signal changes.

The supply voltage of the nRF52 or the measured voltage? Also, how do you measure the elapsed time it takes to take a sample?