RE: ADC + BLE IN ADC

pavan_142297 — Sat, 30 Oct 2021 10:00:49 GMT

Hi,

If there is an increment or decrement in the measuring voltage signal, those changes are being reflected with some delay.

Sensing signal before conversion

Sensing signal after conversion

We are trying to measure this signal using nordic ADC and we need help on collecting 250-500 samples of this wave in (full cycle) 20ms time.

RE: ADC + BLE IN ADC

Jared — Fri, 29 Oct 2021 12:45:08 GMT

[quote user="pavan_142297"] But I observed that when voltage is being increased or decreased nordic chip is taking time to reflect those signal changes.[/quote]

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

RE: ADC + BLE IN ADC

pavan_142297 — Fri, 29 Oct 2021 11:43:08 GMT

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.

RE: ADC + BLE IN ADC

Jared — Thu, 28 Oct 2021 12:06:04 GMT

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

RE: ADC + BLE IN ADC

pavan_142297 — Thu, 28 Oct 2021 08:47:51 GMT

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

RE: ADC + BLE IN ADC

Jared — Wed, 04 Aug 2021 12:13:25 GMT

Hi,

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

regards

Jared